/* - - AnsiWrap.c * * Contains wrappers for thunking down Unicode calls to the Win 9x ANSI versions * */ #include "_apipch.h" // we should not define the Macro for the APIs that we will implement the wrappers for. // lets try to keep this list alphabetical for sanity #undef CallWindowProcW #undef CharLowerW #undef CharNextW #undef CharPrevW #undef CharUpperBuffW #undef CharUpperBuffW #undef CharUpperW #undef CompareStringW #undef CopyFileW #undef CreateDialogParamW #undef CreateDirectoryW #undef CreateEventW #undef CreateFileW #undef CreateFontIndirectW #undef CreateMutexW #undef CreateWindowExW //#undef CryptAcquireContextW #undef DefWindowProcW #undef DeleteFileW #undef DialogBoxParamW #undef DispatchMessageW #undef DragQueryFileW #undef DrawTextW #undef ExpandEnvironmentStringsW #undef FindFirstChangeNotificationW #undef FindFirstFileW #undef FormatMessageW #undef GetClassInfoExW #undef GetClassInfoW #undef GetClassNameW #undef GetDateFormatW #undef GetDiskFreeSpaceW #undef GetDlgItemTextW #undef GetFileAttributesW #undef GetLocaleInfoW #undef GetMenuItemInfoW #undef GetMessageW #undef GetModuleFileNameW #undef GetObjectW #undef GetPrivateProfileIntW #undef GetPrivateProfileStringW #undef GetProfileIntW #undef GetStringTypeW #undef GetSystemDirectoryW #undef GetTempFileNameW #undef GetTempPathW #undef GetTextExtentPoint32W #undef GetTimeFormatW #undef GetUserNameW #undef GetWindowLongW #undef GetWindowsDirectoryW #undef GetWindowTextLengthW #undef GetWindowTextW #undef InsertMenuW #undef IsBadStringPtrW #undef IsCharLowerW #undef IsCharUpperW #undef IsDialogMessageW #undef LCMapStringW #undef LoadAcceleratorsW #undef LoadCursorW #undef LoadIconW #undef LoadImageW #undef LoadLibraryW #undef LoadMenuW #undef LoadStringW #undef lstrcatW #undef lstrcmpiW #undef lstrcmpW #undef lstrcpynW #undef lstrcpyW #undef ModifyMenuW #undef MoveFileW #undef OutputDebugStringW #undef PeekMessageW #undef PostMessageW #undef RegCreateKeyExW #undef RegCreateKeyW #undef RegDeleteKeyW #undef RegDeleteValueW #undef RegEnumKeyExW #undef RegEnumValueW #undef RegisterClassExW #undef RegisterClassW #undef RegisterClipboardFormatW #undef RegisterWindowMessageW #undef RegOpenKeyExW #undef RegQueryInfoKeyW #undef RegQueryValueExW #undef RegQueryValueW #undef RegSetValueExW #undef RegSetValueW #undef SendDlgItemMessageW #undef SendMessageW #undef SetDlgItemTextW #undef SetMenuItemInfoW #undef SetWindowLongW #undef SetWindowTextW #undef ShellExecuteW #undef StartDocW #undef SystemParametersInfoW #undef TranslateAcceleratorW #undef UnRegisterClassW #undef wsprintfW #undef wvsprintfW // // Do this in every wrapper function to make sure the wrapper // prototype matches the function it is intending to replace. // #define VALIDATE_PROTOTYPE(f) if (f##W == f##WrapW) 0 #define InRange(val, valMin, valMax) (valMin <= val && val <= valMax) // Because with current build setting, no lib containing wcscpy and wcslen is linked // so implement these two functions here. LPWSTR My_wcscpy( LPWSTR pwszDest, LPCWSTR pwszSrc ) { LPWSTR pwszDestT = NULL; LPCWSTR pwszSrcT; pwszSrcT = pwszSrc; pwszDestT = pwszDest; while ( *pwszSrcT ) *pwszDestT++ = *pwszSrcT ++; *pwszDestT = 0x0000; return pwszDest; } DWORD My_wcslen( LPCWSTR lpwszStr ) { DWORD dLen =0; LPCWSTR lpwszStrT; lpwszStrT = lpwszStr; dLen = 0; while ( *lpwszStrT ) { dLen ++; lpwszStrT ++; } return dLen; } LPWSTR My_wcscat( LPWSTR pwszDest, LPCWSTR pwszSrc ) { LPWSTR pwszDestT = pwszDest; while ( *pwszDestT ) pwszDestT++; My_wcscpy(pwszDestT, pwszSrc); return pwszDest; } // ADVAPI32.DLL /* RegOpenKeyEx */ LONG WINAPI RegOpenKeyExWrapW( HKEY hKey, // handle to open key LPCTSTR lpSubKey, // address of name of subkey to open DWORD ulOptions, // reserved REGSAM samDesired, // security access mask PHKEY phkResult) // address of handle to open key { LPSTR lpSubKeyA = NULL; LONG lRetValue = 0; VALIDATE_PROTOTYPE(RegOpenKeyEx); if (g_bRunningOnNT) return RegOpenKeyExW(hKey, lpSubKey, ulOptions, samDesired, phkResult); lpSubKeyA = ConvertWtoA(lpSubKey); lRetValue = RegOpenKeyExA(hKey, lpSubKeyA, ulOptions, samDesired, phkResult); LocalFreeAndNull( &lpSubKeyA ); return lRetValue; } /* RegQueryValue */ LONG WINAPI RegQueryValueWrapW( HKEY hKey, // handle to key to query LPCTSTR lpSubKey, // name of subkey to query LPTSTR lpValue, // buffer for returned string PLONG lpcbValue) // receives size of returned string { LPSTR lpSubKeyA = NULL; LPWSTR lpwszValue = NULL; LONG lRetValue =0; LPSTR lpValueA = NULL; LONG cbValueA = 0; VALIDATE_PROTOTYPE(RegQueryValue); if (g_bRunningOnNT) return RegQueryValueW(hKey, lpSubKey, lpValue, lpcbValue); lpSubKeyA = ConvertWtoA(lpSubKey); lRetValue = RegQueryValueA(hKey, lpSubKeyA, NULL, &cbValueA); if ( lRetValue != ERROR_SUCCESS ) { LocalFreeAndNull( &lpSubKeyA); return lRetValue; } lpValueA = LocalAlloc(LMEM_ZEROINIT, cbValueA); lRetValue = RegQueryValueA(hKey, lpSubKeyA, lpValueA, &cbValueA); lpwszValue = ConvertAtoW(lpValueA); *lpcbValue = (My_wcslen(lpwszValue) + 1 ) * sizeof(WCHAR); if ( lpValue != NULL ) My_wcscpy(lpValue, lpwszValue); LocalFreeAndNull( &lpSubKeyA ); LocalFreeAndNull( &lpValueA ); LocalFreeAndNull( &lpwszValue ); return lRetValue; } // RegEnumKeyEx LONG WINAPI RegEnumKeyExWrapW( HKEY hKey, // handle to key to enumerate DWORD dwIndex, // index of subkey to enumerate LPTSTR lpName, // address of buffer for subkey name LPDWORD lpcbName, // address for size of subkey buffer LPDWORD lpReserved, // reserved LPTSTR lpClass, // address of buffer for class string LPDWORD lpcbClass, // address for size of class buffer PFILETIME lpftLastWriteTime ) // address for time key last written to { LONG lRetValue = 0; CHAR lpNameA[MAX_PATH]; CHAR lpClassA[MAX_PATH]; LPWSTR lpNameW = NULL; LPWSTR lpClassW= NULL; DWORD cbName, cbClass; // [PaulHi] 1/11/99 Init wide char buffers lpNameA[0] = 0; lpClassA[0] = 0; VALIDATE_PROTOTYPE(RegEnumKeyEx); if (g_bRunningOnNT) return RegEnumKeyExW(hKey, dwIndex, lpName, lpcbName, lpReserved, lpClass, lpcbClass, lpftLastWriteTime); cbName = cbClass = MAX_PATH; lRetValue = RegEnumKeyExA(hKey,dwIndex,lpNameA,&cbName,lpReserved,lpClassA,&cbClass,lpftLastWriteTime); if ( lRetValue != ERROR_SUCCESS ) return lRetValue; lpClassW = ConvertAtoW( lpClassA ); lpNameW = ConvertAtoW( lpNameA ); cbName = My_wcslen(lpNameW) + 1; cbClass= My_wcslen(lpClassW) + 1; // [PaulHi] 1/11/99 Be careful copying to passed in pointers if (lpClass && lpcbClass) { if (cbClass <= *lpcbClass) { CopyMemory(lpClass, lpClassW, cbClass * sizeof(WCHAR) ); *lpcbClass = cbClass; } else { Assert(0); lpClass[0] = 0; *lpcbClass = 0; lRetValue = ERROR_INSUFFICIENT_BUFFER; } } if (lpName && lpcbName) { if (cbName <= *lpcbName) { CopyMemory(lpName, lpNameW, cbName * sizeof(WCHAR) ); *lpcbName = cbName; } else { Assert(0); lpName[0] = 0; *lpcbName = 0; lRetValue = ERROR_INSUFFICIENT_BUFFER; } } LocalFreeAndNull( &lpClassW ); LocalFreeAndNull( &lpNameW ); return lRetValue; } /* RegSetValue */ LONG WINAPI RegSetValueWrapW( HKEY hKey, // handle to key to set value for LPCTSTR lpSubKey, // address of subkey name DWORD dwType, // type of value LPCTSTR lpData, // address of value data DWORD cbData ) // size of value data { LPSTR lpSubKeyA =NULL; LPSTR lpDataA=NULL; DWORD cbDataA =0; LONG lRetValue = 0; VALIDATE_PROTOTYPE(RegSetValue); if (g_bRunningOnNT) return RegSetValueW(hKey, lpSubKey, dwType, lpData, cbData); lpSubKeyA = ConvertWtoA(lpSubKey ); lpDataA = ConvertWtoA( lpData ); cbDataA = lstrlenA( lpDataA ); lRetValue = RegSetValueA(hKey, lpSubKeyA, dwType, lpDataA, cbDataA); LocalFreeAndNull( &lpSubKeyA ); LocalFreeAndNull( &lpDataA ); return lRetValue; } // RegDeleteKey LONG WINAPI RegDeleteKeyWrapW( HKEY hKey, // handle to open key LPCTSTR lpSubKey) // address of name of subkey to delete { LPSTR lpSubKeyA =NULL; LONG lRetValue = 0; VALIDATE_PROTOTYPE(RegDeleteKey); if (g_bRunningOnNT) return RegDeleteKeyW(hKey, lpSubKey); lpSubKeyA = ConvertWtoA(lpSubKey ); lRetValue = RegDeleteKeyA(hKey, lpSubKeyA ); LocalFreeAndNull ( &lpSubKeyA ); return lRetValue; } // GetUserName BOOL WINAPI GetUserNameWrapW( LPTSTR lpBuffer, // address of name buffer LPDWORD nSize ) // address of size of name buffer { CHAR lpBufferA[MAX_PATH]; DWORD nSizeA, nSizeW; BOOL bRetValue; LPWSTR lpwszBuffer = NULL; VALIDATE_PROTOTYPE(GetUserName); if (g_bRunningOnNT) return GetUserNameW(lpBuffer, nSize); nSizeA = MAX_PATH; bRetValue = GetUserNameA( lpBufferA, &nSizeA ); lpwszBuffer = ConvertAtoW(lpBufferA ); if (lpBuffer == NULL ) bRetValue = FALSE; nSizeW = My_wcslen(lpwszBuffer); if ( *nSize < nSizeW ) { *nSize = nSizeW + 1; bRetValue = FALSE; } if ( bRetValue == TRUE ) { My_wcscpy( lpBuffer, lpwszBuffer ); *nSize = nSizeW + 1; } LocalFreeAndNull( &lpwszBuffer ); return bRetValue; } // RegEnumValue LONG WINAPI RegEnumValueWrapW( HKEY hKey, // handle to key to query DWORD dwIndex, // index of value to query LPTSTR lpValueName, // address of buffer for value string LPDWORD lpcbValueName, // address for size of value buffer LPDWORD lpReserved, // reserved LPDWORD lpType, // address of buffer for type code LPBYTE lpData, // address of buffer for value data LPDWORD lpcbData ) // address for size of data buffer { LONG lRetValue = 0; CHAR lpValueNameA[MAX_PATH]; LPWSTR lpValueNameW = NULL, lpDataW= NULL; LPSTR lpDataA = NULL; DWORD cbValueName, cbData; VALIDATE_PROTOTYPE(RegEnumValue); if (g_bRunningOnNT) return RegEnumValueW(hKey, dwIndex, lpValueName, lpcbValueName, lpReserved, lpType, lpData, lpcbData); // [PaulHi] Validate return parameters if (!lpValueName || !lpcbValueName) return ERROR_INVALID_PARAMETER; if ( lpData && lpcbData &&( *lpcbData != 0 ) ) { lpDataA = LocalAlloc( LMEM_ZEROINIT, *lpcbData ); cbData = *lpcbData; } cbValueName = MAX_PATH; lRetValue = RegEnumValueA(hKey, dwIndex, lpValueNameA, &cbValueName, lpReserved, lpType, lpDataA, &cbData); if ( lRetValue != ERROR_SUCCESS ) return lRetValue; lpValueNameW = ConvertAtoW( lpValueNameA ); cbValueName = My_wcslen( lpValueNameW ) + 1; if ( lpType && (*lpType != REG_EXPAND_SZ) && ( *lpType!= REG_MULTI_SZ) && ( *lpType != REG_SZ ) ) { CopyMemory(lpValueName, lpValueNameW, cbValueName * sizeof(WCHAR) ); *lpcbValueName = cbValueName; if ( lpData && lpcbData) { CopyMemory(lpData, lpDataA, cbData ); *lpcbData = cbData; LocalFreeAndNull( &lpDataA ); } LocalFreeAndNull( &lpValueNameW ); return lRetValue; } if ( lpType && ((*lpType == REG_EXPAND_SZ) || (*lpType == REG_SZ)) ) { CopyMemory(lpValueName, lpValueNameW, cbValueName * sizeof(WCHAR) ); *lpcbValueName = cbValueName; if ( lpData && lpcbData ) { LPWSTR lpDataW; lpDataW = ConvertAtoW( lpDataA ); cbData = My_wcslen(lpDataW) + 1; CopyMemory(lpData, lpDataW, cbData * sizeof(WCHAR) ); *lpcbData = cbData * sizeof(WCHAR); LocalFreeAndNull( &lpDataW ); } LocalFreeAndNull( &lpValueNameW ); return lRetValue; } // the last case REG_MULTI_SZ. CopyMemory(lpValueName, lpValueNameW, cbValueName * sizeof(WCHAR) ); *lpcbValueName = cbValueName; if ( lpData && lpcbData ) { LPWSTR lpDataW= NULL; LPSTR lpDataAt = NULL; LPWSTR lpDataT = NULL; DWORD cbDataAll; lpDataAt = lpDataA; cbDataAll = 0; lpDataT = (LPWSTR)lpData; while ( *lpDataAt != '\0' ) { lpDataW = ConvertAtoW( lpDataAt ); cbDataAll += My_wcslen( lpDataW ) + 1; My_wcscpy(lpDataT, lpDataW); lpDataT += My_wcslen(lpDataW) + 1; lpDataAt += lstrlenA(lpDataAt) + 1; LocalFreeAndNull( &lpDataW ); } cbDataAll ++; *lpDataT = 0x0000; *lpcbData = cbDataAll * sizeof(WCHAR); } LocalFreeAndNull( &lpValueNameW ); return lRetValue; } // RegDeleteValue LONG WINAPI RegDeleteValueWrapW( HKEY hKey, // handle to key LPCTSTR lpValueName ) // address of value name { LPSTR lpValueNameA = NULL; LONG lRetValue=0; VALIDATE_PROTOTYPE(RegDeleteValue); if (g_bRunningOnNT) return RegDeleteValueW(hKey, lpValueName); lpValueNameA = ConvertWtoA( lpValueName ); lRetValue = RegDeleteValueA( hKey, lpValueNameA ); LocalFreeAndNull( & lpValueNameA ); return lRetValue; } // RegCreateKey LONG WINAPI RegCreateKeyWrapW( HKEY hKey, // handle to an open key LPCTSTR lpSubKey, // address of name of subkey to open PHKEY phkResult ) // address of buffer for opened handle { LPSTR lpSubKeyA = NULL; LONG lRetValue =0; VALIDATE_PROTOTYPE(RegCreateKey); if (g_bRunningOnNT) return RegCreateKeyW(hKey, lpSubKey, phkResult); lpSubKeyA = ConvertWtoA( lpSubKey ); lRetValue = RegCreateKeyA(hKey, lpSubKeyA, phkResult); LocalFreeAndNull( &lpSubKeyA ); return lRetValue; } // in header file wincrypt.h // CryptAcquireContext BOOL WINAPI CryptAcquireContextWrapW( HCRYPTPROV *phProv, // out LPCTSTR pszContainer, // in LPCTSTR pszProvider, // in DWORD dwProvType, // in DWORD dwFlags ) // in { LPSTR pszContainerA = NULL; LPSTR pszProviderA = NULL; BOOL bRetValue =0; VALIDATE_PROTOTYPE(CryptAcquireContext); if (g_bRunningOnNT) return CryptAcquireContextW(phProv, pszContainer, pszProvider, dwProvType, dwFlags ); pszContainerA = ConvertWtoA( pszContainer ); pszProviderA = ConvertWtoA ( pszProvider ); bRetValue = CryptAcquireContextA(phProv, pszContainerA, pszProviderA, dwProvType, dwFlags ); LocalFreeAndNull( &pszContainerA ); LocalFreeAndNull( &pszProviderA ); return bRetValue; } LONG WINAPI RegQueryValueExWrapW( HKEY hKey, // handle to key to query LPCTSTR lpValueName, // address of name of value to query LPDWORD lpReserved, // reserved LPDWORD lpType, // address of buffer for value type LPBYTE lpData, // address of data buffer LPDWORD lpcbData ) // address of data buffer size { LONG lRetValue =0; LPSTR lpValueNameA= NULL; LPWSTR lpDataW= NULL; LPSTR lpDataA = NULL; DWORD cbData=0; DWORD dwRealType; // VALIDATE_PROTOTYPE(RegQueryValueEx); if (g_bRunningOnNT) return RegQueryValueExW(hKey, lpValueName, lpReserved, lpType, lpData, lpcbData ); cbData = 0; if ( lpData && lpcbData &&( *lpcbData != 0 ) ) { lpDataA = LocalAlloc( LMEM_ZEROINIT, *lpcbData ); cbData = *lpcbData; } lpValueNameA = ConvertWtoA(lpValueName); lRetValue = RegQueryValueExA(hKey, lpValueNameA, lpReserved, &dwRealType, lpDataA, &cbData); if (lpType) *lpType = dwRealType; if ( (lRetValue != ERROR_SUCCESS) || (lpData == NULL) || (lpcbData == NULL ) ) { LocalFreeAndNull( &lpValueNameA ); return lRetValue; } if ( (dwRealType != REG_EXPAND_SZ) && ( dwRealType != REG_MULTI_SZ) && ( dwRealType != REG_SZ ) ){ CopyMemory(lpData, lpDataA, cbData ); *lpcbData = cbData; LocalFreeAndNull( &lpDataA ); LocalFreeAndNull( &lpValueNameA ); return lRetValue; } if ( (dwRealType == REG_EXPAND_SZ) || (dwRealType == REG_SZ) ) { LPWSTR lpDataW= NULL; lpDataW = ConvertAtoW( lpDataA ); cbData = My_wcslen(lpDataW) + 1; CopyMemory(lpData, lpDataW, cbData * sizeof(WCHAR) ); *lpcbData = cbData * sizeof(WCHAR); LocalFreeAndNull( &lpDataW ); LocalFreeAndNull( &lpDataA ); LocalFreeAndNull( &lpValueNameA ); return lRetValue; } // the last case REG_MULTI_SZ. if (lpData && lpcbData) { LPWSTR lpDataW= NULL; LPSTR lpDataAt= NULL; LPWSTR lpDataT= NULL; DWORD cbDataAll=0; lpDataAt = lpDataA; cbDataAll = 0; lpDataT = (LPWSTR)lpData; while ( *lpDataAt != '\0' ) { lpDataW = ConvertAtoW( lpDataAt ); cbDataAll += My_wcslen( lpDataW ) + 1; My_wcscpy(lpDataT, lpDataW); lpDataT += My_wcslen(lpDataW) + 1; lpDataAt += lstrlenA(lpDataAt) + 1; LocalFreeAndNull( &lpDataW ); } cbDataAll ++; *lpDataT = 0x0000; *lpcbData = cbDataAll * sizeof(WCHAR); } LocalFreeAndNull( &lpDataA ); LocalFreeAndNull( &lpValueNameA ); return lRetValue; } // RegCreateKeyEx LONG WINAPI RegCreateKeyExWrapW( HKEY hKey, // handle to an open key LPCTSTR lpSubKey, // address of subkey name DWORD Reserved, // reserved LPTSTR lpClass, // address of class string DWORD dwOptions, // special options flag REGSAM samDesired, // desired security access LPSECURITY_ATTRIBUTES lpSecurityAttributes, // address of key security structure PHKEY phkResult, // address of buffer for opened handle LPDWORD lpdwDisposition ) // address of disposition value buffer { LPSTR lpSubKeyA = NULL; LPSTR lpClassA = NULL; LONG lRetValue=0; VALIDATE_PROTOTYPE(RegCreateKeyEx); if (g_bRunningOnNT) return RegCreateKeyExW(hKey, lpSubKey, Reserved, lpClass, dwOptions, samDesired, lpSecurityAttributes, phkResult, lpdwDisposition); lpSubKeyA = ConvertWtoA( lpSubKey ); lpClassA = ConvertWtoA ( lpClass ); lRetValue = RegCreateKeyExA(hKey, lpSubKeyA, Reserved, lpClassA, dwOptions, samDesired, lpSecurityAttributes, phkResult, lpdwDisposition); LocalFreeAndNull( &lpSubKeyA ); LocalFreeAndNull( &lpClassA ); return lRetValue; } // RegSetValueEx LONG WINAPI RegSetValueExWrapW( HKEY hKey, // handle to key to set value for LPCTSTR lpValueName, // name of the value to set DWORD Reserved, // reserved DWORD dwType, // flag for value type CONST BYTE *lpData, // address of value data DWORD cbData ) // size of value data { LPSTR lpValueNameA = NULL; LPSTR lpStrA= NULL; BYTE *lpDataA= NULL; DWORD cbDataA=0; LONG lRetValue=0; VALIDATE_PROTOTYPE(RegSetValueEx); if (g_bRunningOnNT) return RegSetValueExW(hKey, lpValueName, Reserved, dwType, lpData, cbData); lpValueNameA = ConvertWtoA( lpValueName ); if ( ( dwType != REG_EXPAND_SZ ) && (dwType != REG_MULTI_SZ) && (dwType != REG_SZ) ) { lRetValue = RegSetValueExA(hKey, lpValueNameA, Reserved, dwType, lpData, cbData); LocalFreeAndNull( &lpValueNameA ); return lRetValue; } if ( ( dwType == REG_EXPAND_SZ) || ( dwType == REG_SZ ) ) { lpDataA = ConvertWtoA( (LPWSTR) lpData ); cbDataA = lstrlenA(lpDataA) + 1; lRetValue = RegSetValueExA(hKey, lpValueNameA, Reserved, dwType, lpDataA, cbDataA); LocalFreeAndNull( &lpValueNameA ); LocalFreeAndNull( &lpDataA ); return lRetValue; } // the last case is for REG_MULT_SZ if ( lpData ) { LPWSTR lpDataWt= NULL; LPSTR lpDataAt= NULL; DWORD cbDataAll=0; lpDataA = LocalAlloc(LMEM_ZEROINIT, cbData); lpDataAt = lpDataA; cbDataAll = 0; lpDataWt = (LPWSTR)lpData; while ( *lpDataWt != 0x0000 ) { WideCharToMultiByte(CP_ACP,0, lpDataWt, -1, lpDataAt, -1, NULL, NULL ); cbDataAll += lstrlenA(lpDataAt) + 1; lpDataWt += My_wcslen(lpDataWt) + 1; lpDataAt += lstrlenA(lpDataAt) + 1; } cbDataAll ++; *lpDataAt = 0x00; lRetValue = RegSetValueExA(hKey, lpValueNameA, Reserved, dwType, lpDataA, cbDataAll); LocalFreeAndNull( &lpDataA ); LocalFreeAndNull( &lpValueNameA ); return lRetValue; } return FALSE; return GetLastError(); } // RegQueryInfoKey LONG WINAPI RegQueryInfoKeyWrapW( HKEY hKey, // handle to key to query LPTSTR lpClass, // address of buffer for class string LPDWORD lpcbClass, // address of size of class string buffer LPDWORD lpReserved, // reserved LPDWORD lpcSubKeys, // address of buffer for number of subkeys LPDWORD lpcbMaxSubKeyLen, // address of buffer for longest subkey // name length LPDWORD lpcbMaxClassLen, // address of buffer for longest class // string length LPDWORD lpcValues, // address of buffer for number of value // entries LPDWORD lpcbMaxValueNameLen, // address of buffer for longest // value name length LPDWORD lpcbMaxValueLen, // address of buffer for longest value // data length LPDWORD lpcbSecurityDescriptor, // address of buffer for security // descriptor length PFILETIME lpftLastWriteTime) // address of buffer for last write time { LPSTR lpClassA= NULL; LONG lRetValue=0; VALIDATE_PROTOTYPE(RegQueryInfoKey); if (g_bRunningOnNT) return RegQueryInfoKeyW(hKey, lpClass, lpcbClass, lpReserved, lpcSubKeys, lpcbMaxSubKeyLen, lpcbMaxClassLen, lpcValues, lpcbMaxValueNameLen, lpcbMaxValueLen,lpcbSecurityDescriptor,lpftLastWriteTime ); lpClassA = ConvertWtoA( lpClass ); lRetValue = RegQueryInfoKeyA(hKey, lpClassA, lpcbClass, lpReserved, lpcSubKeys, lpcbMaxSubKeyLen, lpcbMaxClassLen, lpcValues, lpcbMaxValueNameLen, lpcbMaxValueLen,lpcbSecurityDescriptor,lpftLastWriteTime ); LocalFreeAndNull( &lpClassA ); return lRetValue; } //GDI32.DLL //GetObject int WINAPI GetObjectWrapW( HGDIOBJ hgdiobj, // handle to graphics object of interest int cbBuffer, // size of buffer for object information LPVOID lpvObject ) // pointer to buffer for object information { int iRetValue =0; LOGFONTA lfFontA; LOGFONTW lfFontW; VALIDATE_PROTOTYPE(GetObject); if (g_bRunningOnNT) return GetObjectW(hgdiobj, cbBuffer, lpvObject); if ( GetObjectType(hgdiobj) != OBJ_FONT ) { iRetValue = GetObjectA( hgdiobj, cbBuffer, lpvObject ); return iRetValue; } // if Object type is HFONT, the return value lpvObject will point to LOGFONT which contains // a field lpFaceName with TCHAR * type. if ( cbBuffer != sizeof(LOGFONTW) ) return 0; if (lpvObject == NULL ) return sizeof(LOGFONTW); iRetValue = GetObjectA( hgdiobj, sizeof(lfFontA), &lfFontA ); if (iRetValue == 0 ) return 0; iRetValue = sizeof(LOGFONTW); // copy all the fields except lfFaceName from lfFontA to lfFontW CopyMemory(&lfFontW,&lfFontA, sizeof(LOGFONTA) ); // translate the lfFaceName[] from A to W MultiByteToWideChar(GetACP(), 0, lfFontA.lfFaceName, LF_FACESIZE, lfFontW.lfFaceName, LF_FACESIZE); CopyMemory(lpvObject, &lfFontW, sizeof(LOGFONTW) ); return iRetValue; } // StartDoc int WINAPI StartDocWrapW( HDC hdc, // handle to device context CONST DOCINFO *lpdi ) // address of structure with file names { int iRetValue=0; DOCINFOA diA; LPSTR lpszDocName= NULL, lpszOutput= NULL, lpszDatatype= NULL; VALIDATE_PROTOTYPE(StartDoc); if (g_bRunningOnNT) return StartDocW(hdc,lpdi); diA.cbSize = sizeof(DOCINFOA); lpszDocName = ConvertWtoA( lpdi->lpszDocName ); lpszOutput = ConvertWtoA( lpdi->lpszOutput ); lpszDatatype= ConvertWtoA( lpdi->lpszDatatype); diA.lpszDocName = lpszDocName; diA.lpszOutput = lpszOutput; diA.lpszDatatype = lpszDatatype; diA.fwType = lpdi->fwType; iRetValue = StartDocA( hdc, &diA ); LocalFreeAndNull( &lpszDocName ); LocalFreeAndNull( &lpszOutput ); LocalFreeAndNull( &lpszDatatype ); return iRetValue; } // CreateFontIndirect HFONT WINAPI CreateFontIndirectWrapW (CONST LOGFONT *lplf ) // pointer to logical font structure { HFONT hRetValue; LOGFONTA lfFontA; VALIDATE_PROTOTYPE(CreateFontIndirect); if (g_bRunningOnNT) return CreateFontIndirectW(lplf); // copy LOGFONTW 's fields except lfFaceName to lfFontA. CopyMemory(&lfFontA, lplf, sizeof(LOGFONTW) - LF_FACESIZE * sizeof(WCHAR) ); WideCharToMultiByte(CP_ACP, 0, lplf->lfFaceName, LF_FACESIZE, lfFontA.lfFaceName, LF_FACESIZE, NULL, NULL ); hRetValue = CreateFontIndirectA( &lfFontA ); return hRetValue; } //KERNEL32.DLL // GetLocaleInfo int WINAPI GetLocaleInfoWrapW( LCID Locale, // locale identifier LCTYPE LCType, // type of information LPTSTR lpLCData, // address of buffer for information int cchData ) // size of buffer { int iRetValue=0; LPSTR lpLCDataA= NULL; int cchDataA=0; LPWSTR lpLCDataW= NULL; int cchDataW=0; VALIDATE_PROTOTYPE(GetLocaleInfo); if (g_bRunningOnNT) return GetLocaleInfoW(Locale, LCType, lpLCData, cchData); iRetValue = GetLocaleInfoA(Locale, LCType, NULL, 0); if ( iRetValue == 0 ) return iRetValue; cchDataA = iRetValue; lpLCDataA = LocalAlloc(LMEM_ZEROINIT, cchDataA+1 ); iRetValue = GetLocaleInfoA(Locale, LCType, lpLCDataA, cchDataA); lpLCDataA[cchDataA] = '\0'; lpLCDataW = ConvertAtoW( lpLCDataA ); cchDataW = My_wcslen( lpLCDataW ); if ( (cchData == 0) || (lpLCData == NULL) ) { LocalFreeAndNull(&lpLCDataA); LocalFreeAndNull(&lpLCDataW); return cchDataW ; } CopyMemory(lpLCData, lpLCDataW, cchDataW * sizeof(WCHAR) ); lpLCData[cchDataW] = '\0'; LocalFreeAndNull(&lpLCDataA); LocalFreeAndNull(&lpLCDataW); return cchData; } // CreateDirectory BOOL WINAPI CreateDirectoryWrapW(LPCTSTR lpPathName, // pointer to directory path string LPSECURITY_ATTRIBUTES lpSecurityAttributes)// pointer to security descriptor { BOOL bRetValue = FALSE; LPSTR lpPathNameA = NULL; VALIDATE_PROTOTYPE(CreateDirectory); if (g_bRunningOnNT) return CreateDirectoryW(lpPathName, lpSecurityAttributes); lpPathNameA = ConvertWtoA( lpPathName ); bRetValue = CreateDirectoryA( lpPathNameA, lpSecurityAttributes ); LocalFreeAndNull( &lpPathNameA ); return bRetValue; } // GetWindowsDirectory UINT WINAPI GetWindowsDirectoryWrapW( LPTSTR lpBuffer, // address of buffer for Windows directory UINT uSize ) // size of directory buffer { UINT uRetValue = 0; LPSTR lpBufferA = NULL; VALIDATE_PROTOTYPE(GetWindowsDirectory); if (g_bRunningOnNT) return GetWindowsDirectoryW(lpBuffer, uSize); lpBufferA = LocalAlloc( LMEM_ZEROINIT, uSize * sizeof(WCHAR) ); uRetValue = GetWindowsDirectoryA( lpBufferA, uSize * sizeof(WCHAR) ); uRetValue =MultiByteToWideChar(GetACP( ), 0, lpBufferA, -1, lpBuffer, uSize); LocalFreeAndNull( &lpBufferA ); return uRetValue; } // GetSystemDirectory UINT WINAPI GetSystemDirectoryWrapW( LPTSTR lpBuffer, // address of buffer for system directory UINT uSize ) // size of directory buffer { UINT uRetValue = 0; LPSTR lpBufferA = NULL; VALIDATE_PROTOTYPE(GetSystemDirectory); if (g_bRunningOnNT) return GetSystemDirectoryW(lpBuffer, uSize); lpBufferA = LocalAlloc( LMEM_ZEROINIT, uSize * sizeof(WCHAR) ); uRetValue = GetSystemDirectoryA( lpBufferA, uSize * sizeof(WCHAR) ); uRetValue =MultiByteToWideChar(GetACP( ), 0, lpBufferA, -1, lpBuffer, uSize); LocalFreeAndNull( &lpBufferA ); return uRetValue; } // GetStringType the parameters are not the same BOOL WINAPI GetStringTypeWrapW( DWORD dwInfoType, // information-type options LPCTSTR lpSrcStr, // pointer to the source string int cchSrc, // size, in Characters, of the source string LPWORD lpCharType ) // pointer to the buffer for output { BOOL bRetValue = 0; LPSTR lpSrcStrA = NULL; VALIDATE_PROTOTYPE(GetStringType); if (g_bRunningOnNT) return GetStringTypeW(dwInfoType, lpSrcStr, cchSrc, lpCharType); lpSrcStrA = ConvertWtoA( lpSrcStr ); bRetValue = GetStringTypeA( LOCALE_USER_DEFAULT, dwInfoType, lpSrcStrA, -1, lpCharType); LocalFreeAndNull( &lpSrcStrA ); return bRetValue; } // GetProfileInt UINT WINAPI GetProfileIntWrapW( LPCTSTR lpAppName, // address of section name LPCTSTR lpKeyName, // address of key name INT nDefault ) // default value if key name is not found { UINT uRetValue = 0; LPSTR lpAppNameA = NULL; LPSTR lpKeyNameA = NULL; VALIDATE_PROTOTYPE(GetProfileInt); if (g_bRunningOnNT) return GetProfileIntW(lpAppName, lpKeyName, nDefault); lpAppNameA = ConvertWtoA( lpAppName ); lpKeyNameA = ConvertWtoA( lpKeyName ); uRetValue = GetProfileIntA( lpAppNameA, lpKeyNameA, nDefault); LocalFreeAndNull( &lpAppNameA ); LocalFreeAndNull( &lpKeyNameA ); return uRetValue; } // LCMapString int WINAPI LCMapStringWrapW( LCID Locale, // locale identifier DWORD dwMapFlags, // mapping transformation type LPCTSTR lpSrcStr, // address of source string int cchSrc, // number of characters in source string LPTSTR lpDestStr, // address of destination buffer int cchDest ) // size of destination buffer { int iRetValue =0; LPSTR lpSrcStrA = NULL; LPSTR lpDestStrA = NULL; LPWSTR lpDestStrW = NULL; int cchSrcA, cchDestA, cchDestW; VALIDATE_PROTOTYPE(LCMapString); if (g_bRunningOnNT) return LCMapStringW(Locale, dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest); lpSrcStrA = ConvertWtoA( lpSrcStr ); cchSrcA = lstrlenA(lpSrcStrA); lpDestStrA = LocalAlloc(LMEM_ZEROINIT, cchDest * sizeof(WCHAR) ); cchDestA = cchDest * sizeof(WCHAR); iRetValue = LCMapStringA(Locale,dwMapFlags,lpSrcStrA,cchSrcA,lpDestStrA,cchDestA); // [PaulHi] 6/8/99 Don't fill the buffer if the pointer is NULL. if (lpDestStr && iRetValue != 0) { lpDestStrW = ConvertAtoW(lpDestStrA); iRetValue = My_wcslen(lpDestStrW) + 1; // Ensure that we don't overwrite the output buffer iRetValue = (iRetValue <= cchDest) ? iRetValue : cchDest; CopyMemory( lpDestStr, lpDestStrW, iRetValue * sizeof(WCHAR) ); LocalFreeAndNull( &lpDestStrW ); } LocalFreeAndNull( &lpDestStrA ); LocalFreeAndNull( &lpSrcStrA ); return iRetValue; } // GetFileAttributes DWORD WINAPI GetFileAttributesWrapW( LPCTSTR lpFileName ) // pointer to the name of a file or directory { DWORD dRetValue =0; LPSTR lpFileNameA = NULL; VALIDATE_PROTOTYPE(GetFileAttributes); if (g_bRunningOnNT) return GetFileAttributes(lpFileName); lpFileNameA = ConvertWtoA( lpFileName ); dRetValue = GetFileAttributesA(lpFileNameA ); LocalFreeAndNull ( &lpFileNameA ); return dRetValue; } // CompareString int WINAPI CompareStringWrapW( LCID Locale, // locale identifier DWORD dwCmpFlags, // comparison-style options LPCWSTR lpString1, // pointer to first string int cchCount1, // size, in bytes or characters, of first string LPCWSTR lpString2, // pointer to second string int cchCount2 ) // size, in bytes or characters, of second string { int iRetValue =0; LPSTR lpString1A = NULL, lpString2A = NULL; LPWSTR pszString1 = NULL, pszString2 = NULL; VALIDATE_PROTOTYPE(CompareString); if (g_bRunningOnNT) return CompareStringW(Locale, dwCmpFlags, lpString1, cchCount1, lpString2, cchCount2); // [PaulHi] 4/1/99 Raid 75303 If the character count value(s) are -1 then the // input string(s) are already zero terminated and can be converted to ANSI directly. Assert(lpString1); Assert(lpString2); if (cchCount1 == -1) { // Already zero terminated string // Not great to cast const to non-const, but we don't modify the string pszString1 = (LPWSTR)lpString1; } else { // Convert to zero terminated string pszString1 = LocalAlloc(LMEM_FIXED, (cchCount1+1)*sizeof(WCHAR)); if (!pszString1) goto exit; // Zero inited buffer lstrcpynWrapW(pszString1, lpString1, cchCount1+1); } if (cchCount2 == -1) { // Already zero terminated string // Not great to cast const to non-const, but we don't modify the string pszString2 = (LPWSTR)lpString2; } else { // Convert to zero terminated string pszString2 = LocalAlloc(LMEM_FIXED, (cchCount2+1)*sizeof(WCHAR)); if (!pszString2) goto exit; // Zero inited buffer lstrcpynWrapW(pszString2, lpString2, cchCount2+1); } // Convert to ANSI, statistically improve our odds by checking that there // wasn't data loss on the first character. It's too expensive to do a // full test every time. lpString1A = ConvertWtoA( pszString1 ); if (!lpString1A || (lpString1A[0]=='?' && pszString1[0]!=L'?')) goto exit; lpString2A = ConvertWtoA( pszString2 ); if (!lpString2A || (lpString2A[0]=='?' && pszString2[0]!=L'?')) goto exit; iRetValue = CompareStringA(Locale,dwCmpFlags,lpString1A,lstrlenA(lpString1A),lpString2A,lstrlenA(lpString2A)); exit: LocalFreeAndNull( &lpString1A ); LocalFreeAndNull( &lpString2A ); // Only deallocate if allocated locally if (pszString1 != (LPWSTR)lpString1) LocalFreeAndNull( &pszString1 ); if (pszString2 != (LPWSTR)lpString2) LocalFreeAndNull( &pszString2 ); return iRetValue; } // lstrcpy LPTSTR WINAPI lstrcpyWrapW( LPTSTR lpString1, // pointer to buffer LPCTSTR lpString2 ) // pointer to string to copy { VALIDATE_PROTOTYPE(lstrcpy); if (g_bRunningOnNT) return lstrcpyW(lpString1, lpString2); CopyMemory(lpString1, lpString2, (My_wcslen(lpString2) + 1) * sizeof(WCHAR) ); return lpString1; } // lstrcmpi int WINAPI lstrcmpiWrapW( LPCTSTR lpString1, // pointer to first string LPCTSTR lpString2 ) // pointer to second string { int iRetValue = 0; LPSTR lpString1A = NULL ; LPSTR lpString2A = NULL ; VALIDATE_PROTOTYPE(lstrcmpi); if (g_bRunningOnNT) return lstrcmpiW(lpString1, lpString2); lpString1A = ConvertWtoA( lpString1 ); lpString2A = ConvertWtoA( lpString2 ); iRetValue = lstrcmpiA(lpString1A, lpString2A ); LocalFreeAndNull( &lpString1A ); LocalFreeAndNull( &lpString2A ); return iRetValue; } // LoadLibrary HINSTANCE WINAPI LoadLibraryWrapW( LPCTSTR lpLibFileName ) // address of filename of executable module { HINSTANCE hRetValue =0; LPSTR lpLibFileNameA = NULL; VALIDATE_PROTOTYPE(LoadLibrary); if (g_bRunningOnNT) return LoadLibraryW(lpLibFileName); lpLibFileNameA = ConvertWtoA(lpLibFileName); hRetValue = LoadLibraryA( lpLibFileNameA ); LocalFreeAndNull( &lpLibFileNameA ); return hRetValue; } // GetTextExtentPoint32 BOOL WINAPI GetTextExtentPoint32WrapW(HDC hdc, LPCWSTR pwszBuf, int nLen, LPSIZE psize) { LPSTR pszBuf = NULL; BOOL bRtn = FALSE; VALIDATE_PROTOTYPE(GetTextExtentPoint32); if (g_bRunningOnNT) return GetTextExtentPoint32W(hdc, pwszBuf, nLen, psize); pszBuf = ConvertWtoA(pwszBuf); if (pszBuf) { nLen = lstrlenA(pszBuf); bRtn = GetTextExtentPoint32A(hdc, pszBuf, nLen, psize); LocalFreeAndNull(&pszBuf); } else { psize->cx = 0; psize->cy = 0; } return bRtn; } // GetTimeFormat int WINAPI GetTimeFormatWrapW( LCID Locale, // locale for which time is to be formatted DWORD dwFlags, // flags specifying function options CONST SYSTEMTIME *lpTime, // time to be formatted LPCTSTR lpFormat, // time format string LPTSTR lpTimeStr, // buffer for storing formatted string int cchTime ) // size, in bytes or characters, of the buffer { int iRetValue =0; LPSTR lpFormatA = NULL; LPWSTR lpTimeStrW = NULL; LPSTR lpTimeStrA = NULL; int cchTimeA=0, cchTimeW=0; VALIDATE_PROTOTYPE(GetTimeFormat); if (g_bRunningOnNT) return GetTimeFormatW(Locale, dwFlags, lpTime, lpFormat, lpTimeStr, cchTime); lpFormatA = ConvertWtoA( lpFormat ); cchTimeA = GetTimeFormatA(Locale, dwFlags, lpTime, lpFormatA, NULL, 0); lpTimeStrA = LocalAlloc(LMEM_ZEROINIT, cchTimeA ); iRetValue = GetTimeFormatA(Locale, dwFlags, lpTime, lpFormatA, lpTimeStrA, cchTimeA ); if ( iRetValue != 0 ) { lpTimeStrW = ConvertAtoW( lpTimeStrA ); cchTimeW = My_wcslen( lpTimeStrW ) + 1; iRetValue = cchTimeW; if ( (cchTime !=0) && ( lpTimeStr != NULL ) ) { CopyMemory(lpTimeStr, lpTimeStrW, cchTimeW * sizeof(WCHAR) ); } LocalFreeAndNull( &lpTimeStrW ); } LocalFreeAndNull( &lpFormatA ); LocalFreeAndNull( &lpTimeStrA ); return iRetValue; } // GetDateFormat int WINAPI GetDateFormatWrapW( LCID Locale, // locale for which date is to be formatted DWORD dwFlags, // flags specifying function options CONST SYSTEMTIME *lpDate, // date to be formatted LPCTSTR lpFormat, // date format string LPTSTR lpDateStr, // buffer for storing formatted string int cchDate ) // size of buffer { int iRetValue = 0; LPSTR lpFormatA = NULL; LPWSTR lpDateStrW = NULL; LPSTR lpDateStrA = NULL; int cchDateA, cchDateW; VALIDATE_PROTOTYPE(GetDateFormat); if (g_bRunningOnNT) return GetDateFormatW(Locale, dwFlags, lpDate, lpFormat, lpDateStr, cchDate); lpFormatA = ConvertWtoA( lpFormat ); cchDateA = GetDateFormatA(Locale, dwFlags, lpDate, lpFormatA, NULL, 0); lpDateStrA = LocalAlloc(LMEM_ZEROINIT, cchDateA ); iRetValue = GetDateFormatA(Locale, dwFlags, lpDate, lpFormatA, lpDateStrA, cchDateA ); if ( iRetValue != 0 ) { lpDateStrW = ConvertAtoW( lpDateStrA ); cchDateW = My_wcslen( lpDateStrW ) + 1; iRetValue = cchDateW; if ( (cchDate !=0) && ( lpDateStr != NULL ) ) { CopyMemory(lpDateStr, lpDateStrW, cchDateW * sizeof(WCHAR) ); } LocalFreeAndNull( &lpDateStrW ); } LocalFreeAndNull( &lpFormatA ); LocalFreeAndNull( &lpDateStrA ); return iRetValue; } // lstrcpyn LPTSTR WINAPI lstrcpynWrapW( LPTSTR lpString1, // pointer to target buffer LPCTSTR lpString2, // pointer to source string int iMaxLength ) // number of bytes or characters to copy { int iLength = 0; VALIDATE_PROTOTYPE(lstrcpyn); if (g_bRunningOnNT) return lstrcpynW(lpString1, lpString2, iMaxLength); iLength = My_wcslen(lpString2); if ( iLength >= iMaxLength ) iLength = iMaxLength-1; CopyMemory(lpString1, lpString2, iLength * sizeof(WCHAR) ); lpString1[iLength] = 0x0000; return lpString1; } // CreateFile HANDLE WINAPI CreateFileWrapW( LPCTSTR lpFileName, // pointer to name of the file DWORD dwDesiredAccess, // access (read-write) mode DWORD dwShareMode, // share mode LPSECURITY_ATTRIBUTES lpSecurityAttributes, // pointer to security attributes DWORD dwCreationDisposition, // how to create DWORD dwFlagsAndAttributes, // file attributes HANDLE hTemplateFile ) // handle to file with attributes to copy { LPSTR lpFileA = NULL; HANDLE hFile = NULL; VALIDATE_PROTOTYPE(CreateFile); if (g_bRunningOnNT) return CreateFileW( lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile); lpFileA = ConvertWtoA(lpFileName); hFile = CreateFileA(lpFileA, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile); LocalFreeAndNull(&lpFileA); return (hFile); } // OutputDebugString VOID WINAPI OutputDebugStringWrapW(LPCTSTR lpOutputString ) // pointer to string to be displayed { LPSTR lpOutputStringA = NULL; VALIDATE_PROTOTYPE(OutputDebugString); if (g_bRunningOnNT) { OutputDebugStringW(lpOutputString); return; } lpOutputStringA = ConvertWtoA( lpOutputString ); OutputDebugStringA( lpOutputStringA ); LocalFreeAndNull( &lpOutputStringA ); } // lstrcat LPTSTR WINAPI lstrcatWrapW( LPTSTR lpString1, // pointer to buffer for concatenated strings LPCTSTR lpString2 ) // pointer to string to add to string1 { LPWSTR lpwStr = NULL; VALIDATE_PROTOTYPE(lstrcat); if (g_bRunningOnNT) return lstrcatW(lpString1, lpString2); lpwStr = lpString1 + My_wcslen(lpString1); CopyMemory(lpwStr, lpString2, (My_wcslen(lpString2)+1) * sizeof(WCHAR) ); return lpString1; } // FormatMessage with va_list // // Since it's hard to muck with the Argument List, instead, we'll go throught // the source string and explicitly turn any %x to %x!ws! indicating that the // arguments have Wide Strings in them. // // For sanity we assume we won't ever get more than 9 arguments // static const LPWSTR lpWideFormat = TEXT("!ws!"); DWORD WINAPI FormatMessageWrapW( DWORD dwFlags, // source and processing options LPCVOID lpSource, // pointer to message source DWORD dwMessageId, // requested message identifier DWORD dwLanguageId, // language identifier for requested message LPTSTR lpBuffer, // pointer to message buffer DWORD nSize, // maximum size of message buffer va_list *Arguments ) // pointer to array of message inserts { DWORD dwResult=0, iNumArg, iNum; LPSTR lpSourceA = NULL; LPSTR pszBuffer = NULL; LPWSTR lpTemp1=NULL, lpTemp2=NULL; VALIDATE_PROTOTYPE(FormatMessage); if (g_bRunningOnNT) return FormatMessageW(dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments); // FORMAT_MESSAGE_FROM_STRING means that the source is a string. // Otherwise, it's an opaque LPVOID (aka, an atom). // if ( !(dwFlags & FORMAT_MESSAGE_FROM_STRING) || !(dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ) { return 0; // we don't handle these cases } if ( !(dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY) ) { LPWSTR lpModifiedSource; DebugTrace(TEXT("WARNING: FormatMessageWrap() is being called in Win9X with wide char argument strings. DBCS characters may not be converted correctly!")); if(!(lpModifiedSource = LocalAlloc(LMEM_ZEROINIT, sizeof(TCHAR)*(lstrlen(lpSource)+1)*4))) // Four times is big enough goto exit; lpTemp1 = (LPWSTR)lpSource; My_wcscpy(lpModifiedSource, lpSource); lpTemp2 = lpModifiedSource; while(lpTemp1 && *lpTemp1) { if( *lpTemp1 == '%' && (*(lpTemp1+1) >= '1' && *(lpTemp1+1) <= '9') && *(lpTemp1+2) != '!') //if there isn't a hard-coded printf format specified here { lpTemp2 += 2; //skip 2 to get past the %9 lpTemp1 += 2; My_wcscpy(lpTemp2, lpWideFormat); My_wcscat(lpTemp2, lpTemp1); lpTemp2 += My_wcslen(lpWideFormat); } else { lpTemp1++; lpTemp2++; } } lpSourceA = ConvertWtoA( lpModifiedSource ); FormatMessageA( dwFlags, lpSourceA, dwMessageId, dwLanguageId, (LPSTR)&pszBuffer, 0, Arguments); LocalFreeAndNull(&lpModifiedSource); } else { // We have an argument array. Convert wide strings to DBCS // Create a new argument array and fill with converted (wide to DBCS) // strings to ensure International DBCS conversion occurs correctly. int n, nArgCount = 0, nBytes = 0; LPVOID * pvArgArray = NULL; lpTemp1 = (LPWSTR)lpSource; while (*lpTemp1) { if (*lpTemp1 == '%') { if ( *(lpTemp1+1) == '%') ++lpTemp1; // "%%" not valid argument, step passed else ++nArgCount; // valid argument } ++lpTemp1; } pvArgArray = LocalAlloc(LMEM_ZEROINIT, (nArgCount * sizeof(LPVOID))); if (!pvArgArray) goto exit; lpTemp1 = (LPWSTR)lpSource; n = 0; while (*lpTemp1) { if (*lpTemp1 == '%') { if (*(lpTemp1+1) == '%') // Skip "%%" ++lpTemp1; else { if ( *(lpTemp1+1) >= '1' && *(lpTemp1+1) <= '9' && *(lpTemp1+2) != '!' ) // Default Unicode string arg { pvArgArray[n] = (LPVOID)ConvertWtoA( (LPWSTR) ((LPVOID *)Arguments)[n] ); nBytes += lstrlenA(pvArgArray[n]); } else pvArgArray[n] = ((LPVOID *)Arguments)[n]; // unknown arg type ++n; Assert(n <= nArgCount); } } ++lpTemp1; } // Check if known argument string lengths exceed 1023 bytes. If it does // abort because Win9X will overrun a buffer and crash. if (nBytes <= 1000) { lpSourceA = ConvertWtoA((LPWSTR)lpSource); FormatMessageA( dwFlags, lpSourceA, dwMessageId, dwLanguageId, (LPSTR)&pszBuffer, 0, (va_list *)pvArgArray); } // Clean up lpTemp1 = (LPWSTR)lpSource; n = 0; while (*lpTemp1) { if (*lpTemp1 == '%') { if (*(lpTemp1+1) == '%') // Skip "%%" ++lpTemp1; else { if ( *(lpTemp1+1) >= '1' && *(lpTemp1+1) <= '9' && *(lpTemp1+2) != '!' ) { LocalFree(pvArgArray[n]); ++n; Assert(n <= nArgCount); } } } ++lpTemp1; } LocalFree(pvArgArray); } if (pszBuffer) { LPWSTR *lpwBuffer; lpwBuffer =(LPWSTR *)(lpBuffer); *lpwBuffer = ConvertAtoW(pszBuffer); dwResult = My_wcslen(*lpwBuffer); LocalFree( pszBuffer ); } exit: LocalFreeAndNull(&lpSourceA); return dwResult; } // GetModuleFileName DWORD WINAPI GetModuleFileNameWrapW( HMODULE hModule, // handle to module to find filename for LPTSTR lpFileName, // pointer to buffer to receive module path DWORD nSize ) // size of buffer, in characters { DWORD dRetValue =0; CHAR FileNameA[MAX_PATH]; LPWSTR lpFileNameW = NULL; VALIDATE_PROTOTYPE(GetModuleFileName); if (g_bRunningOnNT) return GetModuleFileNameW(hModule, lpFileName, nSize); dRetValue = GetModuleFileNameA(hModule, FileNameA, MAX_PATH); if ( dRetValue == 0 ) return 0; lpFileNameW = ConvertAtoW( FileNameA ); dRetValue = My_wcslen( lpFileNameW ); if ( dRetValue > nSize ) dRetValue = nSize; CopyMemory(lpFileName, lpFileNameW, (dRetValue+1) * sizeof(WCHAR) ); LocalFreeAndNull( &lpFileNameW ); return dRetValue; } // GetPrivateProfileInt UINT WINAPI GetPrivateProfileIntWrapW( LPCTSTR lpAppName, // address of section name LPCTSTR lpKeyName, // address of key name INT nDefault, // return value if key name is not found LPCTSTR lpFileName ) // address of initialization filename { UINT uRetValue = 0; LPSTR lpAppNameA = NULL; LPSTR lpKeyNameA = NULL; LPSTR lpFileNameA = NULL; VALIDATE_PROTOTYPE(GetPrivateProfileInt); if (g_bRunningOnNT) return GetPrivateProfileIntW(lpAppName, lpKeyName, nDefault, lpFileName); lpAppNameA = ConvertWtoA( lpAppName ); lpKeyNameA = ConvertWtoA( lpKeyName ); lpFileNameA= ConvertWtoA( lpFileName); uRetValue = GetPrivateProfileIntA( lpAppNameA, lpKeyNameA, nDefault, lpFileNameA); LocalFreeAndNull( &lpAppNameA ); LocalFreeAndNull( &lpKeyNameA ); LocalFreeAndNull( &lpFileNameA); return uRetValue; } // IsBadStringPtr BOOL WINAPI IsBadStringPtrWrapW( LPCTSTR lpsz, // address of string UINT_PTR ucchMax ) // maximum size of string { VALIDATE_PROTOTYPE(IsBadStringPtr); if (g_bRunningOnNT) return IsBadStringPtrW(lpsz, ucchMax); return IsBadStringPtrA( (LPSTR)lpsz, ucchMax * sizeof(WCHAR) ); } // GetPrivateProfileString DWORD WINAPI GetPrivateProfileStringWrapW( LPCTSTR lpAppName, // points to section name LPCTSTR lpKeyName, // points to key name LPCTSTR lpDefault, // points to default string LPTSTR lpReturnedString, // points to destination buffer DWORD nSize, // size of destination buffer LPCTSTR lpFileName ) // points to initialization filename { DWORD dRetValue = 0; LPSTR lpAppNameA = NULL; LPSTR lpKeyNameA = NULL; LPSTR lpDefaultA = NULL; LPSTR lpReturnedStringA = NULL; LPWSTR lpReturnedStringW = NULL; LPSTR lpFileNameA = NULL; DWORD nSizeA = 0; VALIDATE_PROTOTYPE(GetPrivateProfileString); if (g_bRunningOnNT) return GetPrivateProfileStringW(lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize, lpFileName); lpAppNameA = ConvertWtoA( lpAppName ); lpKeyNameA = ConvertWtoA( lpKeyName ); lpDefaultA = ConvertWtoA( lpDefault ); lpFileNameA= ConvertWtoA( lpFileName ); nSizeA = nSize * sizeof(WCHAR)+1; lpReturnedStringA = LocalAlloc( LMEM_ZEROINIT, nSizeA ); nSizeA = GetPrivateProfileStringA(lpAppNameA,lpKeyNameA,lpDefaultA,lpReturnedStringA,nSizeA,lpFileNameA); lpReturnedStringW = ConvertAtoW( lpReturnedStringA ); dRetValue = My_wcslen( lpReturnedStringW ); My_wcscpy(lpReturnedString, lpReturnedStringW); LocalFreeAndNull( &lpAppNameA ); LocalFreeAndNull( &lpKeyNameA ); LocalFreeAndNull( &lpDefaultA ); LocalFreeAndNull( &lpReturnedStringA ); LocalFreeAndNull( &lpReturnedStringW ); LocalFreeAndNull( &lpFileNameA ); return dRetValue; } // lstrcmp int WINAPI lstrcmpWrapW( LPCTSTR lpString1, // pointer to first string LPCTSTR lpString2 ) // pointer to second string { int iRetValue = 0; LPSTR lpString1A = NULL ; LPSTR lpString2A = NULL ; VALIDATE_PROTOTYPE(lstrcmp); if (g_bRunningOnNT) return lstrcmpW(lpString1, lpString2); lpString1A = ConvertWtoA( lpString1 ); lpString2A = ConvertWtoA( lpString2 ); iRetValue = lstrcmpA(lpString1A, lpString2A ); LocalFreeAndNull( &lpString1A ); LocalFreeAndNull( &lpString2A ); return iRetValue; } HANDLE WINAPI CreateMutexWrapW( LPSECURITY_ATTRIBUTES lpMutexAttributes, // pointer to security attributes BOOL bInitialOwner, // flag for initial ownership LPCTSTR lpName ) // pointer to mutex-object name { LPSTR lpNameA = NULL; HANDLE hMutex = NULL; VALIDATE_PROTOTYPE(CreateMutex); if (g_bRunningOnNT) return CreateMutexW(lpMutexAttributes, bInitialOwner, lpName); lpNameA = ConvertWtoA(lpName); hMutex = CreateMutexA(lpMutexAttributes, bInitialOwner, lpNameA); LocalFreeAndNull(&lpNameA); return hMutex; } // GetTempPath DWORD WINAPI GetTempPathWrapW( DWORD nBufferLength, // size, in characters, of the buffer LPTSTR lpBuffer ) // pointer to buffer for temp. path { DWORD nRequired = 0; CHAR lpBufferA[MAX_PATH]; LPWSTR lpBufferW = NULL; VALIDATE_PROTOTYPE(GetTempPath); if (g_bRunningOnNT) return GetTempPathW(nBufferLength, lpBuffer); nRequired = GetTempPathA(MAX_PATH, lpBufferA); lpBufferW = ConvertAtoW(lpBufferA); nRequired = My_wcslen(lpBufferW); if ( nRequired < nBufferLength) CopyMemory(lpBuffer, lpBufferW, (nRequired+1)*sizeof(WCHAR) ); return nRequired; } // ExpandEnvironmentStrings DWORD WINAPI ExpandEnvironmentStringsWrapW( LPCTSTR lpSrc, // pointer to string with environment variables LPTSTR lpDst, // pointer to string with expanded environment // variables DWORD nSize ) // maximum characters in expanded string { DWORD dRetValue = 0; LPSTR lpSrcA = NULL; LPSTR lpDstA = NULL; LPWSTR lpDstW = NULL; DWORD nSizeA = 0; VALIDATE_PROTOTYPE(ExpandEnvironmentStrings); if (g_bRunningOnNT) return ExpandEnvironmentStringsW(lpSrc, lpDst, nSize); nSizeA = nSize * sizeof(WCHAR); lpDstA = LocalAlloc( LMEM_ZEROINIT, nSizeA ); lpSrcA = ConvertWtoA( lpSrc ); dRetValue = ExpandEnvironmentStringsA( lpSrcA, lpDstA, nSizeA ); lpDstW = ConvertAtoW( lpDstA ); dRetValue = My_wcslen( lpDstW ); if ( dRetValue < nSize ) My_wcscpy(lpDst, lpDstW); LocalFreeAndNull( &lpSrcA ); LocalFreeAndNull( &lpDstA ); LocalFreeAndNull( &lpDstW ); return dRetValue; } // GetTempFileName UINT WINAPI GetTempFileNameWrapW( LPCTSTR lpPathName, // pointer to directory name for temporary file LPCTSTR lpPrefixString, // pointer to filename prefix UINT uUnique, // number used to create temporary filename LPTSTR lpTempFileName ) // pointer to buffer that receives the new filename { UINT uRetValue = 0; LPSTR lpPathNameA = NULL; LPSTR lpPrefixStringA = NULL; CHAR lpTempFileNameA[MAX_PATH]; LPWSTR lpTempFileNameW = NULL; VALIDATE_PROTOTYPE(GetTempFileName); if (g_bRunningOnNT) return GetTempFileNameW(lpPathName, lpPrefixString, uUnique, lpTempFileName); lpPathNameA = ConvertWtoA( lpPathName ); lpPrefixStringA = ConvertWtoA( lpPrefixString ); uRetValue = GetTempFileNameA(lpPathNameA, lpPrefixStringA, uUnique, lpTempFileNameA); if ( uRetValue != 0 ) { lpTempFileNameW = ConvertAtoW( lpTempFileNameA ); My_wcscpy( lpTempFileName, lpTempFileNameW ); LocalFreeAndNull( &lpTempFileNameW ); } LocalFreeAndNull( &lpPathNameA ); LocalFreeAndNull( &lpPrefixStringA ); return uRetValue; } // BOOL WINAPI ReleaseMutexWrapW( HANDLE hMutex ) // handle to mutex object // DeleteFile BOOL WINAPI DeleteFileWrapW( LPCTSTR lpFileName ) // pointer to name of file to delete { BOOL bRetValue ; LPSTR lpFileNameA = NULL; VALIDATE_PROTOTYPE(DeleteFile); if (g_bRunningOnNT) return DeleteFileW(lpFileName); lpFileNameA = ConvertWtoA( lpFileName ); bRetValue = DeleteFileA( lpFileNameA ); LocalFreeAndNull( &lpFileNameA ); return bRetValue; } // CopyFile BOOL WINAPI CopyFileWrapW( LPCTSTR lpExistingFileName, // pointer to name of an existing file LPCTSTR lpNewFileName, // pointer to filename to copy to BOOL bFailIfExists ) // flag for operation if file exists { BOOL bRetValue; LPSTR lpExistingFileNameA = NULL; LPSTR lpNewFileNameA = NULL; VALIDATE_PROTOTYPE(CopyFile); if (g_bRunningOnNT) return CopyFileW(lpExistingFileName, lpNewFileName, bFailIfExists); lpExistingFileNameA = ConvertWtoA( lpExistingFileName ); lpNewFileNameA = ConvertWtoA( lpNewFileName ); bRetValue = CopyFileA( lpExistingFileNameA, lpNewFileNameA, bFailIfExists); LocalFreeAndNull( & lpExistingFileNameA ); LocalFreeAndNull( & lpNewFileNameA ); return bRetValue; } // FindFirstChangeNotification HANDLE WINAPI FindFirstChangeNotificationWrapW(LPCTSTR lpcwszFilePath, // Directory path of file to watch BOOL bWatchSubtree, // Monitor entire tree DWORD dwNotifyFilter) // Conditions to watch for { HANDLE hRet; LPSTR lpszFilePath; VALIDATE_PROTOTYPE(FindFirstChangeNotification); Assert(lpcwszFilePath); if (g_bRunningOnNT) return FindFirstChangeNotification(lpcwszFilePath, bWatchSubtree, dwNotifyFilter); lpszFilePath = ConvertWtoA(lpcwszFilePath); hRet = FindFirstChangeNotificationA(lpszFilePath, bWatchSubtree, dwNotifyFilter); LocalFreeAndNull(&lpszFilePath); return hRet; } // FindFirstFile HANDLE WINAPI FindFirstFileWrapW( LPCTSTR lpFileName, // pointer to name of file to search for LPWIN32_FIND_DATA lpFindFileData ) // pointer to returned information { HANDLE hRetValue; LPSTR lpFileNameA = NULL; WIN32_FIND_DATAA FindFileDataA; WIN32_FIND_DATAW FindFileDataW; VALIDATE_PROTOTYPE(FindFirstFile); if (g_bRunningOnNT) return FindFirstFileW(lpFileName, lpFindFileData); lpFileNameA = ConvertWtoA(lpFileName); hRetValue = FindFirstFileA( lpFileNameA, &FindFileDataA ); if ( hRetValue != INVALID_HANDLE_VALUE ) { CopyMemory( &FindFileDataW, &FindFileDataA, sizeof(WIN32_FIND_DATAA)-MAX_PATH-14 ); MultiByteToWideChar(GetACP(),0,FindFileDataA.cFileName,MAX_PATH,FindFileDataW.cFileName,MAX_PATH); MultiByteToWideChar(GetACP(),0,FindFileDataA.cAlternateFileName,14,FindFileDataW.cAlternateFileName,14); CopyMemory( lpFindFileData, &FindFileDataW, sizeof(WIN32_FIND_DATAW) ); } LocalFreeAndNull( &lpFileNameA ); return hRetValue; } // GetDiskFreeSpace BOOL WINAPI GetDiskFreeSpaceWrapW( LPCTSTR lpRootPathName, // pointer to root path LPDWORD lpSectorsPerCluster, // pointer to sectors per cluster LPDWORD lpBytesPerSector, // pointer to bytes per sector LPDWORD lpNumberOfFreeClusters, // pointer to number of free clusters LPDWORD lpTotalNumberOfClusters ) // pointer to total number of clusters { BOOL bRetValue; LPSTR lpRootPathNameA = NULL; VALIDATE_PROTOTYPE(GetDiskFreeSpace); if (g_bRunningOnNT) return GetDiskFreeSpaceW(lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters); lpRootPathNameA = ConvertWtoA( lpRootPathName ); bRetValue = GetDiskFreeSpaceA(lpRootPathNameA, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters); LocalFreeAndNull( & lpRootPathNameA ); return bRetValue; } // MoveFile BOOL WINAPI MoveFileWrapW( LPCTSTR lpExistingFileName, // pointer to the name of the existing file LPCTSTR lpNewFileName ) // pointer to the new name for the file { BOOL bRetValue; LPSTR lpExistingFileNameA = NULL; LPSTR lpNewFileNameA = NULL; VALIDATE_PROTOTYPE(MoveFile); if (g_bRunningOnNT) return MoveFileW(lpExistingFileName, lpNewFileName); lpExistingFileNameA = ConvertWtoA( lpExistingFileName ); lpNewFileNameA = ConvertWtoA( lpNewFileName ); bRetValue = MoveFileA( lpExistingFileNameA, lpNewFileNameA ); LocalFreeAndNull( &lpExistingFileNameA ); LocalFreeAndNull( &lpNewFileNameA ); return bRetValue; } // CreateEvent HANDLE WINAPI CreateEventWrapW(LPSECURITY_ATTRIBUTES lpEventAttributes, // pointer to security attributes BOOL bManualReset, // flag for manual-reset event BOOL bInitialState, // flag for initial state LPCTSTR lpcwszName) // pointer to event-object name { HANDLE hRet; LPSTR lpszName; VALIDATE_PROTOTYPE(CreateEvent); if (g_bRunningOnNT) return CreateEventW(lpEventAttributes, bManualReset, bInitialState, lpcwszName); lpszName = ConvertWtoA(lpcwszName); // Handles NULL lpcwszName case hRet = CreateEventA(lpEventAttributes, bManualReset, bInitialState, lpszName); LocalFreeAndNull(&lpszName); return hRet; } //SHELL32.DLL HINSTANCE WINAPI ShellExecuteWrapW( HWND hwnd, LPCTSTR lpOperation, LPCTSTR lpFile, LPCTSTR lpParameters, LPCTSTR lpDirectory, INT nShowCmd ) { HINSTANCE hRetValue; LPSTR lpOperationA = NULL; LPSTR lpFileA = NULL; LPSTR lpParametersA = NULL; LPSTR lpDirectoryA = NULL; VALIDATE_PROTOTYPE(ShellExecute); if (g_bRunningOnNT) return ShellExecuteW(hwnd, lpOperation, lpFile, lpParameters, lpDirectory, nShowCmd); lpOperationA = ConvertWtoA( lpOperation ); lpFileA = ConvertWtoA( lpFile ); lpParametersA= ConvertWtoA( lpParameters ); lpDirectoryA = ConvertWtoA( lpDirectory ); hRetValue = ShellExecuteA(hwnd, lpOperationA, lpFileA, lpParametersA, lpDirectoryA, nShowCmd); LocalFreeAndNull( &lpOperationA); LocalFreeAndNull( &lpFileA ); LocalFreeAndNull( &lpParametersA ); LocalFreeAndNull( &lpDirectoryA ); return hRetValue; } // DragQueryFile UINT WINAPI DragQueryFileWrapW( HDROP hDrop, UINT iFile, LPTSTR lpszFile, UINT cch ) { UINT uRetValue = 0; LPSTR lpszFileA = NULL; LPWSTR lpszFileW = NULL; UINT cchA, cchW =0; VALIDATE_PROTOTYPE(DragQueryFile); if (g_bRunningOnNT) return DragQueryFileW(hDrop, iFile, lpszFile, cch); cchA = DragQueryFileA( hDrop, iFile, NULL, 0 ); lpszFileA = LocalAlloc(LMEM_ZEROINIT, cchA+1 ); uRetValue = DragQueryFileA(hDrop, iFile, lpszFileA, cchA+1); lpszFileW = ConvertAtoW( lpszFileA ); cchW = My_wcslen( lpszFileW ); if ( lpszFile ) CopyMemory( lpszFile, lpszFileW, (cchW+1)*sizeof(WCHAR) ); LocalFreeAndNull( &lpszFileA ); LocalFreeAndNull( &lpszFileW ); return cchW; } //USER32.DLL // CharPrev LPTSTR WINAPI CharPrevWrapW( LPCTSTR lpszStart, // pointer to first character LPCTSTR lpszCurrent ) // pointer to current character { LPWSTR lpszReturn = NULL; VALIDATE_PROTOTYPE(CharPrev); if (g_bRunningOnNT) return CharPrevW(lpszStart, lpszCurrent); if (lpszCurrent == lpszStart) lpszReturn = (LPWSTR)lpszStart; lpszReturn = (LPWSTR)lpszCurrent - 1; return lpszReturn; } // DrawText int WINAPI DrawTextWrapW( HDC hDC, // handle to device context LPCTSTR lpString, // pointer to string to draw int nCount, // string length, in characters LPRECT lpRect, // pointer to struct with formatting dimensions UINT uFormat ) // text-drawing flags { int iRetValue = 0; LPSTR lpStringA = NULL; VALIDATE_PROTOTYPE(DrawText); if (g_bRunningOnNT) return DrawTextW(hDC, lpString, nCount, lpRect, uFormat); lpStringA = ConvertWtoA( lpString ); iRetValue = DrawTextA(hDC, lpStringA, nCount, lpRect, uFormat); LocalFreeAndNull( &lpStringA ); return iRetValue; } // ModifyMenu BOOL WINAPI ModifyMenuWrapW( HMENU hMenu, // handle to menu UINT uPosition, // menu item to modify UINT uFlags, // menu item flags UINT_PTR uIDNewItem, // menu item identifier or handle to drop-down // menu or submenu LPCTSTR lpNewItem ) // menu item content { BOOL bRetValue; LPSTR lpNewItemA = NULL; VALIDATE_PROTOTYPE(ModifyMenu); if (g_bRunningOnNT) return ModifyMenuW(hMenu, uPosition, uFlags, uIDNewItem, lpNewItem); Assert(lpNewItem); // [PaulHi] 4/5/99 Raid 75428 MF_STRING is defined to be 0x00000000. Need // to check alternative interpretations of lpNewItem. // MF_BITMAP = 0x00000004L // MF_OWNERDRAW = 0x00000100L // If this Assert fires then it implies that a new bit defining lpNewItem may have // been added to this API!!! If so add this definition to the uFlags if statement. Assert( !(uFlags & ~(MF_BITMAP|MF_BYCOMMAND|MF_BYPOSITION|MF_CHECKED|MF_DISABLED|MF_GRAYED|MF_MENUBARBREAK|MF_MENUBREAK|MF_OWNERDRAW|MF_POPUP|MF_SEPARATOR|MF_UNCHECKED))); if (uFlags & (MF_BITMAP | MF_OWNERDRAW)) // lpNewItem is NOT a string pointer return ModifyMenuA(hMenu, uPosition, uFlags, uIDNewItem, (LPCSTR)lpNewItem); lpNewItemA = ConvertWtoA( lpNewItem ); bRetValue = ModifyMenuA(hMenu, uPosition, uFlags, uIDNewItem, lpNewItemA); LocalFreeAndNull( &lpNewItemA ); return bRetValue; } // InsertMenu BOOL WINAPI InsertMenuWrapW( HMENU hMenu, // handle to menu UINT uPosition, // menu item that new menu item precedes UINT uFlags, // menu item flags UINT_PTR uIDNewItem, // menu item identifier or handle to drop-down // menu or submenu LPCTSTR lpNewItem ) // menu item content { BOOL bRetValue; LPSTR lpNewItemA = NULL; VALIDATE_PROTOTYPE(InsertMenu); if (g_bRunningOnNT) return InsertMenuW(hMenu, uPosition, uFlags, uIDNewItem, lpNewItem); if (uFlags & MF_BITMAP || uFlags & MF_OWNERDRAW) // if anything but MF_STRING .. note: MF_STRING = 0x00000000 return InsertMenuA(hMenu, uPosition, uFlags, uIDNewItem, (LPCSTR)lpNewItem); lpNewItemA = ConvertWtoA( lpNewItem ); bRetValue = InsertMenuA(hMenu, uPosition, uFlags, uIDNewItem, lpNewItemA); LocalFreeAndNull( &lpNewItemA ); return bRetValue; } // LoadImage HANDLE WINAPI LoadImageWrapW( HINSTANCE hinst, // handle of the instance containing the image LPCTSTR lpszName, // name or identifier of image UINT uType, // type of image int cxDesired, // desired width int cyDesired, // desired height UINT fuLoad ) // load flags { HANDLE hRetValue; LPSTR lpszNameA = NULL; VALIDATE_PROTOTYPE(LoadImage); if (g_bRunningOnNT) return LoadImageW(hinst, lpszName, uType, cxDesired, cyDesired, fuLoad); lpszNameA = ConvertWtoA( lpszName ); hRetValue = LoadImageA(hinst, lpszNameA, uType, cxDesired, cyDesired, fuLoad); LocalFreeAndNull( & lpszNameA ); return hRetValue; } // GetClassInfoEx BOOL WINAPI GetClassInfoExWrapW( HINSTANCE hinst, // handle of application instance LPCTSTR lpszClass, // address of class name string LPWNDCLASSEX lpwcx ) // address of structure for class data { BOOL bRetValue; LPSTR lpszClassA = NULL; WNDCLASSEXA wcxA; WNDCLASSEXW wcxW; VALIDATE_PROTOTYPE(GetClassInfoEx); if (g_bRunningOnNT) return GetClassInfoExW(hinst, lpszClass, lpwcx); lpszClassA = ConvertWtoA( lpszClass ); wcxA.cbSize = sizeof( WNDCLASSEXA ); bRetValue = GetClassInfoExA( hinst, lpszClassA, &wcxA ); if ( bRetValue == FALSE ) { LocalFreeAndNull( &lpszClassA ); return bRetValue; } CopyMemory( &wcxW, &wcxA, sizeof(WNDCLASSEXA) ); wcxW.cbSize = sizeof(WNDCLASSEXW); if ( wcxA.lpszMenuName && !IS_INTRESOURCE(wcxA.lpszMenuName) ) wcxW.lpszMenuName = ConvertAtoW( wcxA.lpszMenuName ); if ( wcxA.lpszClassName && !IS_INTRESOURCE(wcxA.lpszClassName) ) // lpszClassName can be an atom, high word is null wcxW.lpszClassName = ConvertAtoW( wcxA.lpszClassName ); CopyMemory(lpwcx, &wcxW, sizeof(WNDCLASSEXW) ); LocalFreeAndNull( &lpszClassA ); return bRetValue; } // LoadString int WINAPI LoadStringWrapW( HINSTANCE hInstance, // handle to module containing string resource UINT uID, // resource identifier LPTSTR lpBuffer, // pointer to buffer for resource int nBufferMax ) // size of buffer { int iRetValue = 0; LPSTR lpBufferA = NULL; int nBuffer = 0; LPWSTR lpBufferW= NULL; VALIDATE_PROTOTYPE(LoadString); if (g_bRunningOnNT) return LoadStringW(hInstance, uID, lpBuffer, nBufferMax); nBuffer = nBufferMax * sizeof(WCHAR); lpBufferA = LocalAlloc(LMEM_ZEROINIT, nBuffer ); iRetValue = LoadStringA(hInstance, uID, lpBufferA, nBuffer); lpBufferW = ConvertAtoW( lpBufferA ); nBuffer = My_wcslen( lpBufferW ); if ( nBuffer >= nBufferMax ) nBuffer = nBufferMax - 1; CopyMemory(lpBuffer, lpBufferW, nBuffer * sizeof( WCHAR) ); lpBuffer[nBuffer] = 0x0000; LocalFreeAndNull( &lpBufferA ); LocalFreeAndNull( &lpBufferW ); return nBuffer; } // CharNext LPTSTR WINAPI CharNextWrapW( LPCTSTR lpsz ) // pointer to current character { LPWSTR lpwsz = NULL; VALIDATE_PROTOTYPE(CharNext); if (g_bRunningOnNT) return CharNextW(lpsz); if ( *lpsz == 0x0000 ) lpwsz = (LPWSTR)lpsz; else lpwsz = (LPWSTR)lpsz + 1; return lpwsz; } LRESULT WINAPI ListView_GetItemTextA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; LVITEMA lviA; LPLVITEMW lplviW; LPSTR lpszText; LPWSTR lpszTextW; DWORD iMinLen; lplviW = (LPLVITEMW) lParam; CopyMemory( &lviA, lplviW, sizeof( LVITEMA ) ); iMinLen = lplviW->cchTextMax * sizeof( WCHAR ); lpszText = LocalAlloc( LMEM_ZEROINIT, iMinLen ); lviA.cchTextMax = iMinLen ; lviA.pszText = lpszText; lRetValue = SendMessageA(hWnd, LVM_GETITEMTEXTA, wParam, (LPARAM)(LVITEMA FAR *)&lviA ); lpszTextW = ConvertAtoW( lviA.pszText ); if ( iMinLen > (lstrlenW( lpszTextW ) + 1) * sizeof( WCHAR) ) iMinLen = (lstrlenW( lpszTextW ) + 1) * sizeof( WCHAR) ; CopyMemory( lplviW->pszText, lpszTextW, iMinLen ); LocalFreeAndNull( &lpszText ); LocalFreeAndNull( &lpszTextW ); return lRetValue; } LRESULT WINAPI ListView_GetItemA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; LVITEMA lviA; LPLVITEMW lplviW = NULL; LPSTR lpszText = NULL; LPWSTR lpszTextW = NULL; DWORD iMinLen; lplviW = (LPLVITEMW) lParam; CopyMemory( &lviA, lplviW, sizeof( LVITEMA ) ); iMinLen = 0; if ( lplviW->mask & LVIF_TEXT ) { iMinLen = lplviW->cchTextMax * sizeof( WCHAR ); lpszText = LocalAlloc( LMEM_ZEROINIT, iMinLen ); lviA.cchTextMax = iMinLen ; lviA.pszText = lpszText; } lRetValue = SendMessageA(hWnd, LVM_GETITEMA, wParam, (LPARAM)(LVITEMA FAR *)&lviA ); lplviW->mask = lviA.mask; lplviW->iItem = lviA.iItem; lplviW->iSubItem = lviA.iSubItem; lplviW->state = lviA.state; lplviW->stateMask = lviA.stateMask; lplviW->iImage = lviA.iImage; lplviW->lParam = lviA.lParam; #if (_WIN32_IE >= 0x0300) lplviW->iIndent = lviA.iIndent; #endif if ( lplviW->mask & LVIF_TEXT ) { lpszTextW = ConvertAtoW( lviA.pszText ); if ( iMinLen > (lstrlenW( lpszTextW ) + 1) * sizeof( WCHAR) ) iMinLen = (lstrlenW( lpszTextW ) + 1) * sizeof( WCHAR) ; CopyMemory( lplviW->pszText, lpszTextW, iMinLen ); } LocalFreeAndNull( &lpszText ); LocalFreeAndNull( &lpszTextW ); return lRetValue; } LRESULT WINAPI ListView_InsertItemA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; LVITEMA lviA; LPLVITEMW lplviW; LPSTR lpszText = NULL; lplviW = (LPLVITEMW) lParam; CopyMemory( &lviA, lplviW, sizeof( LVITEMA ) ); if ( (lplviW->mask & LVIF_TEXT) && (lplviW->pszText != NULL) ) { lpszText = ConvertWtoA( lplviW->pszText ); lviA.cchTextMax = lstrlenA( lpszText ) + 1 ; } lviA.pszText = lpszText; lRetValue = SendMessageA(hWnd, LVM_INSERTITEMA, wParam, (LPARAM)(LVITEMA FAR *)&lviA ); LocalFreeAndNull( &lpszText ); return lRetValue; } LRESULT WINAPI ListView_SetItemA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; LVITEMA lviA; LPLVITEMW lplviW; LPSTR lpszText = NULL; lplviW = (LPLVITEMW) lParam; CopyMemory( &lviA, lplviW, sizeof( LVITEMA ) ); if ( (lplviW->mask & LVIF_TEXT ) && (lplviW->pszText != NULL) ) { lpszText = ConvertWtoA( lplviW->pszText ); lviA.cchTextMax = lstrlenA( lpszText ) + 1 ; lviA.pszText = lpszText; } lRetValue = SendMessageA(hWnd, LVM_SETITEMA, wParam, (LPARAM)(LVITEMA FAR *)&lviA ); LocalFreeAndNull( &lpszText ); return lRetValue; } LRESULT WINAPI ListView_SetItemTextA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; LVITEMA lviA; LPLVITEMW lplviW; LPSTR lpszText; lplviW = (LPLVITEMW) lParam; CopyMemory( &lviA, lplviW, sizeof( LVITEMA ) ); lpszText = ConvertWtoA( lplviW->pszText ); lviA.cchTextMax = lstrlenA( lpszText ) + 1 ; lviA.pszText = lpszText; lRetValue = SendMessageA(hWnd, LVM_SETITEMTEXTA, wParam, (LPARAM)(LVITEMA FAR *)&lviA ); LocalFreeAndNull( &lpszText ); return lRetValue; } LRESULT WINAPI ListView_SetColumnA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; LVCOLUMNA lvcA; LPLVCOLUMNW lplvcW; LPSTR lpszText = NULL; lplvcW = (LPLVCOLUMNW) lParam; CopyMemory( &lvcA, lplvcW, sizeof( LVCOLUMNA ) ); if ( (lplvcW->mask & LVCF_TEXT ) && (lplvcW->pszText != NULL) ) { lpszText = ConvertWtoA( lplvcW->pszText ); lvcA.cchTextMax = lstrlenA( lpszText ) + 1 ; } lvcA.pszText = lpszText; lRetValue = SendMessageA(hWnd, LVM_SETCOLUMNA, wParam, (LPARAM)(LPLVCOLUMNA)&lvcA ); LocalFreeAndNull( &lpszText ); return lRetValue; } LRESULT WINAPI ListView_InsertColumnA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; LVCOLUMNA lvcA; LPLVCOLUMNW lplvcW; LPSTR lpszText = NULL; lplvcW = (LPLVCOLUMNW) lParam; CopyMemory( &lvcA, lplvcW, sizeof( LVCOLUMNA ) ); if ( (lplvcW->mask & LVCF_TEXT ) && (lplvcW->pszText != NULL) ) { lpszText = ConvertWtoA( lplvcW->pszText ); lvcA.cchTextMax = lstrlenA( lpszText ) + 1 ; } lvcA.pszText = lpszText; lRetValue = SendMessageA(hWnd, LVM_INSERTCOLUMNA, wParam, (LPARAM)(LPLVCOLUMNA)&lvcA ); LocalFreeAndNull( &lpszText ); return lRetValue; } LRESULT WINAPI ListView_FindItemA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; LPSTR lpsz = NULL; LVFINDINFOA lvfiA; LPFINDINFOW lplvfiW; lplvfiW = (LPFINDINFOW) lParam; CopyMemory( &lvfiA, lplvfiW, sizeof(LVFINDINFOA ) ); if ( (lplvfiW->flags & LVFI_PARTIAL) || (lplvfiW->flags & LVFI_STRING) ) { if ( lplvfiW->psz != NULL ) { lpsz = ConvertWtoA( lplvfiW->psz ); } } lvfiA.psz = lpsz; if ( lplvfiW->flags & LVFI_PARAM ) { // we must convert field lParam, but this is not the case in our current code // so ignore it. if ( lplvfiW->lParam ) lvfiA.lParam = lplvfiW->lParam; } lRetValue = SendMessageA(hWnd, LVM_FINDITEMA, wParam, (LPARAM)(LVFINDINFOA FAR *)&lvfiA ); LocalFreeAndNull( &lpsz ); return lRetValue; } LRESULT WINAPI ListView_SortItemsA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { // not implement yet. return SendMessageA( hWnd, Msg, wParam, lParam ); } LRESULT WINAPI ListView_EditLabelA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { return SendMessageA(hWnd, LVM_EDITLABELA, wParam, lParam ); } LRESULT WINAPI ToolBar_AddString(HWND hWnd, LPARAM lParam) { LRESULT lRetValue; LPSTR pStringA = NULL; LPWSTR pStringW = NULL; LPSTR pStringA_T = NULL, pStringAA = NULL; DWORD dwLen; WPARAM wParam = 0; // get the total length of pStringW if (g_bRunningOnNT) return SendMessageW(hWnd, TB_ADDSTRINGW, wParam, lParam ); dwLen = 0; pStringW = (LPWSTR)(lParam); while ( *pStringW != TEXT('\0') ) { dwLen += lstrlenW(pStringW) + 1; pStringW += lstrlenW(pStringW) + 1; } dwLen += 1; // for the last null terminator pStringW = (LPWSTR)( lParam ); pStringA = LocalAlloc( LMEM_ZEROINIT, dwLen * sizeof(WCHAR) ); pStringA_T = pStringA; while ( *pStringW != TEXT('\0') ) { pStringAA = ConvertWtoA(pStringW ); pStringW += lstrlenW(pStringW) + 1; strcpy(pStringA_T, pStringAA ); LocalFreeAndNull( &pStringAA ); pStringA_T += lstrlenA( pStringA_T ) + 1; } pStringA_T[lstrlenA(pStringA_T)+1] = '\0'; lRetValue = SendMessageA(hWnd, TB_ADDSTRINGA, wParam, (LPARAM)pStringA ); LocalFreeAndNull( &pStringA ); return lRetValue; } LRESULT WINAPI ToolBar_AddButtons(HWND hWnd, WPARAM wParam, LPARAM lParam) { if (g_bRunningOnNT) return SendMessageW( hWnd, TB_ADDBUTTONSW, wParam, lParam ); return SendMessageA( hWnd, TB_ADDBUTTONSA, wParam, lParam ); } LRESULT WINAPI TreeView_GetItemA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; TVITEMA tviA; LPTVITEMW lptviW; LPWSTR lpszTextW = NULL; LPSTR lpszTextA = NULL; lptviW = (LPTVITEMW) lParam; CopyMemory( &tviA, lptviW, sizeof( TVITEMA ) ); if ( lptviW->mask & TVIF_TEXT ) { lpszTextA = ConvertWtoA( lptviW->pszText ) ; tviA.pszText = lpszTextA; tviA.cchTextMax = lstrlenA( lpszTextA ) + 1; } lRetValue = SendMessageA( hWnd, TVM_GETITEMA, wParam, (LPARAM)(LPTVITEMA)&tviA ); if ( lptviW->mask & TVIF_TEXT ) lpszTextW = ConvertAtoW( tviA.pszText ); lptviW->mask = tviA.mask; lptviW->hItem = tviA.hItem; lptviW->state = tviA.state; lptviW->stateMask = tviA.stateMask; if ( lpszTextW ) { CopyMemory(lptviW->pszText, lpszTextW, (lstrlenW(lpszTextW)+1) * sizeof(WCHAR) ); lptviW->cchTextMax = lstrlenW( lpszTextW ) + 1; } lptviW->iImage = tviA.iImage; lptviW->iSelectedImage = tviA.iSelectedImage; lptviW->cChildren = tviA.cChildren; lptviW->lParam = tviA.lParam; LocalFreeAndNull( &lpszTextA ); LocalFreeAndNull( &lpszTextW ); return lRetValue; } LRESULT WINAPI TreeView_SetItemA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; TVITEMA tviA; LPTVITEMW lptviW; LPSTR pszTextA = NULL; lptviW = (LPTVITEMW) lParam; CopyMemory( &tviA, lptviW, sizeof( TVITEMA ) ); if ( (lptviW->mask & TVIF_TEXT) && (lptviW->pszText != NULL) ) { pszTextA = ConvertWtoA( lptviW->pszText ); tviA.cchTextMax = lstrlenA( pszTextA ); } tviA.pszText = pszTextA; lRetValue = SendMessageA( hWnd, TVM_SETITEMA, wParam, (LPARAM)(const TV_ITEM FAR*)&tviA ); LocalFreeAndNull( &pszTextA ); return lRetValue; } LRESULT WINAPI TreeView_InsertItemA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; LPSTR pszTextA = NULL; TVINSERTSTRUCTA tvisA; LPTVINSERTSTRUCTW lptvisW; lptvisW = (LPTVINSERTSTRUCTW)lParam; CopyMemory( &tvisA, lptvisW, sizeof( TVINSERTSTRUCTA ) ); if ( ((lptvisW->item).mask & TVIF_TEXT) && ((lptvisW->item).pszText != NULL) ) { pszTextA = ConvertWtoA( (lptvisW->item).pszText ); tvisA.item.cchTextMax = lstrlenA( pszTextA ); tvisA.item.pszText = pszTextA; } lRetValue = SendMessageA( hWnd, TVM_INSERTITEMA, wParam, (LPARAM)(LPTVINSERTSTRUCTA)&tvisA ); LocalFreeAndNull( &pszTextA ); return lRetValue; } // Tab Control Message Wrapper LRESULT WINAPI TabCtrl_InsertItemA( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam ) { LRESULT lRetValue; TCITEMA tciA; LPTCITEMW lptciW = NULL; LPSTR pszText = NULL; lptciW = (LPTCITEMW) lParam; CopyMemory( &tciA, lptciW, sizeof(TCITEMA ) ); if ( lptciW->mask & TCIF_TEXT ) { pszText = ConvertWtoA( lptciW->pszText ); tciA.pszText = pszText; tciA.cchTextMax = lstrlenA( pszText ) + 1; } lRetValue = SendMessageA( hWnd, TCM_INSERTITEMA, wParam, (LPARAM)(LPTCITEMA)&tciA); LocalFreeAndNull( &pszText ); return lRetValue; } // List Box Control Message wrapper LRESULT WINAPI ListBox_AddStringA(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; LPSTR lpszStrA = NULL; LPWSTR lpszStrW = NULL; lpszStrW = (LPWSTR)lParam; lpszStrA = ConvertWtoA(lpszStrW); lRetValue = SendMessageA(hWnd, LB_ADDSTRING, wParam, (LPARAM)lpszStrA); LocalFreeAndNull(&lpszStrA); return lRetValue; } // Combo List Control Message wrapper LRESULT WINAPI Combo_AddStringA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; LPSTR lpszStrA = NULL; LPWSTR lpszStrW = NULL; lpszStrW = (LPWSTR)lParam; lpszStrA = ConvertWtoA( lpszStrW ); lRetValue = SendMessageA(hWnd, CB_ADDSTRING, wParam, (LPARAM)lpszStrA ); LocalFreeAndNull( &lpszStrA ); return lRetValue; } LRESULT WINAPI Combo_GetLBTextA(HWND hWnd,UINT Msg, WPARAM wParam, LPARAM lParam) { LRESULT lRetValue; LPSTR lpszStrA = NULL; LPWSTR lpszStrW = NULL; int nBytes; Assert(lParam); *((LPWSTR)lParam) = '\0'; // Allocate the single byte char buffer to the correct size nBytes = (int) SendMessageA(hWnd, CB_GETLBTEXTLEN, wParam, 0) + 1; lpszStrA = LocalAlloc(LMEM_FIXED, nBytes); if (!lpszStrA) { Assert(0); return 0; } *lpszStrA = '\0'; lRetValue = SendMessageA(hWnd, CB_GETLBTEXT, wParam, (LPARAM)(lpszStrA)); if ( lRetValue == CB_ERR ) return CB_ERR; // lRetValue is the length of string lpszStrA, in Bytes. // to make sure lpszStrA is Null-terminated. lpszStrA[lRetValue] = '\0'; lpszStrW = ConvertAtoW( lpszStrA ); lRetValue = lstrlenW( lpszStrW ) * sizeof(WCHAR); CopyMemory( (LPWSTR)lParam, lpszStrW, lRetValue + sizeof(WCHAR) ); LocalFreeAndNull(&lpszStrW); LocalFreeAndNull(&lpszStrA); return (LRESULT)lRetValue; } LRESULT WINAPI Combo_InsertStringA(HWND hWnd,UINT Msg, WPARAM wParam,LPARAM lParam) { LRESULT lRetValue; LPSTR lpszStrA = NULL; LPWSTR lpszStrW = NULL; lpszStrW = (LPWSTR)lParam; lpszStrA = ConvertWtoA( lpszStrW ); lRetValue = SendMessageA(hWnd, CB_INSERTSTRING, wParam, (LPARAM)lpszStrA ); LocalFreeAndNull( &lpszStrA ); return lRetValue; } LRESULT WINAPI Combo_FindStringA(HWND hWnd,UINT Msg, WPARAM wParam,LPARAM lParam) { LRESULT lRetValue; LPSTR lpszStrA = NULL; LPWSTR lpszStrW = NULL; lpszStrW = (LPWSTR)lParam; lpszStrA = ConvertWtoA( lpszStrW ); lRetValue = SendMessageA(hWnd, CB_FINDSTRING, wParam, (LPARAM)lpszStrA ); LocalFreeAndNull( &lpszStrA ); return lRetValue; } // Animation Control wrappers LRESULT WINAPI Animate_OpenA( HWND hWnd,UINT Msg, WPARAM wParam,LPARAM lParam) { LRESULT lRetValue; // lParam pointers to a string or resource String ID, // in our codes, only Resources IDs are passed to this function // so we don't want to convert value for this parameter lRetValue = SendMessageA( hWnd, ACM_OPENA, wParam, lParam ); return lRetValue; } // Tooltip Wrappers LRESULT WINAPI ToolTip_AddTool(HWND hWnd,LPARAM lParam) { LRESULT lRetValue; LPSTR lpszStrA = NULL; LPWSTR lpszStrW = NULL; TOOLINFOA TIA = {0}; LPTOOLINFOW lpTIW = (LPTOOLINFOW)lParam; WPARAM wParam = 0; if (g_bRunningOnNT) return SendMessageW(hWnd, TTM_ADDTOOLW, wParam, lParam); if(!lpTIW) return 0; CopyMemory(&TIA, lpTIW, sizeof(TOOLINFOA)); TIA.lpszText = ConvertWtoA(lpTIW->lpszText); lRetValue = SendMessageA(hWnd, TTM_ADDTOOLA, wParam, (LPARAM)&TIA ); LocalFreeAndNull( &TIA.lpszText ); return lRetValue; } // // Guess what TTM_UPDATETIPTEXT is the same as EM_FORMATRANGE .. therefore can't use it // through the SendMessage wrapper .. need our own function for this LRESULT WINAPI ToolTip_UpdateTipText(HWND hWnd,LPARAM lParam) { LRESULT lRetValue; LPSTR lpszStrA = NULL; LPWSTR lpszStrW = NULL; TOOLINFOA TIA = {0}; LPTOOLINFOW lpTIW = (LPTOOLINFOW)lParam; WPARAM wParam = 0; if (g_bRunningOnNT) return SendMessageW(hWnd, TTM_UPDATETIPTEXTW, wParam, lParam); if(!lpTIW) return 0; CopyMemory(&TIA, lpTIW, sizeof(TOOLINFOA)); TIA.lpszText = ConvertWtoA(lpTIW->lpszText); lRetValue = SendMessageA(hWnd, TTM_UPDATETIPTEXTA, wParam, (LPARAM)&TIA ); LocalFreeAndNull( &TIA.lpszText ); return lRetValue; } // SendMessage WM_SETTEXT LRESULT WINAPI WM_SetTextA( HWND hWnd, UINT Msg, // message to send WPARAM wParam, // first message parameter LPARAM lParam ) // second message parameter { LRESULT lRetValue = 0; LPSTR lpA = ConvertWtoA((LPCWSTR)lParam); lRetValue = SendMessageA(hWnd, WM_SETTEXT, wParam, (LPARAM)lpA); LocalFreeAndNull(&lpA); return lRetValue; } // SendMessage // // There is a big potential problem with this function .. since we // are passing ALL the messages through this function, if there are any over-lapping // message ids (e.g. TTM_UPDATETIPTEXT for tooltips is the same as EM_FORMATRANGE // for the RichEdit control) with the result that we may route the wrong message to the // wrong handler.. need to be careful about handling any messages in the WM_USER range .. // This is specially true for a bunch of CommCtrls. // LRESULT WINAPI SendMessageWrapW( HWND hWnd, // handle of destination window UINT Msg, // message to send WPARAM wParam, // first message parameter LPARAM lParam ) // second message parameter { VALIDATE_PROTOTYPE(SendMessage); if (g_bRunningOnNT) return SendMessageW(hWnd, Msg, wParam, lParam); switch (Msg) { case WM_SETTEXT: return WM_SetTextA(hWnd, Msg, wParam, lParam); // for ListView Message case LVM_GETITEMTEXT : return ListView_GetItemTextA(hWnd, Msg, wParam, lParam); case LVM_GETITEM : return ListView_GetItemA(hWnd, Msg, wParam, lParam); case LVM_INSERTCOLUMN : return ListView_InsertColumnA( hWnd, Msg, wParam, lParam); case LVM_INSERTITEM : return ListView_InsertItemA(hWnd, Msg, wParam, lParam); case LVM_SETITEM : return ListView_SetItemA(hWnd, Msg, wParam, lParam); case LVM_SETITEMTEXT : return ListView_SetItemTextA(hWnd, Msg, wParam, lParam); case LVM_SETCOLUMN : return ListView_SetColumnA(hWnd, Msg, wParam, lParam); case LVM_FINDITEM : return ListView_FindItemA(hWnd, Msg, wParam, lParam); case LVM_SORTITEMS : return ListView_SortItemsA(hWnd, Msg, wParam, lParam); case LVM_EDITLABEL : return ListView_EditLabelA(hWnd, Msg, wParam, lParam); // For TreeView Message case TVM_GETITEM : return TreeView_GetItemA(hWnd, Msg, wParam, lParam); case TVM_SETITEM : return TreeView_SetItemA(hWnd, Msg, wParam, lParam); case TVM_INSERTITEM : return TreeView_InsertItemA(hWnd, Msg, wParam, lParam); // For TabCtrl Message case TCM_INSERTITEM : return TabCtrl_InsertItemA( hWnd, Msg, wParam, lParam); // For ComBo List Control case CB_ADDSTRING : return Combo_AddStringA(hWnd, Msg, wParam, lParam); case CB_GETLBTEXT : return Combo_GetLBTextA(hWnd, Msg, wParam, lParam); case CB_INSERTSTRING : return Combo_InsertStringA(hWnd, Msg, wParam, lParam); case CB_FINDSTRING : return Combo_FindStringA(hWnd, Msg, wParam, lParam); // For ListBox Control case LB_ADDSTRING: return ListBox_AddStringA(hWnd, Msg, wParam, lParam); // For Animation Control case ACM_OPEN : return Animate_OpenA( hWnd, Msg, wParam, lParam); // For Others default : return SendMessageA(hWnd, Msg, wParam, lParam); } } // DefWindowProc LRESULT WINAPI DefWindowProcWrapW( HWND hWnd, // handle to window UINT Msg, // message identifier WPARAM wParam, // first message parameter LPARAM lParam ) // second message parameter { VALIDATE_PROTOTYPE(DefWindowProc); if (g_bRunningOnNT) return DefWindowProcW(hWnd, Msg, wParam, lParam); return DefWindowProcA(hWnd, Msg, wParam, lParam); } // wsprintf int WINAPI wsprintfWrapW( LPTSTR lpOut, // pointer to buffer for output LPCTSTR lpFmt, // pointer to format-control string ... ) // optional arguments { va_list ArgList; va_start(ArgList, lpFmt); return wvsprintfWrapW(lpOut, lpFmt, ArgList); /* LPSTR lpFmtA = NULL, lpTemp = NULL; char szOut[1024]; //wsprintf has a 1k limit int nRet = 0; LPWSTR lpOutW = NULL; VALIDATE_PROTOTYPE(wsprintf); if (g_bRunningOnNT) return wsprintfW(lpOut, lpFmt, ... ); // The argument list can have variable number of LPWSTR parameters which would // be too hard to check individually .. instead we can do one of 2 things: // - we can change every %s to %S in the format string .. %S will tell the wsprintfA // that the argument is a wide string // - if this doesn't work then we can try making sure the input format string uses %ws always // lpFmtA = ConvertWtoA((LPWSTR)lpFmt); lpTemp = lpFmtA; while(lpTemp && *lpTemp) { if(*lpTemp == '%' && *(lpTemp+1) == 's') *(lpTemp+1) = 'S'; lpTemp++; } nRet = wsprintfA(szOut,lpFmtA, ...); lpOutW = ConvertAtoW(szOut); My_wcscpy(lpOut, lpOutW); LocalFreeAndNull(&lpOutW); LocalFreeAndNull(&lpFmtA); return nRet; */ } // wvsprintf int WINAPI wvsprintfWrapW( LPTSTR lpOut, // pointer to buffer for output LPCTSTR lpFmt, // pointer to format-control string va_list arglist ) // variable list of format-control arguments { LPSTR lpFmtA = NULL, lpTemp = NULL; char szOut[1024]; int nRet = 0; LPWSTR lpOutW = NULL; VALIDATE_PROTOTYPE(wvsprintf); if (g_bRunningOnNT) return wvsprintfW(lpOut, lpFmt, arglist); // The argument list can have variable number of LPWSTR parameters which would // be too hard to check individually .. instead we can do one of 2 things: // - we can change every %s to %S in the format string .. %S will tell the wsprintfA // that the argument is a wide string // - if this doesn't work then we can try making sure the input format string uses %ws always // lpFmtA = ConvertWtoA((LPWSTR)lpFmt); lpTemp = lpFmtA; while(lpTemp && *lpTemp) { if(*lpTemp == '%' && *(lpTemp+1) == 's') *(lpTemp+1) = 'S'; lpTemp++; } nRet = wvsprintfA(szOut,lpFmtA, arglist); lpOutW = ConvertAtoW(szOut); My_wcscpy(lpOut, lpOutW); LocalFreeAndNull(&lpOutW); LocalFreeAndNull(&lpFmtA); return nRet; } // DialogBoxParam INT_PTR WINAPI DialogBoxParamWrapW( HINSTANCE hInstance, // handle to application instance LPCTSTR lpTemplateName, // identifies dialog box template HWND hWndParent, // handle to owner window DLGPROC lpDialogFunc, // pointer to dialog box procedure LPARAM dwInitParam ) // initialization value { INT_PTR iRetValue = 0; // LPSTR lpTemplateNameA = NULL; VALIDATE_PROTOTYPE(DialogBoxParam); if (g_bRunningOnNT) return DialogBoxParamW(hInstance, lpTemplateName, hWndParent, lpDialogFunc, dwInitParam); // all templateName passed in our current codes are just IDD. // so don't do A/W conversion. // lpTemplateNameA = ConvertWtoA( lpTemplateName ); iRetValue = DialogBoxParamA(hInstance, (LPCSTR)lpTemplateName, hWndParent, lpDialogFunc, dwInitParam); // LocalFreeAndNull( &lpTemplateNameA ); if(iRetValue == -1) DebugTrace(TEXT("Error creating dialog: %d\n"), GetLastError()); return iRetValue; } // SendDlgItemMessage LRESULT WINAPI SendDlgItemMessageWrapW( HWND hDlg, // handle of dialog box int nIDDlgItem, // identifier of control UINT Msg, // message to send WPARAM wParam, // first message parameter LPARAM lParam ) // second message parameter { VALIDATE_PROTOTYPE(SendDlgItemMessage); if (g_bRunningOnNT) return SendDlgItemMessageW(hDlg, nIDDlgItem, Msg, wParam, lParam); // [PaulHi] 1/19/99 Raid 66195 // Must special case Win9X wrapper failures, just like with SendMessage // command { LPWSTR lpszStrW = NULL; LPSTR lpszStrA = NULL; LRESULT lRetValue = 0; switch (Msg) { case LB_GETTEXT: case CB_GETLBTEXT: case WM_GETTEXT: // Wrapper function returns single byte string instead of double byte. // Note that caller should be expecting double byte and should set lParam // size accordingly. lRetValue = SendDlgItemMessageA(hDlg, nIDDlgItem, Msg, wParam, lParam); lpszStrW = ConvertAtoW((LPSTR)lParam); lstrcpyWrapW((LPTSTR)lParam, lpszStrW); LocalFreeAndNull(&lpszStrW); break; case CB_ADDSTRING: Assert(lParam); lpszStrA = ConvertWtoA((LPCWSTR)lParam); lRetValue = SendDlgItemMessageA(hDlg, nIDDlgItem, Msg, wParam, (LPARAM)lpszStrA); LocalFreeAndNull(&lpszStrA); break; default: lRetValue = SendDlgItemMessageA(hDlg, nIDDlgItem, Msg, wParam, lParam); } return lRetValue; } } // SetWindowLong LONG WINAPI SetWindowLongWrapW( HWND hWnd, // handle of window int nIndex, // offset of value to set LONG dwNewLong ) // new value { VALIDATE_PROTOTYPE(SetWindowLong); if (g_bRunningOnNT) return SetWindowLongW(hWnd, nIndex, dwNewLong); return SetWindowLongA(hWnd, nIndex, dwNewLong); } // GetWindowLong LONG WINAPI GetWindowLongWrapW( HWND hWnd, // handle of window int nIndex ) // offset of value to retrieve { VALIDATE_PROTOTYPE(GetWindowLong); if (g_bRunningOnNT) return GetWindowLongW(hWnd, nIndex); return GetWindowLongA(hWnd, nIndex); } // SetWindowLong LONG_PTR WINAPI SetWindowLongPtrWrapW( HWND hWnd, // handle of window int nIndex, // offset of value to set LONG_PTR dwNewLong ) // new value { VALIDATE_PROTOTYPE(SetWindowLongPtr); if (g_bRunningOnNT) return SetWindowLongPtrW(hWnd, nIndex, dwNewLong); return SetWindowLongPtrA(hWnd, nIndex, dwNewLong); } // GetWindowLong LONG_PTR WINAPI GetWindowLongPtrWrapW( HWND hWnd, // handle of window int nIndex ) // offset of value to retrieve { VALIDATE_PROTOTYPE(GetWindowLongPtr); if (g_bRunningOnNT) return GetWindowLongPtrW(hWnd, nIndex); return GetWindowLongPtrA(hWnd, nIndex); } // CreateWindowEx HWND WINAPI CreateWindowExWrapW( DWORD dwExStyle, // extended window style LPCTSTR lpClassName, // pointer to registered class name LPCTSTR lpWindowName, // pointer to window name DWORD dwStyle, // window style int x, // horizontal position of window int y, // vertical position of window int nWidth, // window width int nHeight, // window height HWND hWndParent, // handle to parent or owner window HMENU hMenu, // handle to menu, or child-window identifier HINSTANCE hInstance, // handle to application instance LPVOID lpParam ) // pointer to window-creation data { HWND hRetValue = NULL; LPSTR lpClassNameA = NULL; LPSTR lpWindowNameA = NULL; VALIDATE_PROTOTYPE(CreateWindowEx); if (g_bRunningOnNT) return CreateWindowExW(dwExStyle, lpClassName, lpWindowName, dwStyle, x, y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam); lpClassNameA = ConvertWtoA( lpClassName ); lpWindowNameA = ConvertWtoA( lpWindowName ); hRetValue = CreateWindowExA(dwExStyle, lpClassNameA, lpWindowNameA, dwStyle, x, y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam); LocalFreeAndNull( &lpClassNameA ); LocalFreeAndNull( &lpWindowNameA ); return hRetValue; } // UnregisterClass BOOL WINAPI UnregisterClassWrapW( LPCTSTR lpClassName, // address of class name string HINSTANCE hInstance ) // handle of application instance { BOOL bRetValue; LPSTR lpClassNameA = NULL; VALIDATE_PROTOTYPE(UnregisterClass); if (g_bRunningOnNT) return UnregisterClassW(lpClassName, hInstance); lpClassNameA = ConvertWtoA( lpClassName ); bRetValue = UnregisterClassA(lpClassNameA, hInstance); LocalFreeAndNull( &lpClassNameA ); return bRetValue; } // RegisterClass ATOM WINAPI RegisterClassWrapW(CONST WNDCLASS *lpWndClass ) // address of structure with class date { ATOM aRetValue; WNDCLASSA CLassA; LPSTR lpszMenuName = NULL; LPSTR lpszClassName = NULL; VALIDATE_PROTOTYPE(RegisterClass); if (g_bRunningOnNT) return RegisterClassW(lpWndClass); CLassA.style = lpWndClass->style; CLassA.lpfnWndProc = lpWndClass->lpfnWndProc; CLassA.cbClsExtra = lpWndClass->cbClsExtra; CLassA.cbWndExtra = lpWndClass->cbWndExtra; CLassA.hInstance = lpWndClass->hInstance; CLassA.hIcon = lpWndClass->hIcon; CLassA.hCursor = lpWndClass->hCursor; CLassA.hbrBackground = lpWndClass->hbrBackground; CLassA.lpszMenuName = NULL; CLassA.lpszClassName = NULL; if ( lpWndClass->lpszMenuName) { lpszMenuName = ConvertWtoA(lpWndClass->lpszMenuName); CLassA.lpszMenuName = lpszMenuName; } if ( lpWndClass->lpszClassName ) { lpszClassName = ConvertWtoA(lpWndClass->lpszClassName); CLassA.lpszClassName = lpszClassName; } aRetValue = RegisterClassA(&CLassA); LocalFreeAndNull( &lpszMenuName ); LocalFreeAndNull( &lpszClassName ); return aRetValue; } // LoadCursor HCURSOR WINAPI LoadCursorWrapW( HINSTANCE hInstance, // handle to application instance LPCTSTR lpCursorName ) // name string or cursor resource identifier { VALIDATE_PROTOTYPE(LoadCursor); if (g_bRunningOnNT) return LoadCursorW(hInstance, lpCursorName); return LoadCursorA(hInstance, (LPSTR)lpCursorName); } // RegisterWindowMessage UINT WINAPI RegisterWindowMessageWrapW( LPCTSTR lpString ) // address of message string { UINT uRetValue = 0; LPSTR lpStringA = NULL; VALIDATE_PROTOTYPE(RegisterWindowMessage); if (g_bRunningOnNT) return RegisterWindowMessageW(lpString); lpStringA = ConvertWtoA( lpString ); uRetValue = RegisterWindowMessageA( lpStringA ); LocalFreeAndNull( &lpStringA ); return uRetValue; } // SystemParametersInfo BOOL WINAPI SystemParametersInfoWrapW( UINT uiAction, // system parameter to query or set UINT uiParam, // depends on action to be taken PVOID pvParam, // depends on action to be taken UINT fWinIni ) // user profile update flag { BOOL bRetValue; LOGFONTA lfFontA; LOGFONTW lfFontW; VALIDATE_PROTOTYPE(SystemParametersInfo); if (g_bRunningOnNT) return SystemParametersInfoW(uiAction, uiParam, pvParam, fWinIni); if ( uiAction != SPI_GETICONTITLELOGFONT ) return SystemParametersInfoA(uiAction, uiParam, pvParam, fWinIni); // we handle SPI_GETICONTITLELOGFONT only for our special requirement. ... bRetValue = SystemParametersInfoA(uiAction, uiParam, &lfFontA, fWinIni); if ( bRetValue == FALSE ) return FALSE; // copy all the fields except lfFaceName from lfFontA to lfFontW CopyMemory(&lfFontW,&lfFontA, sizeof(LOGFONTA) ); // translate the lfFaceName[] from A to W MultiByteToWideChar(GetACP(), 0, lfFontA.lfFaceName, LF_FACESIZE, lfFontW.lfFaceName, LF_FACESIZE); CopyMemory(pvParam, &lfFontW, sizeof(LOGFONTW) ); return bRetValue; } /* // No A & W version. BOOL WINAPI ShowWindow( HWND hWnd, // handle to window int nCmdShow ) // show state of window */ // CreateDialogParam HWND WINAPI CreateDialogParamWrapW( HINSTANCE hInstance, // handle to application instance LPCTSTR lpTemplateName, // identifies dialog box template HWND hWndParent, // handle to owner window DLGPROC lpDialogFunc, // pointer to dialog box procedure LPARAM dwInitParam ) // initialization value { VALIDATE_PROTOTYPE(CreateDialogParam); if (g_bRunningOnNT) return CreateDialogParamW(hInstance, lpTemplateName, hWndParent, lpDialogFunc, dwInitParam); return CreateDialogParamA(hInstance, (LPCSTR) lpTemplateName, hWndParent, lpDialogFunc, dwInitParam); } // SetWindowText BOOL WINAPI SetWindowTextWrapW( HWND hWnd, // handle to window or control LPCTSTR lpString ) // address of string { BOOL bRetValue; LPSTR lpStringA = NULL; VALIDATE_PROTOTYPE(SetWindowText); if (g_bRunningOnNT) return SetWindowTextW(hWnd, lpString); lpStringA = ConvertWtoA( lpString ); bRetValue = SetWindowTextA( hWnd, lpStringA); LocalFreeAndNull( &lpStringA ); return bRetValue; } // PostMessage BOOL WINAPI PostMessageWrapW( HWND hWnd, // handle of destination window UINT Msg, // message to post WPARAM wParam, // first message parameter LPARAM lParam ) // second message parameter { VALIDATE_PROTOTYPE(PostMessage); if (g_bRunningOnNT) return PostMessageW(hWnd, Msg, wParam, lParam); return PostMessageA(hWnd, Msg, wParam, lParam); } // GetMenuItemInfo BOOL WINAPI GetMenuItemInfoWrapW( HMENU hMenu, UINT uItem, BOOL fByPosition, LPMENUITEMINFO lpmii ) { BOOL bRetValue; MENUITEMINFOA miiA = {0}; LPSTR lpA = NULL; LPWSTR lpW = NULL; LPWSTR lpOld = NULL; VALIDATE_PROTOTYPE(GetMenuItemInfo); if (g_bRunningOnNT) return GetMenuItemInfoW(hMenu, uItem, fByPosition, lpmii); CopyMemory(&miiA, lpmii, sizeof(MENUITEMINFOA) ); miiA.cbSize = sizeof (MENUITEMINFOA); if(miiA.fMask & MIIM_TYPE) { lpA = LocalAlloc(LMEM_ZEROINIT, lpmii->cch+1); miiA.dwTypeData = lpA; miiA.cch = lpmii->cch; } bRetValue = GetMenuItemInfoA(hMenu, uItem, fByPosition, &miiA); if(bRetValue) { lpOld = lpmii->dwTypeData; CopyMemory(lpmii, &miiA, sizeof(MENUITEMINFOA) ); lpmii->dwTypeData = lpOld; if ( miiA.fMask & MIIM_TYPE ) { lpW = ConvertAtoW(miiA.dwTypeData); lstrcpyWrapW(lpmii->dwTypeData,lpW); lpmii->cch = My_wcslen( lpmii->dwTypeData ); } } LocalFreeAndNull(&lpA); LocalFreeAndNull(&lpW); return bRetValue; } // GetClassInfo BOOL WINAPI GetClassInfoWrapW( HINSTANCE hInstance, // handle of application instance LPCTSTR lpClassName, // address of class name string LPWNDCLASS lpWndClass ) // address of structure for class data { BOOL bRetValue; LPSTR lpClassNameA = NULL; WNDCLASSA ClassA; VALIDATE_PROTOTYPE(GetClassInfo); if (g_bRunningOnNT) return GetClassInfoW(hInstance, lpClassName, lpWndClass); lpClassNameA = ConvertWtoA( lpClassName ); bRetValue = GetClassInfoA(hInstance, lpClassNameA, &ClassA ); if (bRetValue == FALSE) { LocalFreeAndNull( & lpClassNameA ); return FALSE; } CopyMemory(lpWndClass, &ClassA, sizeof(WNDCLASSA)-2*sizeof(LPSTR) ); if ( ClassA.lpszMenuName && !IS_INTRESOURCE(ClassA.lpszMenuName) ) lpWndClass->lpszMenuName = ConvertAtoW( ClassA.lpszMenuName ); else lpWndClass->lpszMenuName = NULL; if ( ClassA.lpszClassName && !IS_INTRESOURCE(ClassA.lpszClassName) ) // lpszClassName can be an atom, high word is null lpWndClass->lpszClassName = ConvertAtoW( ClassA.lpszClassName); else lpWndClass->lpszClassName = NULL; LocalFreeAndNull( & lpClassNameA ); return bRetValue; } //---------------------------------------------------------------------- // // function: CharLowerWrapW( LPWSTR pch ) // // purpose: Converts character to lowercase. Takes either a pointer // to a string, or a character masquerading as a pointer. // In the later case, the HIWORD must be zero. This is // as spec'd for Win32. // // returns: Lowercased character or string. In the string case, // the lowercasing is done inplace. // //---------------------------------------------------------------------- LPWSTR WINAPI CharLowerWrapW( LPWSTR pch ) { VALIDATE_PROTOTYPE(CharLower); if (g_bRunningOnNT) { return CharLowerW( pch ); } if (!HIWORD(pch)) { WCHAR ch = (WCHAR)(LONG_PTR)pch; CharLowerBuffWrapW( &ch, 1 ); pch = (LPWSTR)MAKEINTATOM(ch); } else { CharLowerBuffWrapW( pch, lstrlenW(pch) ); } return pch; } //---------------------------------------------------------------------- // // function: CharLowerBuffWrapW( LPWSTR pch, DWORD cch ) // // purpose: Converts a string to lowercase. String must be cch // characters in length. // // returns: Character count (cch). The lowercasing is done inplace. // //---------------------------------------------------------------------- DWORD WINAPI CharLowerBuffWrapW( LPWSTR pch, DWORD cchLength ) { DWORD cch; VALIDATE_PROTOTYPE(CharLowerBuff); if (g_bRunningOnNT) { return CharLowerBuffW( pch, cchLength ); } for ( cch = cchLength; cch-- ; pch++ ) { WCHAR ch = *pch; if (IsCharUpperWrapW(ch)) { if (ch < 0x0100) { *pch += 32; // Get Latin-1 out of the way first } else if (ch < 0x0531) { if (ch < 0x0391) { if (ch < 0x01cd) { if (ch <= 0x178) { if (ch < 0x0178) { *pch += (ch == 0x0130) ? 0 : 1; } else { *pch -= 121; } } else { static const BYTE abLookup[] = { // 0/8 1/9 2/a 3/b 4/c 5/d 6/e 7/f /* 0x0179-0x17f */ 1, 0, 1, 0, 1, 0, 0, /* 0x0180-0x187 */ 0, 210, 1, 0, 1, 0, 206, 1, /* 0x0188-0x18f */ 0, 205, 205, 1, 0, 0, 79, 202, /* 0x0190-0x197 */ 203, 1, 0, 205, 207, 0, 211, 209, /* 0x0198-0x19f */ 1, 0, 0, 0, 211, 213, 0, 214, /* 0x01a0-0x1a7 */ 1, 0, 1, 0, 1, 0, 0, 1, /* 0x01a8-0x1af */ 0, 218, 0, 0, 1, 0, 218, 1, /* 0x01b0-0x1b7 */ 0, 217, 217, 1, 0, 1, 0, 219, /* 0x01b8-0x1bf */ 1, 0, 0, 0, 1, 0, 0, 0, /* 0x01c0-0x1c7 */ 0, 0, 0, 0, 2, 0, 0, 2, /* 0x01c8-0x1cb */ 0, 0, 2, 0 }; *pch += abLookup[ch-0x0179]; } } else if (ch < 0x0386) { switch (ch) { case 0x01f1: *pch += 2; break; case 0x01f2: break; default: *pch += 1; } } else { static const BYTE abLookup[] = { 38, 0, 37, 37, 37, 0, 64, 0, 63, 63 }; *pch += abLookup[ch-0x0386]; } } else { if (ch < 0x0410) { if (ch < 0x0401) { if (ch < 0x03e2) { if (!InRange(ch, 0x03d2, 0x03d4) && !(InRange(ch, 0x3da, 0x03e0) & !(ch & 1))) { *pch += 32; } } else { *pch += 1; } } else { *pch += 80; } } else { if (ch < 0x0460) { *pch += 32; } else { *pch += 1; } } } } else { if (ch < 0x2160) { if (ch < 0x1fba) { if (ch < 0x1f08) { if (ch < 0x1e00) { *pch += 48; } else { *pch += 1; } } else if (!(InRange(ch, 0x1f88, 0x1faf) && (ch & 15)>7)) { *pch -= 8; } } else { static const BYTE abLookup[] = { // 8 9 a b c d e f 0, 0, 74, 74, 0, 0, 0, 0, 86, 86, 86, 86, 0, 0, 0, 0, 8, 8, 100, 100, 0, 0, 0, 0, 8, 8, 112, 112, 7, 0, 0, 0, 128, 128, 126, 126, 0, 0, 0, 0 }; int i = (ch-0x1fb0); *pch -= (int)abLookup[((i>>1) & ~7) | (i & 7)]; } } else { if (ch < 0xff21) { if (ch < 0x24b6) { *pch += 16; } else { *pch += 26; } } else { *pch += 32; } } } } else { // These are Unicode Number Forms. They have lowercase counter- // parts, but are not considered uppercase. Why, I don't know. if (InRange(ch, 0x2160, 0x216f)) { *pch += 16; } } } return cchLength; } //---------------------------------------------------------------------- // // function: CharUpperBuffWrapW( LPWSTR pch, DWORD cch ) // // purpose: Converts a string to uppercase. String must be cch // characters in length. Note that this function is // is messier that CharLowerBuffWrap, and the reason for // this is many Unicode characters are considered uppercase, // even when they don't have an uppercase counterpart. // // returns: Character count (cch). The uppercasing is done inplace. // //---------------------------------------------------------------------- DWORD WINAPI CharUpperBuffWrapW( LPWSTR pch, DWORD cchLength ) { DWORD cch; VALIDATE_PROTOTYPE(CharUpperBuff); if (g_bRunningOnNT) { return CharUpperBuffW( pch, cchLength ); } for ( cch = cchLength; cch-- ; pch++ ) { WCHAR ch = *pch; if (IsCharLowerWrapW(ch)) { if (ch < 0x00ff) { *pch -= ((ch != 0xdf) << 5); } else if (ch < 0x03b1) { if (ch < 0x01f5) { if (ch < 0x01ce) { if (ch < 0x017f) { if (ch < 0x0101) { *pch += 121; } else { *pch -= (ch != 0x0131 && ch != 0x0138 && ch != 0x0149); } } else if (ch < 0x01c9) { static const BYTE abMask[] = { // 6543210f edcba987 0xfc, 0xbf, // 11111100 10111111 0xbf, 0x67, // 10111111 01100111 0xff, 0xef, // 11111111 11101111 0xff, 0xf7, // 11111111 11110111 0xbf, 0xfd // 10111111 11111101 }; int i = ch - 0x017f; *pch -= ((abMask[i>>3] >> (i&7)) & 1) + (ch == 0x01c6); } else { *pch -= ((ch != 0x01cb)<<1); } } else { if (ch < 0x01df) { if (ch < 0x01dd) { *pch -= 1; } else { *pch -= 79; } } else { *pch -= 1 + (ch == 0x01f3) - InRange(ch,0x01f0,0x01f2); } } } else if (ch < 0x0253) { *pch -= (ch < 0x0250); } else if (ch < 0x03ac) { static const BYTE abLookup[] = {// 0/8 1/9 2/a 3/b 4/c 5/d 6/e 7/f /* 0x0253-0x0257 */ 210, 206, 0, 205, 205, /* 0x0258-0x025f */ 0, 202, 0, 203, 0, 0, 0, 0, /* 0x0260-0x0267 */ 205, 0, 0, 207, 0, 0, 0, 0, /* 0x0268-0x026f */ 209, 211, 0, 0, 0, 0, 0, 211, /* 0x0270-0x0277 */ 0, 0, 213, 0, 0, 214, 0, 0, /* 0x0278-0x027f */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x0280-0x0287 */ 0, 0, 0, 218, 0, 0, 0, 0, /* 0x0288-0x028f */ 218, 0, 217, 217, 0, 0, 0, 0, /* 0x0290-0x0297 */ 0, 0, 219 }; if (ch <= 0x0292) { *pch -= abLookup[ch - 0x0253]; } } else { *pch -= (ch == 0x03b0) ? 0 : (37 + (ch == 0x03ac)); } } else { if (ch < 0x0561) { if (ch < 0x0451) { if (ch < 0x03e3) { if (ch < 0x03cc) { *pch -= 32 - (ch == 0x03c2); } else { int i = (ch < 0x03d0); *pch -= (i<<6) - i + (ch == 0x03cc); } } else if (ch < 0x0430) { *pch -= (ch < 0x03f0); } else { *pch -= 32; } } else if (ch < 0x0461) { *pch -= 80; } else { *pch -= 1; } } else { if (ch < 0x1fb0) { if (ch < 0x1f70) { if (ch < 0x1e01) { int i = ch != 0x0587 && ch < 0x10d0; *pch -= ((i<<5)+(i<<4)); /* 48 */ } else if (ch < 0x1f00) { *pch -= !InRange(ch, 0x1e96, 0x1e9a); } else { int i = !InRange(ch, 0x1f50, 0x1f56)||(ch & 1); *pch += (i<<3); } } else { static const BYTE abLookup[] = { 74, 86, 86, 100, 128, 112, 126 }; if ( ch <= 0x1f7d ) { *pch += abLookup[(ch-0x1f70)>>1]; } } } else { if (ch < 0x24d0) { if (ch < 0x1fe5) { *pch += (0x0023 & (1<<(ch&15))) ? 8 : 0; } else if (ch < 0x2170) { *pch += (0x0023 & (1<<(ch&15))) ? 7 : 0; } else { *pch -= ((ch > 0x24b5)<<4); } } else if (ch < 0xff41) { int i = !InRange(ch, 0xfb00, 0xfb17); *pch -= (i<<4)+(i<<3)+(i<<1); /* 26 */ } else { *pch -= 32; } } } } } else { int i = InRange(ch, 0x2170, 0x217f); *pch -= (i<<4); } } return cchLength; } // CharUpper //---------------------------------------------------------------------- // // function: CharUpperWrapW( LPWSTR pch ) // // purpose: Converts character to uppercase. Takes either a pointer // to a string, or a character masquerading as a pointer. // In the later case, the HIWORD must be zero. This is // as spec'd for Win32. // // returns: Uppercased character or string. In the string case, // the uppercasing is done inplace. // //---------------------------------------------------------------------- LPWSTR WINAPI CharUpperWrapW( LPWSTR pch ) { VALIDATE_PROTOTYPE(CharUpper); if (g_bRunningOnNT) { return CharUpperW( pch ); } if (!HIWORD(pch)) { WCHAR ch = (WCHAR)(LONG_PTR)pch; CharUpperBuffWrapW( &ch, 1 ); pch = (LPWSTR)MAKEINTATOM(ch); } else { CharUpperBuffWrapW( pch, lstrlenW(pch) ); } return pch; } /* LPTSTR WINAPI CharUpperWrapW( LPTSTR lpsz ) // single character or pointer to string { LPWSTR lpszW = NULL; LPSTR lpszA = NULL; LPSTR lpszUpperA = NULL; VALIDATE_PROTOTYPE(CharUpper); if (g_bRunningOnNT) return CharUpperW(lpsz); lpszA = ConvertWtoA( lpsz ); lpszUpperA = CharUpperA( lpszA ); lpszW = ConvertAtoW( lpszUpperA ); CopyMemory( lpsz, lpszW, My_wcslen(lpszW) * sizeof(WCHAR) ); LocalFreeAndNull( &lpszW ); LocalFreeAndNull( &lpszA ); return lpsz; } */ // RegisterClipboardFormat UINT WINAPI RegisterClipboardFormatWrapW( LPCTSTR lpszFormat ) // address of name string { UINT uRetValue =0; LPSTR lpszFormatA = NULL; VALIDATE_PROTOTYPE(RegisterClipboardFormat); if (g_bRunningOnNT) return RegisterClipboardFormatW(lpszFormat); lpszFormatA = ConvertWtoA( lpszFormat ); uRetValue = RegisterClipboardFormatA( lpszFormatA ); LocalFreeAndNull( &lpszFormatA ); return uRetValue; } // DispatchMessage LRESULT WINAPI DispatchMessageWrapW( CONST MSG *lpmsg ) // pointer to structure with message { VALIDATE_PROTOTYPE(DispatchMessage); if (g_bRunningOnNT) return DispatchMessageW(lpmsg); return DispatchMessageA(lpmsg); } /* No A & W version BOOL WINAPI TranslateMessage( IN CONST MSG *lpMsg) */ // IsDialogMessage BOOL WINAPI IsDialogMessageWrapW( HWND hDlg, // handle of dialog box LPMSG lpMsg ) // address of structure with message { VALIDATE_PROTOTYPE(IsDialogMessage); if (g_bRunningOnNT) return IsDialogMessageW(hDlg, lpMsg); return IsDialogMessageA(hDlg, lpMsg); } // GetMessage BOOL WINAPI GetMessageWrapW( LPMSG lpMsg, // address of structure with message HWND hWnd, // handle of window UINT wMsgFilterMin, // first message UINT wMsgFilterMax ) // last message { VALIDATE_PROTOTYPE(GetMessage); if (g_bRunningOnNT) return GetMessageW(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax); return GetMessageA(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax); } // SetDlgItemText BOOL WINAPI SetDlgItemTextWrapW( HWND hDlg, // handle of dialog box int nIDDlgItem, // identifier of control LPCTSTR lpString ) // text to set { BOOL bRetValue; LPSTR lpStringA = NULL; VALIDATE_PROTOTYPE(SetDlgItemText); if (g_bRunningOnNT) return SetDlgItemTextW(hDlg, nIDDlgItem, lpString); lpStringA = ConvertWtoA( lpString ); bRetValue = SetDlgItemTextA(hDlg, nIDDlgItem, lpStringA); LocalFreeAndNull( &lpStringA ); return bRetValue; } // RegisterClassEx ATOM WINAPI RegisterClassExWrapW( CONST WNDCLASSEX *lpwcx ) // address of structure with class data { ATOM aReturn; WNDCLASSEXA wcxA; PSTR lpszClassName = NULL; PSTR lpszMenuName = NULL; VALIDATE_PROTOTYPE(RegisterClassEx); if (g_bRunningOnNT) return RegisterClassExW(lpwcx); wcxA.cbSize = sizeof(WNDCLASSEXA); wcxA.style = lpwcx->style; wcxA.lpfnWndProc = lpwcx->lpfnWndProc; wcxA.cbClsExtra = lpwcx->cbClsExtra; wcxA.cbWndExtra = lpwcx->cbWndExtra; wcxA.hInstance = lpwcx->hInstance; wcxA.hIcon = lpwcx->hIcon; wcxA.hCursor = lpwcx->hCursor; wcxA.hbrBackground = lpwcx->hbrBackground; wcxA.hIconSm = lpwcx->hIconSm; if ( lpwcx->lpszMenuName) { lpszMenuName = ConvertWtoA(lpwcx->lpszMenuName); wcxA.lpszMenuName = lpszMenuName; } if (lpwcx->lpszClassName) { lpszClassName = ConvertWtoA(lpwcx->lpszClassName); wcxA.lpszClassName = lpszClassName; } aReturn = RegisterClassExA( &wcxA ); if ( wcxA.lpszMenuName) LocalFreeAndNull( &lpszMenuName ); if (wcxA.lpszClassName) LocalFreeAndNull( &lpszClassName ); return aReturn; } // LoadAccelerators HACCEL WINAPI LoadAcceleratorsWrapW( HINSTANCE hInstance, // handle to application instance LPCTSTR lpTableName ) // address of table-name string { HACCEL hRetValue = NULL; LPSTR lpTableNameA = NULL; VALIDATE_PROTOTYPE(LoadAccelerators); if (g_bRunningOnNT) return LoadAcceleratorsW(hInstance, lpTableName); lpTableNameA = ConvertWtoA( lpTableName ); hRetValue = LoadAcceleratorsA( hInstance, lpTableNameA ); LocalFreeAndNull( &lpTableNameA ); return hRetValue; } // LoadMenu HMENU WINAPI LoadMenuWrapW( HINSTANCE hInstance, // handle to application instance LPCTSTR lpMenuName ) // menu name string or menu-resource identifier { HMENU hRetValue = NULL; LPSTR lpMenuNameA = NULL; VALIDATE_PROTOTYPE(LoadMenu); if (g_bRunningOnNT) return LoadMenuW(hInstance, lpMenuName); // becuause all the calling to this functions in our project just pass // and Resource ID as lpMenuName. so don't need to covert like a string lpMenuNameA = MAKEINTRESOURCEA(lpMenuName); hRetValue = LoadMenuA(hInstance,lpMenuNameA); return hRetValue; } //LoadIcon HICON WINAPI LoadIconWrapW( HINSTANCE hInstance, // handle to application instance LPCTSTR lpIconName ) // icon-name string or icon resource identifier { HICON hRetValue = NULL; LPSTR lpIconNameA = NULL; VALIDATE_PROTOTYPE(LoadIcon); if (g_bRunningOnNT) return LoadIconW(hInstance, lpIconName); // becuause all the calling to this functions in our project just pass // and Resource ID as lpMenuName. so don't need to covert like a string lpIconNameA = MAKEINTRESOURCEA(lpIconName ); hRetValue = LoadIconA(hInstance, lpIconNameA); return hRetValue; } // GetWindowText int WINAPI GetWindowTextWrapW( HWND hWnd, // handle to window or control with text LPTSTR lpString, // address of buffer for text int nMaxCount ) // maximum number of characters to copy { int iRetValue =0; LPSTR lpStringA = NULL; LPWSTR lpStringW = NULL; int nCount =0; VALIDATE_PROTOTYPE(GetWindowText); *lpString = '\0'; if (g_bRunningOnNT) return GetWindowTextW(hWnd, lpString, nMaxCount); nCount = nMaxCount * sizeof( WCHAR ); lpStringA = LocalAlloc( LMEM_ZEROINIT, nCount ); iRetValue = GetWindowTextA(hWnd, lpStringA, nCount); if ( iRetValue == 0 ) { LocalFreeAndNull( &lpStringA ); return iRetValue; } lpStringW = ConvertAtoW( lpStringA ); nCount = My_wcslen( lpStringW ); if ( nCount >= nMaxCount ) nCount = nMaxCount - 1; CopyMemory( lpString, lpStringW, nCount * sizeof(WCHAR) ); lpString[nCount] = 0x0000; iRetValue = nCount; LocalFreeAndNull( &lpStringA ); LocalFreeAndNull( &lpStringW ); return iRetValue; } // CallWindowProcWrap LRESULT WINAPI CallWindowProcWrapW( WNDPROC lpPrevWndFunc, // pointer to previous procedure HWND hWnd, // handle to window UINT Msg, // message WPARAM wParam, // first message parameter LPARAM lParam ) // second message parameter { VALIDATE_PROTOTYPE(CallWindowProc); if (g_bRunningOnNT) return CallWindowProcW(lpPrevWndFunc, hWnd, Msg, wParam, lParam); return CallWindowProcA(lpPrevWndFunc, hWnd, Msg, wParam, lParam); } // GetClassName int WINAPI GetClassNameWrapW( HWND hWnd, // handle of window LPTSTR lpClassName, // address of buffer for class name int nMaxCount ) // size of buffer, in characters { int iRetValue =0; LPSTR lpClassNameA = NULL; LPWSTR lpClassNameW = NULL; int nCount =0; VALIDATE_PROTOTYPE(GetClassName); if (g_bRunningOnNT) return GetClassNameW(hWnd, lpClassName, nMaxCount); nCount = nMaxCount * sizeof( WCHAR ); lpClassNameA = LocalAlloc( LMEM_ZEROINIT, nCount ); iRetValue = GetClassNameA(hWnd, lpClassNameA, nCount); if ( iRetValue == 0 ) { LocalFreeAndNull( &lpClassNameA ); return iRetValue; } lpClassNameW = ConvertAtoW( lpClassNameA ); nCount = My_wcslen( lpClassNameW ); if ( nCount >= nMaxCount ) nCount = nMaxCount - 1; CopyMemory( lpClassName, lpClassNameW, nCount * sizeof(WCHAR) ); lpClassName[nCount] = 0x0000; iRetValue = nCount; LocalFreeAndNull( &lpClassNameA ); LocalFreeAndNull( &lpClassNameW ); return iRetValue; } // TranslateAccelerator int WINAPI TranslateAcceleratorWrapW( HWND hWnd, // handle to destination window HACCEL hAccTable, // handle to accelerator table LPMSG lpMsg ) // address of structure with message { VALIDATE_PROTOTYPE(TranslateAccelerator); if (g_bRunningOnNT) return TranslateAcceleratorW(hWnd, hAccTable, lpMsg); return TranslateAcceleratorA(hWnd, hAccTable, lpMsg); } // GetDlgItemText UINT WINAPI GetDlgItemTextWrapW( HWND hDlg, // handle of dialog box int nIDDlgItem, // identifier of control LPTSTR lpString, // address of buffer for text int nMaxCount ) // maximum size of string { int iRetValue = 0; LPSTR lpStringA = NULL; LPWSTR lpStringW = NULL; int nCount =0; VALIDATE_PROTOTYPE(GetDlgItemText); *lpString = '\0'; if (g_bRunningOnNT) return GetDlgItemTextW(hDlg, nIDDlgItem, lpString, nMaxCount); nCount = nMaxCount * sizeof( WCHAR ); lpStringA = LocalAlloc( LMEM_ZEROINIT, nCount ); iRetValue = GetDlgItemTextA(hDlg, nIDDlgItem, lpStringA, nMaxCount); if ( iRetValue == 0 ) { LocalFreeAndNull( &lpStringA ); return iRetValue; } lpStringW = ConvertAtoW( lpStringA ); nCount = My_wcslen( lpStringW ); if ( nCount >= nMaxCount ) nCount = nMaxCount - 1; CopyMemory( lpString, lpStringW, nCount * sizeof(WCHAR) ); lpString[nCount] = 0x0000; iRetValue = nCount; LocalFreeAndNull( &lpStringA ); LocalFreeAndNull( &lpStringW ); return iRetValue; } // SetMenuItemInfo BOOL WINAPI SetMenuItemInfoWrapW( HMENU hMenu, UINT uItem, BOOL fByPosition, LPMENUITEMINFO lpmii ) { BOOL bRetValue; MENUITEMINFOA miiA; // VALIDATE_PROTOTYPE(SetMenuItemInfo); if (g_bRunningOnNT) return SetMenuItemInfoW(hMenu, uItem, fByPosition, lpmii); // Bug 1723 WinSE: MFT_STRING is defined as 0. So lpmii->fType can never have MFT_STRING bit set //if ( ((lpmii->fMask & MIIM_TYPE) == 0 ) || ((lpmii->fType & MFT_STRING) == 0 ) ) if ( ((lpmii->fMask & MIIM_TYPE) == 0 ) || lpmii->fType != MFT_STRING ) { return SetMenuItemInfoA(hMenu, uItem, fByPosition, (MENUITEMINFOA *)lpmii ); } CopyMemory(&miiA, lpmii, sizeof(MENUITEMINFOA) ); miiA.cbSize = sizeof(MENUITEMINFOA); miiA.dwTypeData = ConvertWtoA( lpmii->dwTypeData ); miiA.cch = lstrlenA( miiA.dwTypeData ); bRetValue = SetMenuItemInfoA(hMenu, uItem, fByPosition, &miiA ); LocalFreeAndNull( &miiA.dwTypeData ); return bRetValue; } // PeekMessage BOOL WINAPI PeekMessageWrapW( LPMSG lpMsg, // pointer to structure for message HWND hWnd, // handle to window UINT wMsgFilterMin, // first message UINT wMsgFilterMax, // last message UINT wRemoveMsg ) // removal flags { VALIDATE_PROTOTYPE(PeekMessage); if (g_bRunningOnNT) return PeekMessageW(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg); return PeekMessageA(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg); } // run time loaded APIs in Comctl32.dll extern LPIMAGELIST_LOADIMAGE_A gpfnImageList_LoadImageA; extern LPPROPERTYSHEET_A gpfnPropertySheetA; extern LP_CREATEPROPERTYSHEETPAGE_A gpfnCreatePropertySheetPageA; extern LPIMAGELIST_LOADIMAGE_W gpfnImageList_LoadImageW; extern LPPROPERTYSHEET_W gpfnPropertySheetW; extern LP_CREATEPROPERTYSHEETPAGE_W gpfnCreatePropertySheetPageW; HIMAGELIST WINAPI gpfnImageList_LoadImageWrapW(HINSTANCE hi, LPCWSTR lpbmp, int cx, int cGrow, COLORREF crMask, UINT uType, UINT uFlags) { WORD rID; VALIDATE_PROTOTYPE( gpfnImageList_LoadImage ); if (g_bRunningOnNT) return gpfnImageList_LoadImageW(hi, lpbmp, cx, cGrow, crMask, uType, uFlags) ; // in our case, all the calling functions pass resources ID to lpbmp, // so we don't want to convert this arguement. rID = (WORD)lpbmp; return gpfnImageList_LoadImageA(hi,(LPCSTR)((DWORD_PTR)(rID)), cx, cGrow, crMask, uType, uFlags) ; } INT_PTR WINAPI gpfnPropertySheetWrapW(LPCPROPSHEETHEADERW lppsh) { INT_PTR iRetValue; PROPSHEETHEADERA pshA; LPSTR pszCaption = NULL; VALIDATE_PROTOTYPE( gpfnPropertySheet ); if (g_bRunningOnNT) return gpfnPropertySheetW( lppsh ); CopyMemory( &pshA, lppsh, sizeof( PROPSHEETHEADERA ) ); pshA.dwSize = sizeof(PROPSHEETHEADERA); pszCaption = ConvertWtoA( lppsh->pszCaption ); pshA.pszCaption = pszCaption; iRetValue = gpfnPropertySheetA( &pshA ); LocalFreeAndNull( &pszCaption ); return iRetValue; } HPROPSHEETPAGE WINAPI gpfnCreatePropertySheetPageWrapW(LPCPROPSHEETPAGEW lppsp) { PROPSHEETPAGEA pspA; HPROPSHEETPAGE hRetValue; LPSTR lpTitle = NULL; VALIDATE_PROTOTYPE( gpfnCreatePropertySheetPage ); if (g_bRunningOnNT) return gpfnCreatePropertySheetPageW( lppsp ); CopyMemory( &pspA, lppsp, sizeof(PROPSHEETPAGEA) ); pspA.dwSize = sizeof( PROPSHEETPAGEA ); lpTitle = ConvertWtoA( lppsp->pszTitle ); pspA.pszTitle = lpTitle; hRetValue = gpfnCreatePropertySheetPageA( &pspA ); LocalFreeAndNull( &lpTitle ); return hRetValue; } // APIs in Commdlg32.dll extern BOOL (*pfnGetOpenFileNameA)(LPOPENFILENAMEA pof); extern BOOL (*pfnGetOpenFileNameW)(LPOPENFILENAMEW pof); BOOL WINAPI pfnGetOpenFileNameWrapW(LPOPENFILENAMEW lpOf) { BOOL bRetValue; OPENFILENAMEA ofA; LPSTR lpstrFilterA = NULL; LPSTR lpstrFilterA_T = NULL,lpstrFilterAA=NULL ; LPWSTR lpstrFilterW = NULL; CHAR lpstrFileA[MAX_PATH+1] =""; LPSTR lpstrFileTitleA = NULL; LPSTR lpstrTitleA = NULL; LPSTR lpstrDefExtA= NULL; LPSTR lpTemplateNameA = NULL; LPSTR lpstrInitialDirA = NULL; LPWSTR lpstrFileW = NULL; DWORD dwLen; VALIDATE_PROTOTYPE(pfnGetOpenFileName); if (g_bRunningOnNT) return pfnGetOpenFileNameW( lpOf ); CopyMemory( &ofA, lpOf, sizeof( OPENFILENAMEA ) ); ofA.lStructSize = sizeof( OPENFILENAMEA ); if ( lpOf->lpTemplateName ) { lpTemplateNameA = ConvertWtoA( lpOf->lpTemplateName ); ofA.lpTemplateName = lpTemplateNameA; } else ofA.lpTemplateName = NULL; if ( lpOf->lpstrDefExt ) { lpstrDefExtA = ConvertWtoA( lpOf->lpstrDefExt ); ofA.lpstrDefExt = lpstrDefExtA; } else ofA.lpstrDefExt = NULL; if ( lpOf->lpstrTitle ) { lpstrTitleA = ConvertWtoA( lpOf->lpstrTitle ); ofA.lpstrTitle = lpstrTitleA; } else ofA.lpstrTitle = NULL; if ( lpOf->lpstrFileTitle ) { lpstrFileTitleA = ConvertWtoA( lpOf->lpstrFileTitle ); ofA.lpstrFileTitle = lpstrFileTitleA; } else ofA.lpstrFileTitle = NULL; if ( lpOf->lpstrInitialDir ) { lpstrInitialDirA = ConvertWtoA( lpOf->lpstrInitialDir ); ofA.lpstrInitialDir = lpstrInitialDirA; } else ofA.lpstrInitialDir = NULL; ofA.lpstrCustomFilter = NULL; // get the total length of lpOf->lpstrFilter dwLen = 0; lpstrFilterW = (LPWSTR)(lpOf->lpstrFilter); while ( *lpstrFilterW != TEXT('\0') ) { dwLen += lstrlenW(lpstrFilterW) + 1; lpstrFilterW += lstrlenW(lpstrFilterW) + 1; } dwLen += 1; // for the last null terminator lpstrFilterW = (LPWSTR)( lpOf->lpstrFilter ); lpstrFilterA = LocalAlloc( LMEM_ZEROINIT, dwLen * sizeof(WCHAR) ); lpstrFilterA_T = lpstrFilterA; while ( *lpstrFilterW != TEXT('\0') ) { lpstrFilterAA = ConvertWtoA(lpstrFilterW ); lpstrFilterW += lstrlenW(lpstrFilterW) + 1; strcpy(lpstrFilterA_T, lpstrFilterAA ); LocalFreeAndNull( &lpstrFilterAA ); lpstrFilterA_T += lstrlenA( lpstrFilterA_T ) + 1; } lpstrFilterA_T[lstrlenA(lpstrFilterA_T)+1] = '\0'; ofA.lpstrFilter = lpstrFilterA; ofA.lpstrFile = lpstrFileA; ofA.nMaxFile = MAX_PATH + 1; bRetValue = pfnGetOpenFileNameA( &ofA ); LocalFreeAndNull( &lpTemplateNameA ); LocalFreeAndNull( &lpstrDefExtA ); LocalFreeAndNull( &lpstrTitleA ); LocalFreeAndNull( &lpstrFileTitleA ); LocalFreeAndNull( &lpstrInitialDirA ); LocalFreeAndNull( &lpstrFilterA ); if ( bRetValue != FALSE ) { lpstrFileW = ConvertAtoW( lpstrFileA ); CopyMemory( lpOf->lpstrFile, lpstrFileW, (lstrlenW(lpstrFileW)+1) * sizeof( WCHAR) ); LocalFreeAndNull( &lpstrFileW ); } return bRetValue; } extern BOOL (*pfnGetSaveFileNameA)(LPOPENFILENAMEA pof); extern BOOL (*pfnGetSaveFileNameW)(LPOPENFILENAMEW pof); BOOL WINAPI pfnGetSaveFileNameWrapW(LPOPENFILENAMEW lpOf) { BOOL bRetValue; OPENFILENAMEA ofA; LPSTR lpstrFilterA = NULL; LPSTR lpstrFilterA_T = NULL,lpstrFilterAA=NULL ; LPWSTR lpstrFilterW = NULL; CHAR lpstrFileA[MAX_PATH+1] =""; LPSTR lpFileA = NULL; LPSTR lpstrFileTitleA = NULL; LPSTR lpstrTitleA = NULL; LPSTR lpstrDefExtA= NULL; LPSTR lpTemplateNameA = NULL; LPSTR lpstrInitialDirA = NULL; LPWSTR lpstrFileW = NULL; DWORD dwLen; VALIDATE_PROTOTYPE(pfnGetOpenFileName); if (g_bRunningOnNT) return pfnGetSaveFileNameW( lpOf ); CopyMemory( &ofA, lpOf, sizeof( OPENFILENAMEA ) ); ofA.lStructSize = sizeof( OPENFILENAMEA ); if ( lpOf->lpTemplateName ) { lpTemplateNameA = ConvertWtoA( lpOf->lpTemplateName ); ofA.lpTemplateName = lpTemplateNameA; } else ofA.lpTemplateName = NULL; if ( lpOf->lpstrDefExt ) { lpstrDefExtA = ConvertWtoA( lpOf->lpstrDefExt ); ofA.lpstrDefExt = lpstrDefExtA; } else ofA.lpstrDefExt = NULL; if ( lpOf->lpstrTitle ) { lpstrTitleA = ConvertWtoA( lpOf->lpstrTitle ); ofA.lpstrTitle = lpstrTitleA; } else ofA.lpstrTitle = NULL; if ( lpOf->lpstrFileTitle ) { lpstrFileTitleA = ConvertWtoA( lpOf->lpstrFileTitle ); ofA.lpstrFileTitle = lpstrFileTitleA; } else ofA.lpstrFileTitle = NULL; if ( lpOf->lpstrFile ) { lpFileA = ConvertWtoA( lpOf->lpstrFile ); lstrcpyA(lpstrFileA, lpFileA); ofA.lpstrFile = lpstrFileA; ofA.nMaxFile = MAX_PATH + 1; } else ofA.lpstrFile = NULL; if ( lpOf->lpstrInitialDir ) { lpstrInitialDirA = ConvertWtoA( lpOf->lpstrInitialDir ); ofA.lpstrInitialDir = lpstrInitialDirA; } else ofA.lpstrInitialDir = NULL; ofA.lpstrCustomFilter = NULL; // get the total length of lpOf->lpstrFilter dwLen = 0; lpstrFilterW = (LPWSTR)(lpOf->lpstrFilter); while ( *lpstrFilterW != TEXT('\0') ) { dwLen += lstrlenW(lpstrFilterW) + 1; lpstrFilterW += lstrlenW(lpstrFilterW) + 1; } dwLen += 1; // for the last null terminator lpstrFilterW = (LPWSTR)( lpOf->lpstrFilter ); lpstrFilterA = LocalAlloc( LMEM_ZEROINIT, dwLen * sizeof(WCHAR) ); lpstrFilterA_T = lpstrFilterA; while ( *lpstrFilterW != TEXT('\0') ) { lpstrFilterAA = ConvertWtoA(lpstrFilterW ); lpstrFilterW += lstrlenW(lpstrFilterW) + 1; strcpy(lpstrFilterA_T, lpstrFilterAA ); LocalFreeAndNull( &lpstrFilterAA ); lpstrFilterA_T += lstrlenA( lpstrFilterA_T ) + 1; } lpstrFilterA_T[lstrlenA(lpstrFilterA_T)+1] = '\0'; ofA.lpstrFilter = lpstrFilterA; bRetValue = pfnGetSaveFileNameA( &ofA ); LocalFreeAndNull( &lpTemplateNameA ); LocalFreeAndNull( &lpstrDefExtA ); LocalFreeAndNull( &lpstrTitleA ); LocalFreeAndNull( &lpstrFileTitleA ); LocalFreeAndNull( &lpstrInitialDirA ); LocalFreeAndNull( &lpstrFilterA ); LocalFreeAndNull( &lpFileA ); if ( bRetValue != FALSE ) { lpstrFileW = ConvertAtoW( lpstrFileA ); CopyMemory( lpOf->lpstrFile, lpstrFileW, (lstrlenW(lpstrFileW)+1) * sizeof( WCHAR) ); LocalFreeAndNull( &lpstrFileW ); } return bRetValue; } extern BOOL (*pfnPrintDlgA)(LPPRINTDLGA lppd); extern BOOL (*pfnPrintDlgW)(LPPRINTDLGW lppd); BOOL WINAPI pfnPrintDlgWrapW(LPPRINTDLGW lppd) { BOOL bRetValue; PRINTDLGA pdA; VALIDATE_PROTOTYPE(pfnPrintDlg); if (g_bRunningOnNT) return pfnPrintDlgW( lppd ); CopyMemory( &pdA, lppd, sizeof( PRINTDLGA ) ); pdA.lStructSize = sizeof( PRINTDLGA ); // Only lpPrintTemplateName and lpSetupTemplateName has STR type, // but in our case, only IDD of Resources are passed to these two parameters. // so don't do conversion. pdA.lpPrintTemplateName = (LPCSTR)(lppd->lpPrintTemplateName); pdA.lpSetupTemplateName = (LPCSTR)(lppd->lpSetupTemplateName); bRetValue = pfnPrintDlgA ( &pdA ); lppd->hDC = pdA.hDC; lppd->Flags = pdA.Flags; lppd->nFromPage = pdA.nFromPage; lppd->nToPage = pdA.nToPage; lppd->nMinPage = pdA.nMinPage; lppd->nMaxPage = pdA.nMaxPage; lppd->nCopies = pdA.nCopies; return bRetValue; } extern HRESULT (*pfnPrintDlgExA)(LPPRINTDLGEXA lppdex); extern HRESULT (*pfnPrintDlgExW)(LPPRINTDLGEXW lppdex); HRESULT WINAPI pfnPrintDlgExWrapW(LPPRINTDLGEXW lppdex) { HRESULT hRetValue; PRINTDLGEXA pdexA; VALIDATE_PROTOTYPE(pfnPrintDlgEx); if (g_bRunningOnNT) return pfnPrintDlgExW( lppdex ); CopyMemory( &pdexA, lppdex, sizeof( PRINTDLGEXA ) ); pdexA.lStructSize = sizeof( PRINTDLGEXA ); // Only lpPrintTemplateName and lpSetupTemplateName has STR type, // but in our case, only IDD of Resources are passed to these two parameters. // so don't do conversion. hRetValue = pfnPrintDlgExA( &pdexA ); lppdex->dwResultAction = pdexA.dwResultAction; lppdex->hDC = pdexA.hDC; lppdex->lpPageRanges = pdexA.lpPageRanges; lppdex->nCopies = pdexA.nCopies; lppdex->nMaxPage = pdexA.nMaxPage; lppdex->nMaxPageRanges = pdexA.nMaxPageRanges; lppdex->nMinPage = pdexA.nMinPage; lppdex->nPageRanges = pdexA.nPageRanges; lppdex->nPropertyPages = pdexA.nPropertyPages; lppdex->nStartPage = pdexA.nStartPage; return hRetValue; } // GetWindowTextLength int WINAPI GetWindowTextLengthWrapW( HWND hWnd) { VALIDATE_PROTOTYPE(GetWindowTextLength); if (g_bRunningOnNT) return GetWindowTextLengthW(hWnd); else return GetWindowTextLengthA(hWnd); } // GetFileVersionInfoSize DWORD GetFileVersionInfoSizeWrapW( LPTSTR lptstrFilename, LPDWORD lpdwHandle ) { LPSTR lpFileA = NULL; DWORD dwRet = 0; VALIDATE_PROTOTYPE(GetFileVersionInfoSize); if (g_bRunningOnNT) return GetFileVersionInfoSizeW(lptstrFilename, lpdwHandle); lpFileA = ConvertWtoA(lptstrFilename); dwRet = GetFileVersionInfoSizeA(lpFileA, lpdwHandle); LocalFreeAndNull(&lpFileA); return dwRet; } // GetFileVersionInfo BOOL GetFileVersionInfoWrapW( LPTSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData) { LPSTR lpFileA = NULL; BOOL bRet = FALSE; VALIDATE_PROTOTYPE(GetFileVersionInfo); if (g_bRunningOnNT) return GetFileVersionInfoW(lptstrFilename, dwHandle, dwLen, lpData); // Note this is assuming that the dwLen and dwHandle are the same as those returned by // GetFileVersionInfoSize .. lpFileA = ConvertWtoA(lptstrFilename); bRet = GetFileVersionInfoA(lpFileA, dwHandle, dwLen, lpData); LocalFreeAndNull(&lpFileA); return bRet; } // VerQueryValue // This one assumes that pBlock etc are all returned by GetFileVersionInfo and GetFileVersionInfoSize etc BOOL VerQueryValueWrapW( const LPVOID pBlock, LPTSTR lpSubBlock, LPVOID *lplpBuffer, PUINT puLen) { LPSTR lpBlockA = NULL; BOOL bRet = FALSE; VALIDATE_PROTOTYPE(GetFileVersionInfo); if (g_bRunningOnNT) return VerQueryValueW(pBlock, lpSubBlock, lplpBuffer, puLen); // Note this is assuming that the dwLen and dwHandle are the same as those returned by // GetFileVersionInfoSize .. lpBlockA = ConvertWtoA(lpSubBlock); bRet = VerQueryValueA(pBlock, lpBlockA, lplpBuffer, puLen); LocalFreeAndNull(&lpBlockA); return bRet; }