Changeset 1703 for trunk/src

Timestamp:

Nov 11, 1999, 2:16:40 PM (26 years ago)

Author:

sandervl

Message:

font changes + fixes

Location:

trunk/src/gdi32

Files:

• font.cpp (modified) (16 diffs)
• gdi32.cpp (modified) (204 diffs)

trunk/src/gdi32/font.cpp

@@ -1 @@
-/* $Id: font.cpp,v 1.4 1999-11-10 23:30:45 phaller Exp $ */
+/* $Id: font.cpp,v 1.5 1999-11-11 13:16:40 sandervl Exp $ */
 
 /*
@@ -5 +5 @@
  *
  * Copyright 1999 Edgar Buerkle (Edgar.Buerkle@gmx.ne)
- * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
+ * Copyright 1999 Sander van Leeuwen (sandervl@xs4all.nl)
  * Copyright 1998 Patrick Haller
  *
- * TODO: EnumFontsA/W, EnumFontFamiliesExA/W + others
+ * TODO: EnumFontsA/W, EnumFontFamiliesExA/W not complete
+ *
+ * Parts based on Wine code (991031)
+ *
+ * Copyright 1993 Alexandre Julliard
+ *           1997 Alex Korobka
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -24 +29 @@
 #include "misc.h"
 #include "unicode.h"
-#include <vmutex.h>
 #include <heapstring.h>
 #include <win\options.h>
@@ -32 +36 @@
 
 
-VMutex mutexProcWinA;
-VMutex mutexProcWinW;
-FONTENUMPROCA FontEnumProcWinA;
-FONTENUMPROCW FontEnumProcWinW;
-
+typedef struct {
+        DWORD userProc;
+        DWORD userData;
+        DWORD dwFlags;
+} ENUMUSERDATA;
+
+/*
+ *  For TranslateCharsetInfo
+ */
+#define FS(x) {{0,0,0,0},{0x1<<(x),0}}
+#define MAXTCIINDEX 32
+static CHARSETINFO FONT_tci[MAXTCIINDEX] = {
+  /* ANSI */
+  { ANSI_CHARSET, 1252, FS(0)},
+  { EASTEUROPE_CHARSET, 1250, FS(1)},
+  { RUSSIAN_CHARSET, 1251, FS(2)},
+  { GREEK_CHARSET, 1253, FS(3)},
+  { TURKISH_CHARSET, 1254, FS(4)},
+  { HEBREW_CHARSET, 1255, FS(5)},
+  { ARABIC_CHARSET, 1256, FS(6)},
+  { BALTIC_CHARSET, 1257, FS(7)},
+  /* reserved by ANSI */
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  /* ANSI and OEM */
+  { THAI_CHARSET,  874,  FS(16)},
+  { SHIFTJIS_CHARSET, 932, FS(17)},
+  { GB2312_CHARSET, 936, FS(18)},
+  { HANGEUL_CHARSET, 949, FS(19)},
+  { CHINESEBIG5_CHARSET, 950, FS(20)},
+  { JOHAB_CHARSET, 1361, FS(21)}, 
+  /* reserved for alternate ANSI and OEM */
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+  /* reserved for system */
+  { DEFAULT_CHARSET, 0, FS(0)},
+  { DEFAULT_CHARSET, 0, FS(0)},
+};
 
 /*****************************************************************************
@@ -204 +253 @@
   HFONT    hfont;
 
-  //memcpy(&afont, lplf, ((int)&afont.lfFaceName - (int)&afont));
+  //memcpy(&afont, lplf, ((ULONG)&afont.lfFaceName - (ULONG)&afont));
   memcpy(&afont, lplf, sizeof(LOGFONTA));
   memset(afont.lfFaceName, 0, LF_FACESIZE);
@@ -214 +263 @@
 //******************************************************************************
 int  EXPENTRY_O32 EnumFontProcA(LPENUMLOGFONTA lpLogFont, LPNEWTEXTMETRICA
-                                lpTextM, DWORD arg3, LPARAM arg4)
-{
-  return FontEnumProcWinA(lpLogFont, lpTextM, arg3, arg4);
+                                   lpTextM, DWORD arg3, LPARAM arg4)
+{
+ ENUMUSERDATA *lpEnumData = (ENUMUSERDATA *)arg4;
+ FONTENUMPROCA proc = (FONTENUMPROCA)lpEnumData->userProc; 
+
+  return proc(lpLogFont, lpTextM, arg3, lpEnumData->userData);
 }
 //******************************************************************************
 //******************************************************************************
 int  EXPENTRY_O32 EnumFontProcW(LPENUMLOGFONTA lpLogFont, LPNEWTEXTMETRICA lpTextM,
-                                DWORD arg3, LPARAM arg4)
-{
-  ENUMLOGFONTW LogFont;
-  int rc;
-
-  memcpy(&LogFont, lpLogFont, ((int)&LogFont.elfLogFont.lfFaceName -
-         (int)&LogFont));
+                                   DWORD arg3, LPARAM arg4)
+{
+ ENUMUSERDATA *lpEnumData = (ENUMUSERDATA *)arg4;
+ FONTENUMPROCW proc = (FONTENUMPROCW)lpEnumData->userProc; 
+ ENUMLOGFONTW LogFont;
+ NEWTEXTMETRICW textM;
+ int rc;
+
+  memcpy(&LogFont, lpLogFont, ((ULONG)&LogFont.elfLogFont.lfFaceName -
+         (ULONG)&LogFont));
   AsciiToUnicodeN(lpLogFont->elfLogFont.lfFaceName, LogFont.elfLogFont.lfFaceName, LF_FACESIZE-1);
   AsciiToUnicodeN((char *) lpLogFont->elfFullName, LogFont.elfFullName, LF_FULLFACESIZE-1);
   AsciiToUnicodeN((char *) lpLogFont->elfStyle, LogFont.elfStyle, LF_FACESIZE-1);
 
-  rc = FontEnumProcWinW(&LogFont, (LPNEWTEXTMETRICW) lpTextM, arg3, arg4);
-  return rc;
+  textM.tmHeight = lpTextM->tmHeight;
+  textM.tmAscent = lpTextM->tmAscent;
+  textM.tmDescent = lpTextM->tmDescent;
+  textM.tmInternalLeading = lpTextM->tmInternalLeading;
+  textM.tmExternalLeading = lpTextM->tmExternalLeading;
+  textM.tmAveCharWidth = lpTextM->tmAveCharWidth;
+  textM.tmMaxCharWidth = lpTextM->tmMaxCharWidth;
+  textM.tmWeight = lpTextM->tmWeight;
+  textM.tmOverhang = lpTextM->tmOverhang;
+  textM.tmDigitizedAspectX = lpTextM->tmDigitizedAspectX;
+  textM.tmDigitizedAspectY = lpTextM->tmDigitizedAspectY;
+  textM.tmFirstChar = lpTextM->tmFirstChar;
+  textM.tmLastChar = lpTextM->tmLastChar;
+  textM.tmDefaultChar = lpTextM->tmDefaultChar;
+  textM.tmBreakChar = lpTextM->tmBreakChar;
+  textM.tmItalic = lpTextM->tmItalic;
+  textM.tmUnderlined = lpTextM->tmUnderlined;
+  textM.tmStruckOut = lpTextM->tmStruckOut;
+  textM.tmPitchAndFamily = lpTextM->tmPitchAndFamily;
+  textM.tmCharSet = lpTextM->tmCharSet;
+  textM.ntmFlags = 0;
+  textM.ntmSizeEM = 0;
+  textM.ntmCellHeight = 0;
+  textM.ntmAvgWidth = 0;
+
+  return proc(&LogFont, &textM, arg3, lpEnumData->userData);
+}
+//******************************************************************************
+//TODO: FontEnumdwFlagsEx, script, font signature & NEWTEXTMETRICEX (last part)
+//******************************************************************************
+int  EXPENTRY_O32 EnumFontProcExA(LPENUMLOGFONTA lpLogFont, LPNEWTEXTMETRICA
+                                     lpTextM, DWORD arg3, LPARAM arg4)
+{
+ ENUMUSERDATA *lpEnumData = (ENUMUSERDATA *)arg4;
+ FONTENUMPROCEXA proc = (FONTENUMPROCEXA)lpEnumData->userProc; 
+ ENUMLOGFONTEXA logFont;
+ NEWTEXTMETRICEXA textM;
+
+  memcpy(&logFont, lpLogFont, sizeof(ENUMLOGFONTA));
+  memset(logFont.elfScript, 0, sizeof(logFont.elfScript));
+  memcpy(&textM.ntmetm, lpTextM, sizeof(textM.ntmetm));
+  memset(&textM.ntmeFontSignature, 0, sizeof(textM.ntmeFontSignature));
+
+  return proc(&logFont, &textM, arg3, lpEnumData->userData);
+}
+//******************************************************************************
+//TODO: FontEnumdwFlagsEx, script, font signature & NEWTEXTMETRICEX (last part)
+//******************************************************************************
+int EXPENTRY_O32 EnumFontProcExW(LPENUMLOGFONTA lpLogFont, LPNEWTEXTMETRICA lpTextM,
+                                    DWORD arg3, LPARAM arg4)
+{
+ ENUMUSERDATA *lpEnumData = (ENUMUSERDATA *)arg4;
+ FONTENUMPROCEXW proc = (FONTENUMPROCEXW)lpEnumData->userProc; 
+ ENUMLOGFONTEXW LogFont;
+ NEWTEXTMETRICEXW textM;
+ int rc;
+
+  memcpy(&LogFont, lpLogFont, ((ULONG)&LogFont.elfLogFont.lfFaceName - (ULONG)&LogFont));
+  memset(LogFont.elfScript, 0, sizeof(LogFont.elfScript));
+  AsciiToUnicodeN(lpLogFont->elfLogFont.lfFaceName, LogFont.elfLogFont.lfFaceName, LF_FACESIZE-1);
+  AsciiToUnicodeN((char *) lpLogFont->elfFullName, LogFont.elfFullName, LF_FULLFACESIZE-1);
+  AsciiToUnicodeN((char *) lpLogFont->elfStyle, LogFont.elfStyle, LF_FACESIZE-1);
+
+  textM.ntmetm.tmHeight = lpTextM->tmHeight;
+  textM.ntmetm.tmAscent = lpTextM->tmAscent;
+  textM.ntmetm.tmDescent = lpTextM->tmDescent;
+  textM.ntmetm.tmInternalLeading = lpTextM->tmInternalLeading;
+  textM.ntmetm.tmExternalLeading = lpTextM->tmExternalLeading;
+  textM.ntmetm.tmAveCharWidth = lpTextM->tmAveCharWidth;
+  textM.ntmetm.tmMaxCharWidth = lpTextM->tmMaxCharWidth;
+  textM.ntmetm.tmWeight = lpTextM->tmWeight;
+  textM.ntmetm.tmOverhang = lpTextM->tmOverhang;
+  textM.ntmetm.tmDigitizedAspectX = lpTextM->tmDigitizedAspectX;
+  textM.ntmetm.tmDigitizedAspectY = lpTextM->tmDigitizedAspectY;
+  textM.ntmetm.tmFirstChar = lpTextM->tmFirstChar;
+  textM.ntmetm.tmLastChar = lpTextM->tmLastChar;
+  textM.ntmetm.tmDefaultChar = lpTextM->tmDefaultChar;
+  textM.ntmetm.tmBreakChar = lpTextM->tmBreakChar;
+  textM.ntmetm.tmItalic = lpTextM->tmItalic;
+  textM.ntmetm.tmUnderlined = lpTextM->tmUnderlined;
+  textM.ntmetm.tmStruckOut = lpTextM->tmStruckOut;
+  textM.ntmetm.tmPitchAndFamily = lpTextM->tmPitchAndFamily;
+  textM.ntmetm.tmCharSet = lpTextM->tmCharSet;
+  textM.ntmetm.ntmFlags = 0;
+  textM.ntmetm.ntmSizeEM = 0;
+  textM.ntmetm.ntmCellHeight = 0;
+  textM.ntmetm.ntmAvgWidth = 0;
+  memset(&textM.ntmeFontSignature, 0, sizeof(textM.ntmeFontSignature));
+
+  return proc(&LogFont, &textM, arg3, lpEnumData->userData);
 }
 //******************************************************************************
@@ -239 +382 @@
 int WIN32API EnumFontsA( HDC arg1, LPCSTR arg2, FONTENUMPROCA arg3, LPARAM  arg4)
 {
-    dprintf(("GDI32: OS2EnumFontsA"));
-//    return O32_EnumFonts(arg1, arg2, arg3, arg4);
-    return 1;
-}
-//******************************************************************************
-//TODO: Callback
+  return EnumFontFamiliesA(arg1, arg2, arg3, arg4);
+}
+//******************************************************************************
 //******************************************************************************
 int WIN32API EnumFontsW( HDC arg1, LPCWSTR arg2, FONTENUMPROCW arg3, LPARAM  arg4)
 {
-    dprintf(("GDI32: OS2EnumFontsW - stub (1)"));
-    // NOTE: This will not work as is (needs UNICODE support)
-//    return O32_EnumFonts(arg1, arg2, arg3, arg4);
-    return 1;
+  return EnumFontFamiliesW(arg1, arg2, arg3, arg4);
 }
 //******************************************************************************
@@ -260 +397 @@
                                LPARAM       arg4)
 {
+  ENUMUSERDATA enumData;
   int rc;
 
-  dprintf(("GDI32: OS2EnumFontFamiliesA "));
-
-  mutexProcWinA.enter();
-
-  FontEnumProcWinA = arg3;
-
-  rc = O32_EnumFontFamilies(arg1, arg2, &EnumFontProcA, arg4);
-
-  mutexProcWinA.leave();
+  dprintf(("GDI32: EnumFontFamiliesA %s", arg2));
+
+  enumData.userProc = (DWORD)arg3;
+  enumData.userData = arg4;
+
+  rc = O32_EnumFontFamilies(arg1, arg2, &EnumFontProcA, (LPARAM)&enumData);
+
   return rc;
 }
@@ -280 +416 @@
                                LPARAM       arg4)
 {
+  ENUMUSERDATA enumData;
   int rc;
   char *astring = UnicodeToAsciiString((LPWSTR)arg2);
 
-  dprintf(("GDI32: OS2EnumFontFamiliesW "));
-
-  mutexProcWinW.enter();
-
-  FontEnumProcWinW = arg3;
-
-  rc = O32_EnumFontFamilies(arg1, astring, &EnumFontProcW, arg4);
-
-  mutexProcWinW.leave();
+  dprintf(("GDI32: EnumFontFamiliesW %s", astring));
+
+  enumData.userProc = (DWORD)arg3;
+  enumData.userData = arg4;
+
+  rc = O32_EnumFontFamilies(arg1, astring, &EnumFontProcW, (LPARAM)&enumData);
 
   FreeAsciiString(astring);
@@ -300 +434 @@
 INT WIN32API EnumFontFamiliesExA( HDC arg1, LPLOGFONTA arg2, FONTENUMPROCEXA arg3, LPARAM  arg4, DWORD dwFlags)
 {
-    dprintf(("GDI32: OS2EnumFontFamiliesExA, not implemented\n"));
-    return 0;
+  ENUMUSERDATA enumData;
+  int rc;
+
+  dprintf(("GDI32: EnumFontFamiliesExA not complete %s", arg2->lfFaceName));
+
+  enumData.userProc = (DWORD)arg3;
+  enumData.userData = arg4;
+  enumData.dwFlags  = dwFlags;
+
+  rc = O32_EnumFontFamilies(arg1, arg2->lfFaceName, &EnumFontProcExA, (LPARAM)&enumData);
+
+  return rc;
 }
 //******************************************************************************
@@ -307 +451 @@
 INT WIN32API EnumFontFamiliesExW( HDC arg1, LPLOGFONTW arg2, FONTENUMPROCEXW arg3, LPARAM  arg4, DWORD dwFlags)
 {
-    dprintf(("GDI32: OS2EnumFontFamiliesW, not implemented\n"));
-    // NOTE: This will not work as is (needs UNICODE support)
-    return 0;
+  ENUMUSERDATA enumData;
+  int rc;
+  char *astring = UnicodeToAsciiString((LPWSTR)arg2->lfFaceName);
+
+  dprintf(("GDI32: EnumFontFamiliesExW not complete %s", astring));
+
+  enumData.userProc = (DWORD)arg3;
+  enumData.userData = arg4;
+  enumData.dwFlags  = dwFlags;
+
+  rc = O32_EnumFontFamilies(arg1, astring, &EnumFontProcExW, (LPARAM)&enumData);
+
+  FreeAsciiString(astring);
+  return rc;
 }
 //******************************************************************************
@@ -323 +478 @@
 int WIN32API AddFontResourceA( LPCSTR arg1)
 {
-    dprintf(("GDI32: OS2AddFontResourceA"));
+    dprintf(("GDI32: AddFontResourceA"));
     return O32_AddFontResource(arg1);
 }
@@ -330 +485 @@
 int WIN32API AddFontResourceW( LPCWSTR arg1)
 {
-    dprintf(("GDI32: OS2AddFontResourceW STUB"));
+    dprintf(("GDI32: AddFontResourceW STUB"));
     // NOTE: This will not work as is (needs UNICODE support)
 //    return O32_AddFontResource(arg1);
@@ -339 +494 @@
 BOOL WIN32API RemoveFontResourceA( LPCSTR arg1)
 {
-    dprintf(("GDI32: OS2RemoveFontResourceA %s\n", arg1));
+    dprintf(("GDI32: RemoveFontResourceA %s\n", arg1));
     return O32_RemoveFontResource(arg1);
 }
@@ -349 +504 @@
  BOOL  rc;
 
-    dprintf(("GDI32: OS2RemoveFontResourceW\n"));
+    dprintf(("GDI32: RemoveFontResourceW\n"));
     rc = O32_RemoveFontResource(astring);
     FreeAsciiString(astring);
@@ -436 +591 @@
   return (0);
 }
-//******************************************************************************
-//******************************************************************************
+/*************************************************************************
+ * TranslateCharsetInfo [GDI32.382]
+ *
+ * Fills a CHARSETINFO structure for a character set, code page, or
+ * font. This allows making the correspondance between different labelings
+ * (character set, Windows, ANSI, and OEM codepages, and Unicode ranges) 
+ * of the same encoding.
+ *
+ * Only one codepage will be set in lpCs->fs. If TCI_SRCFONTSIG is used,
+ * only one codepage should be set in *lpSrc.
+ *
+ * RETURNS
+ *   TRUE on success, FALSE on failure.
+ *
+ */
+BOOL WIN32API TranslateCharsetInfo(
+  LPDWORD lpSrc, /*
+       if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
+       if flags == TCI_SRCCHARSET: a character set value
+       if flags == TCI_SRCCODEPAGE: a code page value
+                 */
+  LPCHARSETINFO lpCs, /* structure to receive charset information */
+  DWORD flags /* determines interpretation of lpSrc */
+) {
+    int index = 0;
+    switch (flags) {
+    case TCI_SRCFONTSIG:
+        while (!(*lpSrc>>index & 0x0001) && index<MAXTCIINDEX) index++;
+      break;
+    case TCI_SRCCODEPAGE:
+      while ((UINT) (lpSrc) != FONT_tci[index].ciACP && index < MAXTCIINDEX) index++;
+      break;
+    case TCI_SRCCHARSET:
+      while ((UINT) (lpSrc) != FONT_tci[index].ciCharset && index < MAXTCIINDEX) index++;
+      break;
+    default:
+      return FALSE;
+    }
+    if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
+    memcpy(lpCs, &FONT_tci[index], sizeof(CHARSETINFO));
+    return TRUE;
+}
+//******************************************************************************
+//******************************************************************************

trunk/src/gdi32/gdi32.cpp

@@ -1 @@
-/* $Id: gdi32.cpp,v 1.15 1999-11-10 14:15:23 sandervl Exp $ */
+/* $Id: gdi32.cpp,v 1.16 1999-11-11 13:16:40 sandervl Exp $ */
 
 /*
@@ -477 +477 @@
 int WIN32API AbortDoc( HDC arg1)
 {
-    dprintf(("GDI32: OS2AbortDoc"));
+    dprintf(("GDI32: AbortDoc"));
     return O32_AbortDoc(arg1);
 }
@@ -484 +484 @@
 BOOL WIN32API AbortPath( HDC arg1)
 {
-    dprintf(("GDI32: OS2AbortPath"));
+    dprintf(("GDI32: AbortPath"));
     return O32_AbortPath(arg1);
 }
@@ -491 +491 @@
 BOOL WIN32API AngleArc( HDC arg1, int arg2, int arg3, DWORD arg4, float  arg5, float  arg6)
 {
-    dprintf(("GDI32: OS2AngleArc"));
+    dprintf(("GDI32: AngleArc"));
     return O32_AngleArc(arg1, arg2, arg3, arg4, arg5, arg6);
 }
@@ -498 +498 @@
 BOOL WIN32API AnimatePalette( HPALETTE arg1, UINT arg2, UINT arg3, const PALETTEENTRY * arg4)
 {
-    dprintf(("GDI32: OS2AnimatePalette"));
+    dprintf(("GDI32: AnimatePalette"));
     return O32_AnimatePalette(arg1, arg2, arg3, arg4);
 }
@@ -505 +505 @@
 BOOL WIN32API Arc( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int  arg9)
 {
-    dprintf(("GDI32: OS2Arc"));
+    dprintf(("GDI32: Arc"));
     return O32_Arc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
@@ -512 +512 @@
 BOOL WIN32API ArcTo( HDC arg1, int arg2, int arg3, int arg4, int arg5, int  arg6, int  arg7, int  arg8, int  arg9)
 {
-    dprintf(("GDI32: OS2ArcTo"));
+    dprintf(("GDI32: ArcTo"));
     return O32_ArcTo(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
@@ -519 +519 @@
 BOOL WIN32API BeginPath( HDC arg1)
 {
-    dprintf(("GDI32: OS2BeginPath"));
+    dprintf(("GDI32: BeginPath"));
     return O32_BeginPath(arg1);
 }
@@ -532 +532 @@
         }
     }
-    dprintf(("GDI32: OS2BitBlt to hdc %X from (%d,%d) to (%d,%d), (%d,%d) rop %X\n", hdcDest, arg7, arg8, arg2, arg3, arg4, arg5, arg9));
+    dprintf(("GDI32: BitBlt to hdc %X from (%d,%d) to (%d,%d), (%d,%d) rop %X\n", hdcDest, arg7, arg8, arg2, arg3, arg4, arg5, arg9));
     return O32_BitBlt(hdcDest, arg2, arg3, arg4, arg5, hdcSrc, arg7, arg8, arg9);
 }
@@ -539 +539 @@
 BOOL WIN32API Chord( HDC arg1, int arg2, int arg3, int arg4, int arg5, int  arg6, int  arg7, int  arg8, int  arg9)
 {
-    dprintf(("GDI32: OS2Chord"));
+    dprintf(("GDI32: Chord"));
     return O32_Chord(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
@@ -546 +546 @@
 HENHMETAFILE WIN32API CloseEnhMetaFile( HDC arg1)
 {
-    dprintf(("GDI32: OS2CloseEnhMetaFile"));
+    dprintf(("GDI32: CloseEnhMetaFile"));
     return O32_CloseEnhMetaFile(arg1);
 }
@@ -553 +553 @@
 BOOL WIN32API CloseFigure( HDC arg1)
 {
-    dprintf(("GDI32: OS2CloseFigure"));
+    dprintf(("GDI32: CloseFigure"));
     return O32_CloseFigure(arg1);
 }
@@ -560 +560 @@
 HMETAFILE WIN32API CloseMetaFile( HDC arg1)
 {
-    dprintf(("GDI32: OS2CloseMetaFile"));
+    dprintf(("GDI32: CloseMetaFile"));
     return O32_CloseMetaFile(arg1);
 }
@@ -567 +567 @@
 int WIN32API CombineRgn( HRGN arg1, HRGN  arg2, HRGN  arg3, int  arg4)
 {
-    dprintf(("GDI32: OS2CombineRgn"));
+    dprintf(("GDI32: CombineRgn"));
     return O32_CombineRgn(arg1, arg2, arg3, arg4);
 }
@@ -574 +574 @@
 HENHMETAFILE WIN32API CopyEnhMetaFileA( HENHMETAFILE arg1, LPCSTR  arg2)
 {
-    dprintf(("GDI32: OS2CopyEnhMetaFileA"));
+    dprintf(("GDI32: CopyEnhMetaFileA"));
     return O32_CopyEnhMetaFile(arg1, arg2);
 }
@@ -584 +584 @@
  HENHMETAFILE rc;
 
-    dprintf(("GDI32: OS2CopyEnhMetaFileW"));
+    dprintf(("GDI32: CopyEnhMetaFileW"));
     rc = O32_CopyEnhMetaFile(arg1, astring);
     FreeAsciiString(astring);
@@ -593 +593 @@
 HMETAFILE WIN32API CopyMetaFileA( HMETAFILE arg1, LPCSTR  arg2)
 {
-    dprintf(("GDI32: OS2CopyMetaFileA"));
+    dprintf(("GDI32: CopyMetaFileA"));
     return O32_CopyMetaFile(arg1, arg2);
 }
@@ -603 +603 @@
  HMETAFILE rc;
 
-    dprintf(("GDI32: OS2CopyMetaFileW"));
+    dprintf(("GDI32: CopyMetaFileW"));
     rc = O32_CopyMetaFile(arg1, astring);
     FreeAsciiString(astring);
@@ -616 +616 @@
 
     rc = O32_CreateBitmap(nWidth, nHeight, cPlanes, cBitsPerPel, lpvBits);
-    dprintf(("GDI32: OS2CreateBitmap (%d,%d) bps %d returned %d\n", nWidth, nHeight, cBitsPerPel, rc));
+    dprintf(("GDI32: CreateBitmap (%d,%d) bps %d returned %d\n", nWidth, nHeight, cBitsPerPel, rc));
     return(rc);
 }
@@ -623 +623 @@
 HBITMAP WIN32API CreateBitmapIndirect( const BITMAP * arg1)
 {
-    dprintf(("GDI32: OS2CreateBitmapIndirect"));
+    dprintf(("GDI32: CreateBitmapIndirect"));
     return O32_CreateBitmapIndirect(arg1);
 }
@@ -630 +630 @@
 HBRUSH WIN32API CreateBrushIndirect( const LOGBRUSH * arg1)
 {
-    dprintf(("GDI32: OS2CreateBrushIndirect"));
+    dprintf(("GDI32: CreateBrushIndirect"));
     return O32_CreateBrushIndirect((LPLOGBRUSH)arg1);
 }
@@ -637 +637 @@
 HDC WIN32API CreateDCA( LPCSTR arg1, LPCSTR arg2, LPCSTR arg3, const DEVMODEA * arg4)
 {
-    dprintf(("GDI32: OS2CreateDCA"));
+    dprintf(("GDI32: CreateDCA"));
     return O32_CreateDC(arg1, arg2, arg3, arg4);
 }
@@ -644 +644 @@
 HDC WIN32API CreateDCW( LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3, const DEVMODEW * arg4)
 {
-    dprintf(("GDI32: OS2CreateDCW STUB"));
+    dprintf(("GDI32: CreateDCW STUB"));
     // NOTE: This will not work as is (needs UNICODE support)
 //    return O32_CreateDC(arg1, arg2, arg3, arg4);
@@ -653 +653 @@
 HRGN WIN32API CreateEllipticRgn( int arg1, int arg2, int arg3, int  arg4)
 {
-    dprintf(("GDI32: OS2CreateEllipticRgn"));
+    dprintf(("GDI32: CreateEllipticRgn"));
     return O32_CreateEllipticRgn(arg1, arg2, arg3, arg4);
 }
@@ -660 +660 @@
 HRGN WIN32API CreateEllipticRgnIndirect( const RECT * arg1)
 {
-    dprintf(("GDI32: OS2CreateEllipticRgnIndirect"));
+    dprintf(("GDI32: CreateEllipticRgnIndirect"));
     return O32_CreateEllipticRgnIndirect(arg1);
 }
@@ -667 +667 @@
 HENHMETAFILE WIN32API CreateEnhMetaFileA( HDC arg1, LPCSTR arg2, const RECT * arg3, LPCSTR  arg4)
 {
-    dprintf(("GDI32: OS2CreateEnhMetaFileA"));
+    dprintf(("GDI32: CreateEnhMetaFileA"));
     return O32_CreateEnhMetaFile(arg1, arg2, arg3, arg4);
 }
@@ -674 +674 @@
 HENHMETAFILE WIN32API CreateEnhMetaFileW( HDC arg1, LPCWSTR arg2, const RECT * arg3, LPCWSTR  arg4)
 {
-    dprintf(("GDI32: OS2CreateEnhMetaFileW STUB"));
+    dprintf(("GDI32: CreateEnhMetaFileW STUB"));
     // NOTE: This will not work as is (needs UNICODE support)
 //    return O32_CreateEnhMetaFile(arg1, arg2, arg3, arg4);
@@ -685 +685 @@
 HBRUSH WIN32API CreateHatchBrush( int arg1, COLORREF  arg2)
 {
-    dprintf(("GDI32: OS2CreateHatchBrush"));
+    dprintf(("GDI32: CreateHatchBrush"));
     return O32_CreateHatchBrush(arg1, arg2);
 }
@@ -692 +692 @@
 HDC WIN32API CreateICA( LPCSTR arg1, LPCSTR arg2, LPCSTR arg3, const DEVMODEA * arg4)
 {
-    dprintf(("GDI32: OS2CreateICA"));
+    dprintf(("GDI32: CreateICA"));
     return O32_CreateIC(arg1, arg2, arg3, arg4);
 }
@@ -699 +699 @@
 HDC WIN32API CreateICW( LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3, const DEVMODEW * arg4)
 {
-    dprintf(("GDI32: OS2CreateICW STUB"));
+    dprintf(("GDI32: CreateICW STUB"));
     // NOTE: This will not work as is (needs UNICODE support)
 //    return O32_CreateIC(arg1, arg2, arg3, arg4);
@@ -708 +708 @@
 HDC WIN32API CreateMetaFileA( LPCSTR arg1)
 {
-    dprintf(("GDI32: OS2CreateMetaFileA"));
+    dprintf(("GDI32: CreateMetaFileA"));
     return O32_CreateMetaFile(arg1);
 }
@@ -718 +718 @@
  HDC   rc;
 
-    dprintf(("GDI32: OS2CreateMetaFileW"));
+    dprintf(("GDI32: CreateMetaFileW"));
     rc = O32_CreateMetaFile(astring);
     FreeAsciiString(astring);
@@ -727 +727 @@
 HRGN WIN32API CreateRectRgn( int arg1, int arg2, int arg3, int  arg4)
 {
-    dprintf(("GDI32: OS2CreateRectRgn"));
+    dprintf(("GDI32: CreateRectRgn"));
     return O32_CreateRectRgn(arg1, arg2, arg3, arg4);
 }
@@ -734 +734 @@
 HRGN WIN32API CreateRectRgnIndirect( const RECT * arg1)
 {
-    dprintf(("GDI32: OS2CreateRectRgnIndirect"));
+    dprintf(("GDI32: CreateRectRgnIndirect"));
     return O32_CreateRectRgnIndirect(arg1);
 }
@@ -741 +741 @@
 HRGN WIN32API CreateRoundRectRgn( int arg1, int arg2, int arg3, int arg4, int arg5, int  arg6)
 {
-    dprintf(("GDI32: OS2CreateRoundRectRgn"));
+    dprintf(("GDI32: CreateRoundRectRgn"));
     return O32_CreateRoundRectRgn(arg1, arg2, arg3, arg4, arg5, arg6);
 }
@@ -748 +748 @@
 HBRUSH WIN32API CreateSolidBrush( COLORREF arg1)
 {
-    dprintf(("GDI32: OS2CreateSolidBrush\n"));
+    dprintf(("GDI32: CreateSolidBrush\n"));
     return O32_CreateSolidBrush(arg1);
 }
@@ -755 +755 @@
 BOOL WIN32API DPtoLP( HDC arg1, PPOINT arg2, int  arg3)
 {
-    dprintf(("GDI32: OS2DPtoLP\n"));
+    dprintf(("GDI32: DPtoLP\n"));
     return O32_DPtoLP(arg1, arg2, arg3);
 }
@@ -762 +762 @@
 BOOL WIN32API DeleteEnhMetaFile( HENHMETAFILE arg1)
 {
-    dprintf(("GDI32: OS2DeleteEnhMetaFile\n"));
+    dprintf(("GDI32: DeleteEnhMetaFile\n"));
     return O32_DeleteEnhMetaFile(arg1);
 }
@@ -769 +769 @@
 BOOL WIN32API DeleteMetaFile( HMETAFILE arg1)
 {
-    dprintf(("GDI32: OS2DeleteMetaFile"));
+    dprintf(("GDI32: DeleteMetaFile"));
     return O32_DeleteMetaFile(arg1);
 }
@@ -776 +776 @@
 BOOL WIN32API Ellipse( HDC arg1, int arg2, int arg3, int arg4, int  arg5)
 {
-    dprintf(("GDI32: OS2Ellipse"));
+    dprintf(("GDI32: Ellipse"));
     return O32_Ellipse(arg1, arg2, arg3, arg4, arg5);
 }
@@ -783 +783 @@
 int WIN32API EndDoc( HDC arg1)
 {
-    dprintf(("GDI32: OS2EndDoc"));
+    dprintf(("GDI32: EndDoc"));
     return O32_EndDoc(arg1);
 }
@@ -790 +790 @@
 int WIN32API EndPage( HDC arg1)
 {
-    dprintf(("GDI32: OS2EndPage"));
+    dprintf(("GDI32: EndPage"));
     return O32_EndPage(arg1);
 }
@@ -797 +797 @@
 BOOL WIN32API EndPath( HDC arg1)
 {
-    dprintf(("GDI32: OS2EndPath"));
+    dprintf(("GDI32: EndPath"));
     return O32_EndPath(arg1);
 }
@@ -804 +804 @@
 BOOL WIN32API EnumEnhMetaFile( HDC arg1, HENHMETAFILE arg2, ENHMFENUMPROC arg3, PVOID arg4, const RECT *  arg5)
 {
-    dprintf(("GDI32: OS2EnumEnhMetaFile DOESN'T WORK!"));
+    dprintf(("GDI32: EnumEnhMetaFile DOESN'T WORK!"));
 //    return O32_EnumEnhMetaFile(arg1, arg2, arg3, arg4, arg5);
     return 0;
@@ -810 +810 @@
 //******************************************************************************
 //******************************************************************************
-POINT OS2ToWin32LineEnd(POINT startPt,INT nXEnd,INT nYEnd)
+POINT ToWin32LineEnd(POINT startPt,INT nXEnd,INT nYEnd)
 {
   POINT pt;
@@ -859 +859 @@
   POINT oldPt,pt;
 
-  dprintf(("GDI32: OS2LineTo"));
+  dprintf(("GDI32: LineTo"));
 
   //CB: Open32 draws a pixel too much!
   GetCurrentPositionEx(hdc,&oldPt);
-  pt = OS2ToWin32LineEnd(oldPt,nXEnd,nYEnd);
+  pt = ToWin32LineEnd(oldPt,nXEnd,nYEnd);
 
   BOOL rc;
@@ -881 +881 @@
 BOOL WIN32API MoveToEx( HDC arg1, int arg2, int arg3, PPOINT  arg4)
 {
-    dprintf(("GDI32: OS2MoveToEx\n"));
+    dprintf(("GDI32: MoveToEx\n"));
     return O32_MoveToEx(arg1, arg2, arg3, arg4);
 }
@@ -891 +891 @@
 
   rc = O32_PatBlt(arg1, arg2, arg3, arg4, arg5, arg6);
-  dprintf(("GDI32: OS2PatBlt (%d,%d) (%d,%d) returned %d\n", arg2, arg3, arg4, arg5, rc));
+  dprintf(("GDI32: PatBlt (%d,%d) (%d,%d) returned %d\n", arg2, arg3, arg4, arg5, rc));
   return(rc);
 }
@@ -898 +898 @@
 BOOL WIN32API Rectangle( HDC arg1, int arg2, int arg3, int arg4, int  arg5)
 {
-    dprintf(("GDI32: OS2Rectangle\n"));
+    dprintf(("GDI32: Rectangle\n"));
     return O32_Rectangle(arg1, arg2, arg3, arg4, arg5);
 }
@@ -905 +905 @@
 int WIN32API SetROP2( HDC arg1, int  arg2)
 {
-    dprintf(("GDI32: OS2SetROP2"));
+    dprintf(("GDI32: SetROP2"));
     return O32_SetROP2(arg1, arg2);
 }
@@ -913 +913 @@
 BOOL WIN32API EnumMetaFile( HDC arg1, HMETAFILE arg2, MFENUMPROC arg3, LPARAM  arg4)
 {
-    dprintf(("GDI32: OS2EnumMetaFile STUB"));
+    dprintf(("GDI32: EnumMetaFile STUB"));
     //calling convention differences
 //    return O32_EnumMetaFile(arg1, arg2, arg3, arg4);
@@ -922 +922 @@
 int WIN32API EnumObjects( HDC arg1, int arg2, GOBJENUMPROC arg3, LPARAM  arg4)
 {
-    dprintf(("GDI32: OS2EnumObjects STUB"));
+    dprintf(("GDI32: EnumObjects STUB"));
     //calling convention differences
 //    return O32_EnumObjects(arg1, arg2, arg3, arg4);
@@ -931 +931 @@
 BOOL WIN32API EqualRgn( HRGN arg1, HRGN  arg2)
 {
-    dprintf(("GDI32: OS2EqualRgn"));
+    dprintf(("GDI32: EqualRgn"));
     return O32_EqualRgn(arg1, arg2);
 }
@@ -938 +938 @@
 int WIN32API Escape( HDC arg1, int arg2, int arg3, LPCSTR arg4, PVOID  arg5)
 {
-    dprintf(("GDI32: OS2Escape"));
+    dprintf(("GDI32: Escape"));
     return O32_Escape(arg1, arg2, arg3, arg4, arg5);
 }
@@ -945 +945 @@
 int WIN32API ExcludeClipRect( HDC arg1, int arg2, int arg3, int arg4, int  arg5)
 {
-    dprintf(("GDI32: OS2ExcludeClipRect"));
+    dprintf(("GDI32: ExcludeClipRect"));
     return O32_ExcludeClipRect(arg1, arg2, arg3, arg4, arg5);
 }
@@ -952 +952 @@
 HPEN WIN32API ExtCreatePen( DWORD arg1, DWORD arg2, const LOGBRUSH * arg3, DWORD arg4, const DWORD *  arg5)
 {
-    dprintf(("GDI32: OS2ExtCreatePen"));
+    dprintf(("GDI32: ExtCreatePen"));
     return O32_ExtCreatePen(arg1, arg2, arg3, arg4, arg5);
 }
@@ -959 +959 @@
 HRGN WIN32API ExtCreateRegion( const XFORM * arg1, DWORD arg2, const RGNDATA *  arg3)
 {
-    dprintf(("GDI32: OS2ExtCreateRegion"));
+    dprintf(("GDI32: ExtCreateRegion"));
     return O32_ExtCreateRegion(arg1, arg2, arg3);
 }
@@ -966 +966 @@
 BOOL WIN32API ExtFloodFill( HDC arg1, int arg2, int arg3, COLORREF arg4, UINT  arg5)
 {
-    dprintf(("GDI32: OS2ExtFloodFill"));
+    dprintf(("GDI32: ExtFloodFill"));
     return O32_ExtFloodFill(arg1, arg2, arg3, arg4, arg5);
 }
@@ -973 +973 @@
 int WIN32API ExtSelectClipRgn( HDC arg1, HRGN arg2, int  arg3)
 {
-    dprintf(("GDI32: OS2ExtSelectClipRgn"));
+    dprintf(("GDI32: ExtSelectClipRgn"));
     return O32_ExtSelectClipRgn(arg1, arg2, arg3);
 }
@@ -986 +986 @@
 
     if(lprc)
-            dprintf(("GDI32: OS2ExtTextOutW (%d,%d) %X, (%d,%d)(%d,%d)\n", X, Y, fuOptions, lprc->left, lprc->top, lprc->right, lprc->bottom));
-    else    dprintf(("GDI32: OS2ExtTextOutW (%d,%d) %X\n", X, Y, fuOptions));
+            dprintf(("GDI32: ExtTextOutW (%d,%d) %X, (%d,%d)(%d,%d)\n", X, Y, fuOptions, lprc->left, lprc->top, lprc->right, lprc->bottom));
+    else    dprintf(("GDI32: ExtTextOutW (%d,%d) %X\n", X, Y, fuOptions));
     rc = O32_ExtTextOut(hdc, X, Y, fuOptions, lprc, astring, cbCount, lpDx);
-    dprintf(("GDI32: OS2ExtTextOutW %s (%X) length %d rc %d\n", astring, lpString, cbCount, rc));
+    dprintf(("GDI32: ExtTextOutW %s (%X) length %d rc %d\n", astring, lpString, cbCount, rc));
     FreeAsciiString(astring);
     return(rc);
@@ -997 +997 @@
 BOOL WIN32API FillPath( HDC arg1)
 {
-    dprintf(("GDI32: OS2FillPath"));
+    dprintf(("GDI32: FillPath"));
     return O32_FillPath(arg1);
 }
@@ -1004 +1004 @@
 BOOL WIN32API FillRgn( HDC arg1, HRGN arg2, HBRUSH  arg3)
 {
-    dprintf(("GDI32: OS2FillRgn"));
+    dprintf(("GDI32: FillRgn"));
     return O32_FillRgn(arg1, arg2, arg3);
 }
@@ -1011 +1011 @@
 BOOL WIN32API FlattenPath( HDC arg1)
 {
-    dprintf(("GDI32: OS2FlattenPath"));
+    dprintf(("GDI32: FlattenPath"));
     return O32_FlattenPath(arg1);
 }
@@ -1018 +1018 @@
 BOOL WIN32API FloodFill(HDC arg1, int arg2, int arg3, COLORREF  arg4)
 {
-    dprintf(("GDI32: OS2FloodFill"));
+    dprintf(("GDI32: FloodFill"));
     return O32_FloodFill(arg1, arg2, arg3, arg4);
 }
@@ -1025 +1025 @@
 BOOL WIN32API FrameRgn( HDC arg1, HRGN arg2, HBRUSH arg3, int arg4, int  arg5)
 {
-    dprintf(("GDI32: OS2FrameRgn"));
+    dprintf(("GDI32: FrameRgn"));
     return O32_FrameRgn(arg1, arg2, arg3, arg4, arg5);
 }
@@ -1032 +1032 @@
 int WIN32API GetArcDirection( HDC arg1)
 {
-    dprintf(("GDI32: OS2GetArcDirection"));
+    dprintf(("GDI32: GetArcDirection"));
     return O32_GetArcDirection(arg1);
 }
@@ -1039 +1039 @@
 BOOL WIN32API GetAspectRatioFilterEx( HDC arg1, PSIZE  arg2)
 {
-    dprintf(("GDI32: OS2GetAspectRatioFilterEx"));
+    dprintf(("GDI32: GetAspectRatioFilterEx"));
     return O32_GetAspectRatioFilterEx(arg1, arg2);
 }
@@ -1046 +1046 @@
 LONG WIN32API GetBitmapBits( HBITMAP arg1, LONG arg2, PVOID  arg3)
 {
-    dprintf(("GDI32: OS2GetBitmapBits"));
+    dprintf(("GDI32: GetBitmapBits"));
     return O32_GetBitmapBits(arg1, arg2, arg3);
 }
@@ -1053 +1053 @@
 BOOL WIN32API GetBitmapDimensionEx( HBITMAP arg1, PSIZE  arg2)
 {
-    dprintf(("GDI32: OS2GetBitmapDimensionEx"));
+    dprintf(("GDI32: GetBitmapDimensionEx"));
     return O32_GetBitmapDimensionEx(arg1, arg2);
 }
@@ -1060 +1060 @@
 COLORREF WIN32API GetBkColor( HDC arg1)
 {
-    dprintf(("GDI32: OS2GetBkColor"));
+    dprintf(("GDI32: GetBkColor"));
     return O32_GetBkColor(arg1);
 }
@@ -1067 +1067 @@
 int WIN32API GetBkMode( HDC arg1)
 {
-    dprintf(("GDI32: OS2GetBkMode"));
+    dprintf(("GDI32: GetBkMode"));
     return O32_GetBkMode(arg1);
 }
@@ -1074 +1074 @@
 UINT WIN32API GetBoundsRect( HDC arg1, PRECT arg2, UINT  arg3)
 {
-    dprintf(("GDI32: OS2GetBoundsRect"));
+    dprintf(("GDI32: GetBoundsRect"));
     return O32_GetBoundsRect(arg1, arg2, arg3);
 }
@@ -1081 +1081 @@
 BOOL WIN32API GetBrushOrgEx( HDC arg1, PPOINT  arg2)
 {
-    dprintf(("GDI32: OS2GetBrushOrgEx"));
+    dprintf(("GDI32: GetBrushOrgEx"));
     return O32_GetBrushOrgEx(arg1, arg2);
 }
@@ -1088 +1088 @@
 BOOL WIN32API GetCharABCWidthsA( HDC arg1, UINT arg2, UINT arg3, LPABC arg4)
 {
-    dprintf(("GDI32: OS2GetCharABCWidthsA"));
+    dprintf(("GDI32: GetCharABCWidthsA"));
     return O32_GetCharABCWidths(arg1, arg2, arg3, arg4);
 }
@@ -1095 +1095 @@
 BOOL WIN32API GetCharABCWidthsW( HDC arg1, UINT arg2, UINT arg3, LPABC arg4)
 {
-    dprintf(("GDI32: OS2GetCharABCWidthsW not properly implemented."));
+    dprintf(("GDI32: GetCharABCWidthsW not properly implemented."));
     // NOTE: This will not work as is (needs UNICODE support)
     return O32_GetCharABCWidths(arg1, arg2, arg3, arg4);
@@ -1103 +1103 @@
 BOOL WIN32API GetCharWidthA( HDC arg1, UINT arg2, UINT arg3, PINT  arg4)
 {
-    dprintf(("GDI32: OS2GetCharWidthA"));
+    dprintf(("GDI32: GetCharWidthA"));
     return O32_GetCharWidth(arg1, arg2, arg3, arg4);
 }
@@ -1111 +1111 @@
 BOOL WIN32API GetCharWidthW(HDC arg1, UINT iFirstChar, UINT iLastChar, PINT  arg4)
 {
-    dprintf(("GDI32: OS2GetCharWidthW, not properly implemented"));
+    dprintf(("GDI32: GetCharWidthW, not properly implemented"));
     return O32_GetCharWidth(arg1, iFirstChar, iLastChar, arg4);
 }
@@ -1121 +1121 @@
 
   rc = O32_GetClipBox(arg1, arg2);
-  dprintf(("GDI32: OS2GetClipBox of %X returned %d\n", arg1, rc));
+  dprintf(("GDI32: GetClipBox of %X returned %d\n", arg1, rc));
   return(rc);
 }
@@ -1128 +1128 @@
 int WIN32API GetClipRgn( HDC arg1, HRGN  arg2)
 {
-    dprintf(("GDI32: OS2GetClipRgn"));
+    dprintf(("GDI32: GetClipRgn"));
     return O32_GetClipRgn(arg1, arg2);
 }
@@ -1135 +1135 @@
 HANDLE WIN32API GetCurrentObject( HDC arg1, UINT arg2)
 {
-    dprintf(("GDI32: OS2GetCurrentObject"));
+    dprintf(("GDI32: GetCurrentObject"));
     return (HANDLE)O32_GetCurrentObject(arg1, arg2);
 }
@@ -1142 +1142 @@
 BOOL WIN32API GetCurrentPositionEx( HDC arg1, PPOINT  arg2)
 {
-    dprintf(("GDI32: OS2GetCurrentPositionEx"));
+    dprintf(("GDI32: GetCurrentPositionEx"));
     return O32_GetCurrentPositionEx(arg1, arg2);
 }
@@ -1149 +1149 @@
 int WIN32API GetDIBits( HDC arg1, HBITMAP arg2, UINT arg3, UINT arg4, void * arg5, PBITMAPINFO arg6, UINT  arg7)
 {
-    dprintf(("GDI32: OS2GetDIBits"));
+    dprintf(("GDI32: GetDIBits"));
     return O32_GetDIBits(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 }
@@ -1159 +1159 @@
 
     rc = O32_GetDeviceCaps(hdc, nIndex);
-    dprintf(("GDI32: OS2GetDeviceCaps %X, %d returned %d\n", hdc, nIndex, rc));
+    dprintf(("GDI32: GetDeviceCaps %X, %d returned %d\n", hdc, nIndex, rc));
     //SvL: 13-9-'98: NT returns -1 when using 16 bits colors, NOT 65536!
     if(nIndex == NUMCOLORS && rc > 256)
@@ -1169 +1169 @@
 HENHMETAFILE WIN32API GetEnhMetaFileA( LPCSTR arg1)
 {
-    dprintf(("GDI32: OS2GetEnhMetaFileA"));
+    dprintf(("GDI32: GetEnhMetaFileA"));
     return O32_GetEnhMetaFile(arg1);
 }
@@ -1176 +1176 @@
 UINT WIN32API GetEnhMetaFileBits( HENHMETAFILE arg1, UINT arg2, PBYTE  arg3)
 {
-    dprintf(("GDI32: OS2GetEnhMetaFileBits"));
+    dprintf(("GDI32: GetEnhMetaFileBits"));
     return O32_GetEnhMetaFileBits(arg1, arg2, arg3);
 }
@@ -1183 +1183 @@
 UINT WIN32API GetEnhMetaFileHeader( HENHMETAFILE arg1, UINT arg2, LPENHMETAHEADER  arg3)
 {
-    dprintf(("GDI32: OS2GetEnhMetaFileHeader"));
+    dprintf(("GDI32: GetEnhMetaFileHeader"));
     return O32_GetEnhMetaFileHeader(arg1, arg2, arg3);
 }
@@ -1190 +1190 @@
 UINT WIN32API GetEnhMetaFilePaletteEntries( HENHMETAFILE arg1, UINT arg2, PPALETTEENTRY  arg3)
 {
-    dprintf(("GDI32: OS2GetEnhMetaFilePaletteEntries"));
+    dprintf(("GDI32: GetEnhMetaFilePaletteEntries"));
     return O32_GetEnhMetaFilePaletteEntries(arg1, arg2, arg3);
 }
@@ -1200 +1200 @@
  HENHMETAFILE rc;
 
-    dprintf(("GDI32: OS2GetEnhMetaFileW"));
+    dprintf(("GDI32: GetEnhMetaFileW"));
     // NOTE: This will not work as is (needs UNICODE support)
     rc = O32_GetEnhMetaFile(astring);
@@ -1210 +1210 @@
 int WIN32API GetGraphicsMode(HDC arg1)
 {
-    dprintf(("GDI32: OS2GetGraphicsMode"));
+    dprintf(("GDI32: GetGraphicsMode"));
     return O32_GetGraphicsMode(arg1);
 }
@@ -1217 +1217 @@
 DWORD WIN32API GetKerningPairsA( HDC arg1, DWORD arg2, LPKERNINGPAIR  arg3)
 {
-    dprintf(("GDI32: OS2GetKerningPairsA"));
+    dprintf(("GDI32: GetKerningPairsA"));
     return O32_GetKerningPairs(arg1, arg2, arg3);
 }
@@ -1224 +1224 @@
 DWORD WIN32API GetKerningPairsW( HDC arg1, DWORD arg2, LPKERNINGPAIR  arg3)
 {
-    dprintf(("GDI32: OS2GetKerningPairsW"));
+    dprintf(("GDI32: GetKerningPairsW"));
     // NOTE: This will not work as is (needs UNICODE support)
     return O32_GetKerningPairs(arg1, arg2, arg3);
@@ -1232 +1232 @@
 int WIN32API GetMapMode( HDC arg1)
 {
-    dprintf(("GDI32: OS2GetMapMode"));
+    dprintf(("GDI32: GetMapMode"));
     return O32_GetMapMode(arg1);
 }
@@ -1239 +1239 @@
 HMETAFILE WIN32API GetMetaFileA( LPCSTR arg1)
 {
-    dprintf(("GDI32: OS2GetMetaFileA"));
+    dprintf(("GDI32: GetMetaFileA"));
     return O32_GetMetaFile(arg1);
 }
@@ -1246 +1246 @@
 UINT WIN32API GetMetaFileBitsEx( HMETAFILE arg1, UINT arg2, LPVOID  arg3)
 {
-    dprintf(("GDI32: OS2GetMetaFileBitsEx"));
+    dprintf(("GDI32: GetMetaFileBitsEx"));
     return O32_GetMetaFileBitsEx(arg1, arg2, arg3);
 }
@@ -1256 +1256 @@
  HENHMETAFILE rc;
 
-    dprintf(("GDI32: OS2GetMetaFileW"));
+    dprintf(("GDI32: GetMetaFileW"));
     rc = O32_GetMetaFile(astring);
     FreeAsciiString(astring);
@@ -1266 +1266 @@
 BOOL WIN32API GetMiterLimit( HDC arg1, float * arg2)
 {
-    dprintf(("GDI32: OS2GetMiterLimit"));
+    dprintf(("GDI32: GetMiterLimit"));
     return O32_GetMiterLimit(arg1, arg2);
 }
@@ -1273 +1273 @@
 COLORREF WIN32API GetNearestColor( HDC arg1, COLORREF  arg2)
 {
-    dprintf(("GDI32: OS2GetNearestColor\n"));
+    dprintf(("GDI32: GetNearestColor\n"));
     return O32_GetNearestColor(arg1, arg2);
 }
@@ -1280 +1280 @@
 UINT WIN32API GetNearestPaletteIndex( HPALETTE arg1, COLORREF  arg2)
 {
-    dprintf(("GDI32: OS2GetNearestPaletteIndex\n"));
+    dprintf(("GDI32: GetNearestPaletteIndex\n"));
     return O32_GetNearestPaletteIndex(arg1, arg2);
 }
@@ -1287 +1287 @@
 int WIN32API GetObjectW( HGDIOBJ arg1, int arg2, void *  arg3)
 {
-    dprintf(("GDI32: OS2GetObjectW %X, %d %X\n", arg1, arg2, arg3));
+    dprintf(("GDI32: GetObjectW %X, %d %X\n", arg1, arg2, arg3));
     // NOTE: This will not work as is (needs UNICODE support)
     return O32_GetObject(arg1, arg2, arg3);
@@ -1295 +1295 @@
 UINT WIN32API GetOutlineTextMetricsA( HDC arg1, UINT arg2, LPOUTLINETEXTMETRICA  arg3)
 {
-    dprintf(("GDI32: OS2GetOutlineTextMetricsA"));
+    dprintf(("GDI32: GetOutlineTextMetricsA"));
     return O32_GetOutlineTextMetrics(arg1, arg2, arg3);
 }
@@ -1302 +1302 @@
 UINT WIN32API GetOutlineTextMetricsW( HDC arg1, UINT arg2, LPOUTLINETEXTMETRICW  arg3)
 {
-    dprintf(("GDI32: OS2GetOutlineTextMetricsW STUB"));
+    dprintf(("GDI32: GetOutlineTextMetricsW STUB"));
     // NOTE: This will not work as is (needs UNICODE support)
 //    return O32_GetOutlineTextMetrics(arg1, arg2, arg3);
@@ -1311 +1311 @@
 UINT WIN32API GetPaletteEntries( HPALETTE arg1, UINT arg2, UINT arg3, PPALETTEENTRY  arg4)
 {
-    dprintf(("GDI32: OS2GetPaletteEntries"));
+    dprintf(("GDI32: GetPaletteEntries"));
     return O32_GetPaletteEntries(arg1, arg2, arg3, arg4);
 }
@@ -1318 +1318 @@
 INT WIN32API GetPath( HDC arg1, PPOINT arg2, PBYTE arg3, int  arg4)
 {
-    dprintf(("GDI32: OS2GetPath"));
+    dprintf(("GDI32: GetPath"));
     return O32_GetPath(arg1, arg2, arg3, arg4);
 }
@@ -1325 +1325 @@
 int WIN32API GetPolyFillMode( HDC arg1)
 {
-    dprintf(("GDI32: OS2GetPolyFillMode"));
+    dprintf(("GDI32: GetPolyFillMode"));
     return O32_GetPolyFillMode(arg1);
 }
@@ -1332 +1332 @@
 int WIN32API GetROP2( HDC arg1)
 {
-    dprintf(("GDI32: OS2GetROP2"));
+    dprintf(("GDI32: GetROP2"));
     return O32_GetROP2(arg1);
 }
@@ -1339 +1339 @@
 BOOL WIN32API GetRasterizerCaps(LPRASTERIZER_STATUS arg1, UINT  arg2)
 {
-    dprintf(("GDI32: OS2GetRasterizerCaps"));
+    dprintf(("GDI32: GetRasterizerCaps"));
     return O32_GetRasterizerCaps(arg1, arg2);
 }
@@ -1346 +1346 @@
 DWORD WIN32API GetRegionData( HRGN arg1, DWORD arg2, PRGNDATA  arg3)
 {
-    dprintf(("GDI32: OS2GetRegionData"));
+    dprintf(("GDI32: GetRegionData"));
     return O32_GetRegionData(arg1, arg2, arg3);
 }
@@ -1353 +1353 @@
 int WIN32API GetRgnBox( HRGN arg1, PRECT  arg2)
 {
-    dprintf(("GDI32: OS2GetRgnBox"));
+    dprintf(("GDI32: GetRgnBox"));
     return O32_GetRgnBox(arg1, arg2);
 }
@@ -1360 +1360 @@
 int WIN32API GetStretchBltMode( HDC arg1)
 {
-    dprintf(("GDI32: OS2GetStretchBltMode"));
+    dprintf(("GDI32: GetStretchBltMode"));
     return O32_GetStretchBltMode(arg1);
 }
@@ -1369 +1369 @@
  UINT rc;
 
-    dprintf(("GDI32: OS2GetSystemPaletteEntries start %d nr %d pal ptr %X", arg2, arg3, arg4));
+    dprintf(("GDI32: GetSystemPaletteEntries start %d nr %d pal ptr %X", arg2, arg3, arg4));
     rc = O32_GetSystemPaletteEntries(arg1, arg2, arg3, arg4);
     dprintf((" GetSystemPaletteEntries returned %d", rc));
@@ -1378 +1378 @@
 UINT WIN32API GetTextAlign( HDC arg1)
 {
-    dprintf(("GDI32: OS2GetTextAlign"));
+    dprintf(("GDI32: GetTextAlign"));
     return O32_GetTextAlign(arg1);
 }
@@ -1385 +1385 @@
 int WIN32API GetTextCharacterExtra( HDC arg1)
 {
-    dprintf(("GDI32: OS2GetTextCharacterExtra"));
+    dprintf(("GDI32: GetTextCharacterExtra"));
     return O32_GetTextCharacterExtra(arg1);
 }
@@ -1392 +1392 @@
 COLORREF WIN32API GetTextColor( HDC arg1)
 {
-    dprintf(("GDI32: OS2GetTextColor"));
+    dprintf(("GDI32: GetTextColor"));
     return O32_GetTextColor(arg1);
 }
@@ -1399 +1399 @@
 BOOL WIN32API GetTextExtentPoint32A( HDC arg1, LPCSTR arg2, int arg3, PSIZE  lpSize)
 {
-    dprintf(("GDI32: OS2GetTextExtentPoint32A"));
+    dprintf(("GDI32: GetTextExtentPoint32A"));
     lpSize->cx = lpSize->cy = 0;
     return O32_GetTextExtentPoint32(arg1, arg2, arg3, lpSize);
@@ -1410 +1410 @@
  BOOL  rc;
 
-    dprintf(("GDI32: OS2GetTextExtentPoint32W %s\n", astring));
+    dprintf(("GDI32: GetTextExtentPoint32W %s\n", astring));
     lpSize->cx = lpSize->cy = 0;
     rc = O32_GetTextExtentPoint32(arg1, astring, arg3, lpSize);
@@ -1431 +1431 @@
                          cbString,
                          lpSize);
-  dprintf(("GDI32: OS2GetTextExtentPointW %X %s (size %08xh) returned %d\n", hdc, astring, cbString, rc));
-  dprintf(("GDI32: OS2GetTextExtentPointW (%d,%d)\n", lpSize->cx, lpSize->cy));
+  dprintf(("GDI32: GetTextExtentPointW %X %s (size %08xh) returned %d\n", hdc, astring, cbString, rc));
+  dprintf(("GDI32: GetTextExtentPointW (%d,%d)\n", lpSize->cx, lpSize->cy));
 
   FreeAsciiString(astring);
@@ -1441 +1441 @@
 int WIN32API GetTextFaceA( HDC arg1, int arg2, LPSTR  arg3)
 {
-    dprintf(("GDI32: OS2GetTextFaceA"));
+    dprintf(("GDI32: GetTextFaceA"));
     return O32_GetTextFace(arg1, arg2, arg3);
 }
@@ -1451 +1451 @@
  int   rc;
 
-    dprintf(("GDI32: OS2GetTextFaceW"));
+    dprintf(("GDI32: GetTextFaceW"));
     rc = O32_GetTextFace(arg1, arg2, astring);
     AsciiToUnicode(astring, arg3);
@@ -1463 +1463 @@
 
     rc = O32_GetTextMetrics(arg1, arg2);
-    dprintf(("GDI32: OS2GetTextMetricsA returned %d\n", rc));
+    dprintf(("GDI32: GetTextMetricsA returned %d\n", rc));
     return(rc);
 }
@@ -1473 +1473 @@
  TEXTMETRICA atm;
 
-    dprintf(("GDI32: OS2GetTextMetricsW"));
+    dprintf(("GDI32: GetTextMetricsW"));
 
     rc = O32_GetTextMetrics(arg1, &atm);
@@ -1502 +1502 @@
 BOOL WIN32API GetViewportExtEx( HDC arg1, PSIZE  arg2)
 {
-    dprintf(("GDI32: OS2GetViewportExtEx"));
+    dprintf(("GDI32: GetViewportExtEx"));
     return O32_GetViewportExtEx(arg1, arg2);
 }
@@ -1509 +1509 @@
 BOOL WIN32API GetViewportOrgEx( HDC arg1, PPOINT  arg2)
 {
-    dprintf(("GDI32: OS2GetViewportOrgEx"));
+    dprintf(("GDI32: GetViewportOrgEx"));
     return O32_GetViewportOrgEx(arg1, arg2);
 }
@@ -1516 +1516 @@
 UINT WIN32API GetWinMetaFileBits( HENHMETAFILE arg1, UINT arg2, PBYTE arg3, int arg4, HDC arg5)
 {
-    dprintf(("GDI32: OS2GetWinMetaFileBits"));
+    dprintf(("GDI32: GetWinMetaFileBits"));
     return O32_GetWinMetaFileBits(arg1, arg2, arg3, arg4, arg5);
 }
@@ -1523 +1523 @@
 BOOL WIN32API GetWindowOrgEx( HDC arg1, PPOINT  arg2)
 {
-    dprintf(("GDI32: OS2GetWindowOrgEx"));
+    dprintf(("GDI32: GetWindowOrgEx"));
     return O32_GetWindowOrgEx(arg1, arg2);
 }
@@ -1530 +1530 @@
 BOOL WIN32API GetWorldTransform( HDC arg1, LPXFORM  arg2)
 {
-    dprintf(("GDI32: OS2GetWorldTransform"));
+    dprintf(("GDI32: GetWorldTransform"));
     return O32_GetWorldTransform(arg1, arg2);
 }
@@ -1540 +1540 @@
 
   rc = O32_IntersectClipRect(arg1, arg2, arg3, arg4, arg5);
-  dprintf(("GDI32: OS2IntersectClipRect returned %d\n", rc));
+  dprintf(("GDI32: IntersectClipRect returned %d\n", rc));
   return(rc);
 }
@@ -1547 +1547 @@
 BOOL WIN32API InvertRgn( HDC arg1, HRGN  arg2)
 {
-    dprintf(("GDI32: OS2InvertRgn"));
+    dprintf(("GDI32: InvertRgn"));
     return O32_InvertRgn(arg1, arg2);
 }
@@ -1554 +1554 @@
 BOOL WIN32API LPtoDP( HDC arg1, PPOINT arg2, int  arg3)
 {
-    dprintf(("GDI32: OS2LPtoDP"));
+    dprintf(("GDI32: LPtoDP"));
     return O32_LPtoDP(arg1, arg2, arg3);
 }
@@ -1565 +1565 @@
  POINT startPt,endPt;
 
-  dprintf(("GDI32: OS2LineDDA\n"));
+  dprintf(("GDI32: LineDDA\n"));
 
   //CB: don't know if Open32 reports the last pixel, but all other line functions do
   startPt.x = nXStart;
   startPt.y = nYStart;
-  endPt = OS2ToWin32LineEnd(startPt,nXEnd,nYEnd);
+  endPt = ToWin32LineEnd(startPt,nXEnd,nYEnd);
 
   rc = O32_LineDDA(startPt.x,startPt.y,endPt.x,endPt.y,callback->GetOS2Callback(),(LPARAM)callback);
@@ -1581 +1581 @@
 BOOL WIN32API MaskBlt( HDC arg1, int arg2, int arg3, int arg4, int arg5, HDC   arg6, int arg7, int arg8, HBITMAP arg9, int arg10, int arg11, DWORD  arg12)
 {
-    dprintf(("GDI32: OS2MaskBlt"));
+    dprintf(("GDI32: MaskBlt"));
     return O32_MaskBlt(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
 }
@@ -1588 +1588 @@
 BOOL WIN32API ModifyWorldTransform( HDC arg1, const XFORM *arg2, DWORD  arg3)
 {
-    dprintf(("GDI32: OS2ModifyWorldTransform"));
+    dprintf(("GDI32: ModifyWorldTransform"));
     return O32_ModifyWorldTransform(arg1, (LPXFORM)arg2, arg3);
 }
@@ -1595 +1595 @@
 int WIN32API OffsetClipRgn( HDC arg1, int arg2, int  arg3)
 {
-    dprintf(("GDI32: OS2OffsetClipRgn"));
+    dprintf(("GDI32: OffsetClipRgn"));
     return O32_OffsetClipRgn(arg1, arg2, arg3);
 }
@@ -1602 +1602 @@
 int WIN32API OffsetRgn( HRGN arg1, int arg2, int  arg3)
 {
-    dprintf(("GDI32: OS2OffsetRgn"));
+    dprintf(("GDI32: OffsetRgn"));
     return O32_OffsetRgn(arg1, arg2, arg3);
 }
@@ -1609 +1609 @@
 BOOL WIN32API OffsetViewportOrgEx( HDC arg1, int arg2, int arg3, PPOINT  arg4)
 {
-    dprintf(("GDI32: OS2OffsetViewportOrgEx"));
+    dprintf(("GDI32: OffsetViewportOrgEx"));
     return O32_OffsetViewportOrgEx(arg1, arg2, arg3, arg4);
 }
@@ -1616 +1616 @@
 BOOL WIN32API OffsetWindowOrgEx( HDC arg1, int arg2, int arg3, PPOINT  arg4)
 {
-    dprintf(("GDI32: OS2OffsetWindowOrgEx"));
+    dprintf(("GDI32: OffsetWindowOrgEx"));
     return O32_OffsetWindowOrgEx(arg1, arg2, arg3, arg4);
 }
@@ -1623 +1623 @@
 BOOL WIN32API PaintRgn( HDC arg1, HRGN  arg2)
 {
-    dprintf(("GDI32: OS2PaintRgn"));
+    dprintf(("GDI32: PaintRgn"));
     return O32_PaintRgn(arg1, arg2);
 }
@@ -1630 +1630 @@
 HRGN WIN32API PathToRegion( HDC arg1)
 {
-    dprintf(("GDI32: OS2PathToRegion"));
+    dprintf(("GDI32: PathToRegion"));
     return O32_PathToRegion(arg1);
 }
@@ -1639 +1639 @@
                   int nYRadial2)
 {
-    dprintf(("GDI32: OS2Pie"));
+    dprintf(("GDI32: Pie"));
     //CB: bug in O32_Pie
     if (nXRadial1 == nXRadial2 && nYRadial1 == nYRadial2)
@@ -1650 +1650 @@
 BOOL WIN32API PlayEnhMetaFile( HDC arg1, HENHMETAFILE arg2, const RECT *  arg3)
 {
-    dprintf(("GDI32: OS2PlayEnhMetaFile"));
+    dprintf(("GDI32: PlayEnhMetaFile"));
     return O32_PlayEnhMetaFile(arg1, arg2, arg3);
 }
@@ -1657 +1657 @@
 BOOL WIN32API PlayMetaFile( HDC arg1, HMETAFILE  arg2)
 {
-    dprintf(("GDI32: OS2PlayMetaFile"));
+    dprintf(("GDI32: PlayMetaFile"));
     return O32_PlayMetaFile(arg1, arg2);
 }
@@ -1664 +1664 @@
 BOOL WIN32API PlayMetaFileRecord( HDC arg1, LPHANDLETABLE arg2, LPMETARECORD arg3, UINT  arg4)
 {
-    dprintf(("GDI32: OS2PlayMetaFileRecord"));
+    dprintf(("GDI32: PlayMetaFileRecord"));
     return O32_PlayMetaFileRecord(arg1, arg2, arg3, (int)arg4);
 }
@@ -1671 +1671 @@
 BOOL WIN32API PolyBezier( HDC arg1, const POINT * arg2, DWORD  arg3)
 {
-    dprintf(("GDI32: OS2PolyBezier"));
+    dprintf(("GDI32: PolyBezier"));
     return O32_PolyBezier(arg1, arg2, (int)arg3);
 }
@@ -1678 +1678 @@
 BOOL WIN32API PolyBezierTo( HDC arg1, const POINT * arg2, DWORD  arg3)
 {
-    dprintf(("GDI32: OS2PolyBezierTo"));
+    dprintf(("GDI32: PolyBezierTo"));
     return O32_PolyBezierTo(arg1, arg2, arg3);
 }
@@ -1685 +1685 @@
 BOOL WIN32API PolyDraw( HDC arg1, const POINT * arg2, const BYTE * arg3, DWORD  arg4)
 {
-    dprintf(("GDI32: OS2PolyDraw"));
+    dprintf(("GDI32: PolyDraw"));
     return O32_PolyDraw(arg1, arg2, arg3, arg4);
 }
@@ -1692 +1692 @@
 BOOL WIN32API PolyPolygon( HDC arg1, const POINT * arg2, const INT * arg3, UINT  arg4)
 {
-    dprintf(("GDI32: OS2PolyPolygon"));
+    dprintf(("GDI32: PolyPolygon"));
     return O32_PolyPolygon(arg1, arg2, arg3, arg4);
 }
@@ -1699 +1699 @@
 BOOL WIN32API PolyPolyline( HDC hdc, const POINT * lppt, const DWORD * lpdwPolyPoints, DWORD cCount)
 {
-    dprintf(("GDI32: OS2PolyPolyline"));
+    dprintf(("GDI32: PolyPolyline"));
 
     return O32_PolyPolyline(hdc,lppt,lpdwPolyPoints,cCount);
@@ -1707 +1707 @@
 BOOL WIN32API Polygon( HDC arg1, const POINT * arg2, int  arg3)
 {
-    dprintf(("GDI32: OS2Polygon"));
+    dprintf(("GDI32: Polygon"));
     return O32_Polygon(arg1, arg2, arg3);
 }
@@ -1714 +1714 @@
 BOOL WIN32API Polyline( HDC hdc, const POINT *lppt, int cPoints)
 {
-    dprintf(("GDI32: OS2Polyline"));
+    dprintf(("GDI32: Polyline"));
 
     if (cPoints == 0) return TRUE;
@@ -1736 +1736 @@
     BOOL rc;
 
-    points[cPoints-1] = OS2ToWin32LineEnd(lppt[cPoints-2],lastPt.x,lastPt.y);
+    points[cPoints-1] = ToWin32LineEnd(lppt[cPoints-2],lastPt.x,lastPt.y);
     rc = O32_Polyline(hdc,lppt,cPoints);
     points[cPoints-1] = lastPt;
@@ -1746 +1746 @@
 BOOL WIN32API PolylineTo( HDC hdc, const POINT * lppt, DWORD cCount)
 {
-    dprintf(("GDI32: OS2PolylineTo"));
+    dprintf(("GDI32: PolylineTo"));
 
     if (cCount == 0) return TRUE;
@@ -1762 +1762 @@
     BOOL rc;
 
-    points[cCount-1] = OS2ToWin32LineEnd(lppt[cCount-2],lastPt.x,lastPt.y);
+    points[cCount-1] = ToWin32LineEnd(lppt[cCount-2],lastPt.x,lastPt.y);
     rc = O32_PolylineTo(hdc,lppt,cCount);
     points[cCount-1] = lastPt;
@@ -1773 +1773 @@
 BOOL WIN32API PtInRegion( HRGN arg1, int arg2, int  arg3)
 {
-    dprintf(("GDI32: OS2PtInRegion"));
+    dprintf(("GDI32: PtInRegion"));
     return O32_PtInRegion(arg1, arg2, arg3);
 }
@@ -1780 +1780 @@
 BOOL WIN32API PtVisible( HDC arg1, int arg2, int  arg3)
 {
-    dprintf(("GDI32: OS2PtVisible"));
+    dprintf(("GDI32: PtVisible"));
     return O32_PtVisible(arg1, arg2, arg3);
 }
@@ -1787 +1787 @@
 BOOL WIN32API RectInRegion( HRGN arg1, const RECT *  arg2)
 {
-    dprintf(("GDI32: OS2RectInRegion"));
+    dprintf(("GDI32: RectInRegion"));
     return O32_RectInRegion(arg1, arg2);
 }
@@ -1794 +1794 @@
 BOOL WIN32API RectVisible( HDC arg1, const RECT * arg2)
 {
-    dprintf(("GDI32: OS2RectVisible\n"));
+    dprintf(("GDI32: RectVisible\n"));
     return O32_RectVisible(arg1, arg2);
 }
@@ -1801 +1801 @@
 HDC WIN32API ResetDCA( HDC arg1, const DEVMODEA *  arg2)
 {
-    dprintf(("GDI32: OS2ResetDCA\n"));
+    dprintf(("GDI32: ResetDCA\n"));
     return (HDC)O32_ResetDC(arg1, arg2);
 }
@@ -1808 +1808 @@
 HDC WIN32API ResetDCW( HDC arg1, const DEVMODEW *  arg2)
 {
-    dprintf(("GDI32: OS2ResetDCW\n"));
+    dprintf(("GDI32: ResetDCW\n"));
     // NOTE: This will not work as is (needs UNICODE support)
     return (HDC)O32_ResetDC(arg1, (const DEVMODEA *)arg2);
@@ -1816 +1816 @@
 BOOL WIN32API ResizePalette( HPALETTE arg1, UINT  arg2)
 {
-    dprintf(("GDI32: OS2ResizePalette\n"));
+    dprintf(("GDI32: ResizePalette\n"));
     return O32_ResizePalette(arg1, arg2);
 }
@@ -1823 +1823 @@
 BOOL WIN32API RestoreDC( HDC arg1, int  arg2)
 {
-    dprintf(("GDI32: OS2RestoreDC\n"));
+    dprintf(("GDI32: RestoreDC\n"));
     return O32_RestoreDC(arg1, arg2);
 }
@@ -1830 +1830 @@
 BOOL WIN32API RoundRect( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int  arg7)
 {
-    dprintf(("GDI32: OS2RoundRect"));
+    dprintf(("GDI32: RoundRect"));
     return O32_RoundRect(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 }
@@ -1837 +1837 @@
 int WIN32API SaveDC( HDC arg1)
 {
-    dprintf(("GDI32: OS2SaveDC"));
+    dprintf(("GDI32: SaveDC"));
     return O32_SaveDC(arg1);
 }
@@ -1844 +1844 @@
 BOOL WIN32API ScaleViewportExtEx( HDC arg1, int arg2, int arg3, int arg4, int arg5, PSIZE  arg6)
 {
-    dprintf(("GDI32: OS2ScaleViewportExtEx"));
+    dprintf(("GDI32: ScaleViewportExtEx"));
     return O32_ScaleViewportExtEx(arg1, arg2, arg3, arg4, arg5, arg6);
 }
@@ -1851 +1851 @@
 BOOL WIN32API ScaleWindowExtEx( HDC arg1, int arg2, int arg3, int arg4, int arg5, PSIZE  arg6)
 {
-    dprintf(("GDI32: OS2ScaleWindowExtEx"));
+    dprintf(("GDI32: ScaleWindowExtEx"));
     return O32_ScaleWindowExtEx(arg1, arg2, arg3, arg4, arg5, arg6);
 }
@@ -1858 +1858 @@
 int WIN32API SelectClipRgn( HDC arg1, HRGN  arg2)
 {
-    dprintf(("GDI32: OS2SelectClipRgn"));
+    dprintf(("GDI32: SelectClipRgn"));
     return O32_SelectClipRgn(arg1, arg2);
 }
@@ -1865 +1865 @@
 int WIN32API SetArcDirection( HDC arg1, int  arg2)
 {
-    dprintf(("GDI32: OS2SetArcDirection"));
+    dprintf(("GDI32: SetArcDirection"));
     return O32_SetArcDirection(arg1, arg2);
 }
@@ -1872 +1872 @@
 LONG WIN32API SetBitmapBits( HBITMAP arg1, LONG arg2, const VOID *  arg3)
 {
-    dprintf(("GDI32: OS2SetBitmapBits"));
+    dprintf(("GDI32: SetBitmapBits"));
     return O32_SetBitmapBits(arg1, (DWORD)arg2, arg3);
 }
@@ -1879 +1879 @@
 BOOL WIN32API SetBitmapDimensionEx( HBITMAP arg1, int arg2, int arg3, PSIZE  arg4)
 {
-    dprintf(("GDI32: OS2SetBitmapDimensionEx"));
+    dprintf(("GDI32: SetBitmapDimensionEx"));
     return O32_SetBitmapDimensionEx(arg1, arg2, arg3, arg4);
 }
@@ -1886 +1886 @@
 UINT WIN32API SetBoundsRect( HDC arg1, const RECT * arg2, UINT arg3)
 {
-    dprintf(("GDI32: OS2SetBoundsRect"));
+    dprintf(("GDI32: SetBoundsRect"));
     return O32_SetBoundsRect(arg1, arg2, arg3);
 }
@@ -1896 +1896 @@
 
     rc = O32_SetBrushOrgEx(arg1, arg2, arg3, arg4);
-    dprintf(("GDI32: OS2SetBrushOrgEx returned %d\n", rc));
+    dprintf(("GDI32: SetBrushOrgEx returned %d\n", rc));
     return(rc);
 }
@@ -1903 +1903 @@
 int WIN32API SetDIBits( HDC arg1, HBITMAP arg2, UINT arg3, UINT arg4, const VOID * arg5, const BITMAPINFO * arg6, UINT  arg7)
 {
-    dprintf(("GDI32: OS2SetDIBits\n"));
+    dprintf(("GDI32: SetDIBits\n"));
     return O32_SetDIBits(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 }
@@ -1913 +1913 @@
     char *ptr;
 
-    dprintf(("GDI32: OS2SetDIBitsToDevice hdc:%X xDest:%d yDest:%d, cx:%d, cy:%d, xSrc:%d, ySrc:%d, startscan:%d, lines:%d, bits:%X, info%X, coloruse:%d",
+    dprintf(("GDI32: SetDIBitsToDevice hdc:%X xDest:%d yDest:%d, cx:%d, cy:%d, xSrc:%d, ySrc:%d, startscan:%d, lines:%d, bits:%X, info%X, coloruse:%d",
                  hdc, xDest, yDest, cx, cy, xSrc, ySrc, startscan, lines, (LPVOID) bits, (PBITMAPINFO)info, coloruse));
 
@@ -1938 +1938 @@
 HENHMETAFILE WIN32API SetEnhMetaFileBits( UINT arg1, const BYTE *  arg2)
 {
-    dprintf(("GDI32: OS2SetEnhMetaFileBits"));
+    dprintf(("GDI32: SetEnhMetaFileBits"));
     return O32_SetEnhMetaFileBits(arg1, arg2);
 }
@@ -1945 +1945 @@
 int WIN32API SetGraphicsMode(HDC arg1, int  arg2)
 {
-    dprintf(("GDI32: OS2SetGraphicsMode"));
+    dprintf(("GDI32: SetGraphicsMode"));
     return O32_SetGraphicsMode(arg1, arg2);
 }
@@ -1952 +1952 @@
 int WIN32API SetMapMode( HDC arg1, int  arg2)
 {
-    dprintf(("GDI32: OS2SetMapMode"));
+    dprintf(("GDI32: SetMapMode"));
     return O32_SetMapMode(arg1, arg2);
 }
@@ -1959 +1959 @@
 DWORD WIN32API SetMapperFlags( HDC arg1, DWORD  arg2)
 {
-    dprintf(("GDI32: OS2SetMapperFlags"));
+    dprintf(("GDI32: SetMapperFlags"));
     return O32_SetMapperFlags(arg1, arg2);
 }
@@ -1966 +1966 @@
 HMETAFILE WIN32API SetMetaFileBitsEx( UINT arg1, const BYTE * arg2)
 {
-    dprintf(("GDI32: OS2SetMetaFileBitsEx"));
+    dprintf(("GDI32: SetMetaFileBitsEx"));
     return O32_SetMetaFileBitsEx(arg1, (PBYTE)arg2);
 }
@@ -1973 +1973 @@
 BOOL WIN32API SetMiterLimit( HDC arg1, float  arg2, float *  arg3)
 {
-    dprintf(("GDI32: OS2SetMiterLimit"));
+    dprintf(("GDI32: SetMiterLimit"));
     return O32_SetMiterLimit(arg1, arg2, arg3);
 }
@@ -1980 +1980 @@
 UINT WIN32API SetPaletteEntries( HPALETTE arg1, UINT arg2, UINT arg3, PALETTEENTRY * arg4)
 {
-    dprintf(("GDI32: OS2SetPaletteEntries"));
+    dprintf(("GDI32: SetPaletteEntries"));
     return O32_SetPaletteEntries(arg1, arg2, arg3, (const PALETTEENTRY *)arg4);
 }
@@ -1987 +1987 @@
 int WIN32API SetPolyFillMode( HDC arg1, int  arg2)
 {
-    dprintf(("GDI32: OS2SetPolyFillMode"));
+    dprintf(("GDI32: SetPolyFillMode"));
     return O32_SetPolyFillMode(arg1, arg2);
 }
@@ -1994 +1994 @@
 BOOL WIN32API SetRectRgn( HRGN arg1, int arg2, int arg3, int arg4, int  arg5)
 {
-    dprintf(("GDI32: OS2SetRectRgn"));
+    dprintf(("GDI32: SetRectRgn"));
     return O32_SetRectRgn(arg1, arg2, arg3, arg4, arg5);
 }
@@ -2001 +2001 @@
 UINT WIN32API SetTextAlign( HDC arg1, UINT  arg2)
 {
-    dprintf(("GDI32: OS2SetTextAlign"));
+    dprintf(("GDI32: SetTextAlign"));
     return O32_SetTextAlign(arg1, arg2);
 }
@@ -2008 +2008 @@
 int WIN32API SetTextCharacterExtra( HDC arg1, int  arg2)
 {
-    dprintf(("GDI32: OS2SetTextCharacterExtra"));
+    dprintf(("GDI32: SetTextCharacterExtra"));
     return O32_SetTextCharacterExtra(arg1, arg2);
 }
@@ -2015 +2015 @@
 BOOL WIN32API SetTextJustification( HDC arg1, int arg2, int  arg3)
 {
-    dprintf(("GDI32: OS2SetTextJustification"));
+    dprintf(("GDI32: SetTextJustification"));
     return O32_SetTextJustification(arg1, arg2, arg3);
 }
@@ -2022 +2022 @@
 BOOL WIN32API SetViewportExtEx( HDC arg1, int arg2, int arg3, PSIZE  arg4)
 {
-    dprintf(("GDI32: OS2SetViewportExtEx"));
+    dprintf(("GDI32: SetViewportExtEx"));
     return O32_SetViewportExtEx(arg1, arg2, arg3, arg4);
 }
@@ -2029 +2029 @@
 BOOL WIN32API SetViewportOrgEx( HDC arg1, int arg2, int arg3, PPOINT  arg4)
 {
-    dprintf(("GDI32: OS2SetViewportOrgEx"));
+    dprintf(("GDI32: SetViewportOrgEx"));
     return O32_SetViewportOrgEx(arg1, arg2, arg3, arg4);
 }
@@ -2036 +2036 @@
 HENHMETAFILE WIN32API SetWinMetaFileBits( UINT arg1, const BYTE * arg2, HDC arg3, const METAFILEPICT *  arg4)
 {
-    dprintf(("GDI32: OS2SetWinMetaFileBits"));
+    dprintf(("GDI32: SetWinMetaFileBits"));
     return O32_SetWinMetaFileBits(arg1, arg2, arg3, arg4);
 }
@@ -2043 +2043 @@
 BOOL WIN32API SetWindowExtEx( HDC arg1, int arg2, int arg3, PSIZE  arg4)
 {
-    dprintf(("GDI32: OS2SetWindowExtEx"));
+    dprintf(("GDI32: SetWindowExtEx"));
     return O32_SetWindowExtEx(arg1, arg2, arg3, arg4);
 }
@@ -2050 +2050 @@
 BOOL WIN32API SetWindowOrgEx( HDC arg1, int arg2, int arg3, PPOINT  arg4)
 {
-    dprintf(("GDI32: OS2SetWindowOrgEx"));
+    dprintf(("GDI32: SetWindowOrgEx"));
     return O32_SetWindowOrgEx(arg1, arg2, arg3, arg4);
 }
@@ -2057 +2057 @@
 BOOL WIN32API SetWorldTransform( HDC arg1, const XFORM *arg2)
 {
-    dprintf(("GDI32: OS2SetWorldTransform"));
+    dprintf(("GDI32: SetWorldTransform"));
     return O32_SetWorldTransform(arg1, (LPXFORM)arg2);
 }
@@ -2064 +2064 @@
 INT WIN32API StartDocA( HDC arg1, const DOCINFOA *arg2)
 {
-    dprintf(("GDI32: OS2StartDocA"));
+    dprintf(("GDI32: StartDocA"));
     return O32_StartDoc(arg1, (LPDOCINFOA)arg2);
 }
@@ -2071 +2071 @@
 INT WIN32API StartDocW( HDC arg1, const DOCINFOW *arg2)
 {
-    dprintf(("GDI32: OS2StartDocW STUB"));
+    dprintf(("GDI32: StartDocW STUB"));
     // NOTE: This will not work as is (needs UNICODE support)
 //    return O32_StartDoc(arg1, arg2);
@@ -2080 +2080 @@
 int WIN32API StartPage( HDC arg1)
 {
-    dprintf(("GDI32: OS2StartPage"));
+    dprintf(("GDI32: StartPage"));
     return O32_StartPage(arg1);
 }
@@ -2090 +2090 @@
  BOOL  rc;
 
-    dprintf(("GDI32: OS2TextOutW"));
+    dprintf(("GDI32: TextOutW"));
     // NOTE: This will not work as is (needs UNICODE support)
     rc = O32_TextOut(arg1, arg2, arg3, astring, arg5);
@@ -2100 +2100 @@
 BOOL WIN32API UnrealizeObject( HGDIOBJ arg1)
 {
-    dprintf(("GDI32: OS2UnrealizeObject"));
+    dprintf(("GDI32: UnrealizeObject"));
     return O32_UnrealizeObject(arg1);
 }
@@ -2107 +2107 @@
 BOOL WIN32API WidenPath( HDC arg1)
 {
-    dprintf(("GDI32: OS2WidenPath"));
+    dprintf(("GDI32: WidenPath"));
     return O32_WidenPath(arg1);
 }
@@ -2115 +2115 @@
 HBITMAP WIN32API CreateDiscardableBitmap(HDC hDC, int nWidth, int nHeight)
 {
-    dprintf(("GDI32: OS2CreateDisardableBitmap\n"));
+    dprintf(("GDI32: CreateDisardableBitmap\n"));
     return O32_CreateCompatibleBitmap(hDC, nWidth, nHeight);
 }
@@ -2123 +2123 @@
 int WIN32API SetAbortProc(HDC hdc, ABORTPROC lpAbortProc)
 {
-  dprintf(("GDI32: OS2SetAbortProc - stub (1)w\n"));
+  dprintf(("GDI32: SetAbortProc - stub (1)w\n"));
   return(1);
 }
@@ -2132 +2132 @@
 UINT WIN32API GetTextCharset(HDC hdc)
 {
-  dprintf(("GDI32: OS2GetTextCharset, not complete\n"));
+  dprintf(("GDI32: GetTextCharset, not complete\n"));
   return(ANSI_CHARSET);
 }
@@ -2142 +2142 @@
 BOOL WIN32API SelectClipPath(HDC hdc, int iMode)
 {
-  dprintf(("GDI32: OS2SelectClipPath, not implemented!(TRUE)\n"));
+  dprintf(("GDI32: SelectClipPath, not implemented!(TRUE)\n"));
   return(TRUE);
 }
@@ -2152 +2152 @@
 BOOL WIN32API SetColorAdjustment(HDC hdc, CONST COLORADJUSTMENT *lpca)
 {
-  dprintf(("GDI32: OS2SetColorAdjustment, not implemented!(TRUE)\n"));
+  dprintf(("GDI32: SetColorAdjustment, not implemented!(TRUE)\n"));
   return(TRUE);
 }
@@ -2164 +2164 @@
  BOOL    fFlip = 0;
 
-  dprintf(("GDI32: OS2CreateDIBSection, partly implemented!\n"));
+  dprintf(("GDI32: CreateDIBSection %x %x %x %d", hdc, iUsage, hSection, dwOffset));
   if(hSection) {
-        dprintf(("GDI32: OS2CreateDIBSection, hSection != NULL, not supported!\n"));
+        dprintf(("GDI32: CreateDIBSection, hSection != NULL, not supported!\n"));
         return NULL;
   }
@@ -2236 +2236 @@
  DIBSection *dsect = DIBSection::findHDC(hdc);
 
-  dprintf(("GDI32: OS2SetDIBColorTable\n"));
+  dprintf(("GDI32: SetDIBColorTable\n"));
   if(dsect) {
         return(dsect->SetDIBColorTable(uStartIndex, cEntries, pColors));
@@ -2246 +2246 @@
 HPALETTE WIN32API CreateHalftonePalette(HDC hdc)
 {
-    dprintf(("GDI32: OS2CreateHalftonePalette, not implemented\n"));
+    dprintf(("GDI32: CreateHalftonePalette, not implemented\n"));
     return(NULL);
-}
-//******************************************************************************
-//******************************************************************************
-UINT WIN32API TranslateCharsetInfo(DWORD *lpSrc, LPCHARSETINFO lpCs, DWORD dwFlags)
-{
-   dprintf(("GDI32: OS2TranslateCharsetInfo, not implemented\n"));
-   return(0);
 }
 //******************************************************************************
@@ -2262 +2255 @@
 BOOL WIN32API UpdateColors(HDC hdc)
 {
-  dprintf(("GDI32: OS2UpdateColors\n"));
+  dprintf(("GDI32: UpdateColors\n"));
   return O32_InvalidateRect(O32_WindowFromDC(hdc), NULL, FALSE);
 }