1841 lines
33 KiB
C++
1841 lines
33 KiB
C++
//+---------------------------------------------------------------------------
|
||
//
|
||
// Microsoft Windows
|
||
// Copyright (C) Microsoft Corporation, 1993 - 1993.
|
||
//
|
||
// File: widewrap.cxx
|
||
//
|
||
// Contents: Unicode wrapper API, used only on Chicago
|
||
//
|
||
// Functions: About fifty Win32 function wrappers
|
||
//
|
||
// Notes: 'sz' is used instead of the "correct" hungarian 'psz'
|
||
// throughout to enhance readability.
|
||
//
|
||
// Not all of every Win32 function is wrapped here. Some
|
||
// obscurely-documented features may not be handled correctly
|
||
// in these wrappers. Caller beware.
|
||
//
|
||
// These are privately exported for use by the Shell.
|
||
//
|
||
// History: 28-Dec-93 ErikGav Created
|
||
// 06-14-94 KentCe Various Chicago build fixes.
|
||
// 21-Dec-94 BruceMa Use olewcstombs + other fixes
|
||
// 21-Feb-95 BruceMa Add support for AreFileApisANSI
|
||
//
|
||
//----------------------------------------------------------------------------
|
||
|
||
#include <windows.h>
|
||
#include "widewrap.h"
|
||
|
||
size_t olembstowcs(WCHAR *pwsz, const char *psz, size_t cCh);
|
||
size_t olewcstombs(char *psz, const WCHAR *pwsz , size_t cCh);
|
||
|
||
inline size_t olembstowcs(WCHAR *pwsz, const char *psz, size_t cCh)
|
||
{
|
||
return MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, psz, -1, pwsz, cCh);
|
||
}
|
||
|
||
inline size_t olewcstombs(char *psz, const WCHAR *pwsz , size_t cCh)
|
||
{
|
||
return WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, pwsz, -1, psz,
|
||
cCh, NULL, NULL);
|
||
}
|
||
|
||
#ifdef _CHICAGO_
|
||
|
||
#define HFINDFILE HANDLE
|
||
#define ERR ((char*) -1)
|
||
|
||
|
||
//
|
||
// BUGBUG: 9869
|
||
//
|
||
// The length of a Unicode string (in chars) and a DBCS string are not
|
||
// always equal. We need to review all WideChar to MultiByte conversions
|
||
// logic to verify that the proper result buffer size is used.
|
||
//
|
||
// Make the below Win95 only change to get the Win95 FE build out.
|
||
//
|
||
|
||
int UnicodeToAnsi(LPSTR sz, LPCWSTR pwsz, LONG cb)
|
||
{
|
||
int ret;
|
||
|
||
ret = WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, pwsz, -1, sz, cb, NULL, NULL);
|
||
|
||
#if DBG==1
|
||
if (ret == -1)
|
||
{
|
||
DebugBreak();
|
||
}
|
||
#endif
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
int UnicodeToAnsiOem(LPSTR sz, LPCWSTR pwsz, LONG cb)
|
||
{
|
||
int ret;
|
||
|
||
if (AreFileApisANSI())
|
||
{
|
||
ret = WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, pwsz, -1, sz,
|
||
cb, NULL, NULL);
|
||
}
|
||
else
|
||
{
|
||
ret = WideCharToMultiByte(CP_OEMCP, WC_COMPOSITECHECK, pwsz, -1, sz,
|
||
cb, NULL, NULL);
|
||
}
|
||
|
||
#if DBG==1
|
||
if (ret == -1)
|
||
{
|
||
DebugBreak();
|
||
}
|
||
#endif
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
|
||
#if DBG==1
|
||
int AnsiToUnicode(LPWSTR pwsz, LPCSTR sz, LONG cb)
|
||
{
|
||
int ret;
|
||
|
||
ret = olembstowcs(pwsz, sz, cb);
|
||
|
||
if (ret == -1)
|
||
{
|
||
DebugBreak();
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
#else
|
||
#define AnsiToUnicode olembstowcs
|
||
#endif
|
||
|
||
|
||
|
||
int AnsiToUnicodeOem(LPWSTR pwsz, LPCSTR sz, LONG cb)
|
||
{
|
||
int ret;
|
||
|
||
if (AreFileApisANSI())
|
||
{
|
||
ret = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, sz, cb, pwsz, cb);
|
||
}
|
||
else
|
||
{
|
||
ret = MultiByteToWideChar(CP_OEMCP, MB_PRECOMPOSED, sz, cb, pwsz, cb);
|
||
}
|
||
|
||
#if DBG==1
|
||
if (ret == -1)
|
||
{
|
||
DebugBreak();
|
||
}
|
||
#endif
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
|
||
|
||
LPSTR Convert(LPCWSTR pwsz)
|
||
{
|
||
LONG len;
|
||
LPSTR sz = NULL;
|
||
|
||
if (pwsz == NULL)
|
||
goto Exit;
|
||
|
||
#if DBG==1
|
||
// some Win32 API accept atoms in their string parameters
|
||
#endif
|
||
|
||
len = (wcslen(pwsz) + 1) * 2;
|
||
|
||
sz = new CHAR[len];
|
||
if (sz==NULL)
|
||
{
|
||
sz = ERR;
|
||
goto Exit;
|
||
}
|
||
|
||
__try
|
||
{
|
||
UnicodeToAnsi(sz, pwsz, len);
|
||
}
|
||
__except(EXCEPTION_EXECUTE_HANDLER)
|
||
{
|
||
#if DBG==1
|
||
MessageBoxA(NULL, "GP fault in unicode conversion -- caught",
|
||
NULL, MB_OK);
|
||
#endif
|
||
if (sz)
|
||
delete sz;
|
||
sz = ERR;
|
||
}
|
||
|
||
Exit:
|
||
return sz;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
LPSTR ConvertOem(LPCWSTR pwsz)
|
||
{
|
||
LONG len;
|
||
LPSTR sz = NULL;
|
||
|
||
if (pwsz == NULL)
|
||
goto Exit;
|
||
|
||
#if DBG==1
|
||
// some Win32 API accept atoms in their string parameters
|
||
#endif
|
||
|
||
len = (wcslen(pwsz) + 1) * 2;
|
||
|
||
sz = new CHAR[len];
|
||
if (sz==NULL)
|
||
{
|
||
sz = ERR;
|
||
goto Exit;
|
||
}
|
||
|
||
__try
|
||
{
|
||
UnicodeToAnsiOem(sz, pwsz, len);
|
||
}
|
||
__except(EXCEPTION_EXECUTE_HANDLER)
|
||
{
|
||
#if DBG==1
|
||
MessageBoxA(NULL, "GP fault in unicode conversion -- caught",
|
||
NULL, MB_OK);
|
||
#endif
|
||
if (sz)
|
||
delete sz;
|
||
sz = ERR;
|
||
}
|
||
|
||
Exit:
|
||
return sz;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
HANDLE WINAPI CreateFileX(LPCWSTR pwsz, DWORD fdwAccess, DWORD fdwShareMask,
|
||
LPSECURITY_ATTRIBUTES lpsa, DWORD fdwCreate, DWORD fdwAttrsAndFlags,
|
||
HANDLE hTemplateFile)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("CreateFile\n");
|
||
#endif
|
||
|
||
CHAR sz[MAX_PATH * 2];
|
||
UnicodeToAnsiOem(sz, pwsz, sizeof(sz));
|
||
|
||
return CreateFileA(sz, fdwAccess, fdwShareMask, lpsa, fdwCreate,
|
||
fdwAttrsAndFlags, hTemplateFile);
|
||
}
|
||
|
||
BOOL WINAPI DeleteFileX(LPCWSTR pwsz)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("DeleteFile\n");
|
||
#endif
|
||
|
||
CHAR sz[MAX_PATH * 2];
|
||
UnicodeToAnsi(sz, pwsz, sizeof(sz));
|
||
|
||
return DeleteFileA(sz);
|
||
}
|
||
|
||
|
||
LONG APIENTRY RegOpenKeyX(HKEY hKey, LPCWSTR pwszSubKey, PHKEY phkResult)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("RegOpenKey\n");
|
||
#endif
|
||
|
||
LONG ret;
|
||
LPSTR sz;
|
||
|
||
sz = Convert(pwszSubKey);
|
||
|
||
if (sz == ERR)
|
||
{
|
||
return ERROR_OUTOFMEMORY;
|
||
}
|
||
|
||
ret = RegOpenKeyA(hKey, sz, phkResult);
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
LONG APIENTRY RegQueryValueX(HKEY hKey, LPCWSTR pwszSubKey, LPWSTR pwszValue,
|
||
PLONG lpcbValue)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("RegQueryValue\n");
|
||
#endif
|
||
|
||
LONG cb, ret;
|
||
LPSTR szValue = NULL;
|
||
LPSTR sz;
|
||
|
||
sz = Convert(pwszSubKey);
|
||
if (sz == ERR)
|
||
{
|
||
return ERROR_OUTOFMEMORY;
|
||
}
|
||
|
||
ret = RegQueryValueA(hKey, sz, NULL, &cb);
|
||
|
||
// If the caller was just asking for the size of the value, jump out
|
||
// now, without actually retrieving and converting the value.
|
||
|
||
if (pwszValue == NULL)
|
||
{
|
||
// Adjust size of buffer to report, to account for CHAR -> WCHAR
|
||
*lpcbValue = cb * sizeof(WCHAR);
|
||
goto Exit;
|
||
}
|
||
|
||
|
||
if (ret == ERROR_SUCCESS)
|
||
{
|
||
// If the caller was asking for the value, but allocated too small
|
||
// of a buffer, set the buffer size and jump out.
|
||
|
||
if (*lpcbValue < (LONG) (cb * sizeof(WCHAR)))
|
||
{
|
||
// Adjust size of buffer to report, to account for CHAR -> WCHAR
|
||
*lpcbValue = cb * sizeof(WCHAR);
|
||
ret = ERROR_MORE_DATA;
|
||
goto Exit;
|
||
}
|
||
|
||
// Otherwise, retrieve and convert the value.
|
||
|
||
szValue = new CHAR[cb];
|
||
if (szValue == NULL)
|
||
{
|
||
ret = ERROR_OUTOFMEMORY;
|
||
goto Exit;
|
||
}
|
||
|
||
ret = RegQueryValueA(hKey, sz, szValue, &cb);
|
||
|
||
if (ret == ERROR_SUCCESS)
|
||
{
|
||
AnsiToUnicode(pwszValue, szValue, cb);
|
||
|
||
// Adjust size of buffer to report, to account for CHAR -> WCHAR
|
||
*lpcbValue = cb * sizeof(WCHAR);
|
||
}
|
||
}
|
||
|
||
Exit:
|
||
if (szValue)
|
||
delete szValue;
|
||
if (sz)
|
||
delete sz;
|
||
|
||
return ret;
|
||
}
|
||
|
||
LONG APIENTRY RegSetValueX(HKEY hKey, LPCWSTR lpSubKey, DWORD dwType,
|
||
LPCWSTR lpData, DWORD cbData)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("RegSetValue\n");
|
||
#endif
|
||
|
||
LPSTR szKey = NULL;
|
||
LPSTR szValue = NULL;
|
||
LONG ret = ERROR_OUTOFMEMORY;
|
||
|
||
szKey = Convert(lpSubKey);
|
||
if (szKey == ERR)
|
||
{
|
||
szKey = NULL;
|
||
goto Exit;
|
||
}
|
||
|
||
szValue = Convert(lpData);
|
||
if (szValue == ERR)
|
||
{
|
||
szValue = NULL;
|
||
goto Exit;
|
||
}
|
||
|
||
ret = RegSetValueA(hKey, szKey, dwType, szValue, cbData);
|
||
|
||
Exit:
|
||
if (szKey)
|
||
delete szKey;
|
||
if (szValue)
|
||
delete szValue;
|
||
return ret;
|
||
}
|
||
|
||
LONG APIENTRY RegSetValueExX(HKEY hKey,
|
||
LPCWSTR lpSubKey,
|
||
DWORD dwReserved,
|
||
DWORD dwType,
|
||
LPBYTE lpData,
|
||
DWORD cbData)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("RegSetValueEx\n");
|
||
#endif
|
||
|
||
LPSTR szKey = NULL;
|
||
LPBYTE szValue = lpData;
|
||
LONG ret = ERROR_OUTOFMEMORY;
|
||
|
||
szKey = Convert(lpSubKey);
|
||
if (szKey == ERR)
|
||
{
|
||
szKey = NULL;
|
||
goto Exit;
|
||
}
|
||
|
||
if (dwType == REG_SZ)
|
||
{
|
||
szValue = (LPBYTE) Convert((LPWSTR)lpData);
|
||
}
|
||
if (szValue == (LPBYTE) ERR)
|
||
{
|
||
szValue = NULL;
|
||
goto Exit;
|
||
}
|
||
|
||
ret = RegSetValueExA(hKey, szKey, dwReserved, dwType, szValue, cbData);
|
||
|
||
Exit:
|
||
if (szKey)
|
||
delete szKey;
|
||
if ((szValue != lpData) && (szValue != (LPBYTE)ERR))
|
||
delete szValue;
|
||
return ret;
|
||
}
|
||
|
||
UINT WINAPI RegisterWindowMessageX(LPCWSTR lpString)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("RegisterWindowMessage\n");
|
||
#endif
|
||
|
||
UINT ret;
|
||
#if 0
|
||
LPSTR sz;
|
||
|
||
sz = Convert(lpString);
|
||
if (sz == ERR)
|
||
{
|
||
return 0;
|
||
}
|
||
#else
|
||
// BUGBUG: CairOLE calls this from libmain -- have to use static buffer
|
||
|
||
CHAR sz[200];
|
||
UnicodeToAnsi(sz, lpString, sizeof(sz));
|
||
#endif
|
||
|
||
ret = RegisterWindowMessageA(sz);
|
||
#if 0
|
||
delete sz;
|
||
#endif
|
||
return ret;
|
||
}
|
||
|
||
LONG
|
||
APIENTRY
|
||
RegOpenKeyExX (
|
||
HKEY hKey,
|
||
LPCWSTR lpSubKey,
|
||
DWORD ulOptions,
|
||
REGSAM samDesired,
|
||
PHKEY phkResult
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("RegOpenKeyEx\n");
|
||
#endif
|
||
|
||
LONG ret;
|
||
LPSTR sz;
|
||
|
||
sz = Convert(lpSubKey);
|
||
if (sz == ERR)
|
||
{
|
||
return ERROR_OUTOFMEMORY;
|
||
}
|
||
|
||
ret = RegOpenKeyExA(hKey, sz, ulOptions, samDesired, phkResult);
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
LONG
|
||
APIENTRY
|
||
RegQueryValueExX(
|
||
HKEY hKey,
|
||
LPWSTR lpValueName,
|
||
LPDWORD lpReserved,
|
||
LPDWORD lpType,
|
||
LPBYTE lpData,
|
||
LPDWORD lpcbData
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("RegQueryValueEx\n");
|
||
#endif
|
||
|
||
LPBYTE lpTempBuffer;
|
||
DWORD dwTempType;
|
||
DWORD cb, cbRequired;
|
||
LONG ret;
|
||
LPSTR sz;
|
||
LPWSTR pwszTempWide;
|
||
LPSTR pszTempNarrow;
|
||
ULONG ulStringLength;
|
||
|
||
sz = Convert(lpValueName);
|
||
if (sz == ERR)
|
||
{
|
||
return ERROR_OUTOFMEMORY;
|
||
}
|
||
|
||
ret = RegQueryValueExA(hKey, sz, lpReserved, &dwTempType, NULL, &cb);
|
||
|
||
// If the caller was just asking for the size of the value, jump out
|
||
// now, without actually retrieving and converting the value.
|
||
|
||
if (lpData == NULL)
|
||
{
|
||
switch (dwTempType)
|
||
{
|
||
case REG_EXPAND_SZ:
|
||
case REG_MULTI_SZ:
|
||
case REG_SZ:
|
||
|
||
// Adjust size of buffer to report, to account for CHAR -> WCHAR
|
||
|
||
if (lpcbData != NULL)
|
||
*lpcbData = cb * sizeof(WCHAR);
|
||
break;
|
||
|
||
default:
|
||
|
||
if (lpcbData != NULL)
|
||
*lpcbData = cb;
|
||
break;
|
||
}
|
||
|
||
// Set the type, if required.
|
||
if (lpType != NULL)
|
||
{
|
||
*lpType = dwTempType;
|
||
}
|
||
|
||
goto Exit;
|
||
}
|
||
|
||
|
||
if (ret == ERROR_SUCCESS)
|
||
{
|
||
//
|
||
// Determine the size of buffer needed
|
||
//
|
||
|
||
switch (dwTempType)
|
||
{
|
||
case REG_EXPAND_SZ:
|
||
case REG_MULTI_SZ:
|
||
case REG_SZ:
|
||
|
||
cbRequired = cb * sizeof(WCHAR);
|
||
break;
|
||
|
||
default:
|
||
|
||
cbRequired = cb;
|
||
break;
|
||
}
|
||
|
||
// If the caller was asking for the value, but allocated too small
|
||
// of a buffer, set the buffer size and jump out.
|
||
|
||
if (lpcbData != NULL && *lpcbData < cbRequired)
|
||
{
|
||
// Adjust size of buffer to report, to account for CHAR -> WCHAR
|
||
*lpcbData = cbRequired;
|
||
|
||
// Set the type, if required.
|
||
if (lpType != NULL)
|
||
{
|
||
*lpType = dwTempType;
|
||
}
|
||
|
||
ret = ERROR_MORE_DATA;
|
||
goto Exit;
|
||
}
|
||
|
||
// Otherwise, retrieve and convert the value.
|
||
|
||
switch (dwTempType)
|
||
{
|
||
case REG_EXPAND_SZ:
|
||
case REG_MULTI_SZ:
|
||
case REG_SZ:
|
||
|
||
lpTempBuffer = new BYTE[cbRequired];
|
||
if (lpTempBuffer == NULL)
|
||
{
|
||
return ERROR_OUTOFMEMORY;
|
||
}
|
||
|
||
ret = RegQueryValueExA(hKey,
|
||
sz,
|
||
lpReserved,
|
||
&dwTempType,
|
||
lpTempBuffer,
|
||
&cb);
|
||
|
||
if (ret == ERROR_SUCCESS)
|
||
{
|
||
switch (dwTempType)
|
||
{
|
||
case REG_EXPAND_SZ:
|
||
case REG_SZ:
|
||
|
||
AnsiToUnicode((LPWSTR) lpData, (LPSTR) lpTempBuffer, cb);
|
||
|
||
// Adjust size of buffer to report, to account for CHAR -> WCHAR
|
||
*lpcbData = cbRequired;
|
||
|
||
// Set the type, if required.
|
||
if (lpType != NULL)
|
||
{
|
||
*lpType = dwTempType;
|
||
}
|
||
break;
|
||
|
||
case REG_MULTI_SZ:
|
||
|
||
pszTempNarrow = (LPSTR) lpTempBuffer;
|
||
pwszTempWide = (LPWSTR) lpData;
|
||
|
||
while (pszTempNarrow != NULL)
|
||
{
|
||
ulStringLength = strlen(pszTempNarrow) + 1;
|
||
AnsiToUnicode(pwszTempWide,
|
||
pszTempNarrow,
|
||
ulStringLength);
|
||
|
||
// Compiler will scale appropriately here
|
||
pszTempNarrow += ulStringLength;
|
||
pwszTempWide += ulStringLength;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (lpTempBuffer)
|
||
delete lpTempBuffer;
|
||
|
||
break;
|
||
|
||
default:
|
||
|
||
//
|
||
// No conversion of out parameters needed. Just call narrow
|
||
// version with args passed in, and return directly.
|
||
//
|
||
|
||
ret = RegQueryValueExA(hKey,
|
||
sz,
|
||
lpReserved,
|
||
lpType,
|
||
lpData,
|
||
lpcbData);
|
||
|
||
}
|
||
}
|
||
|
||
Exit:
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
|
||
|
||
ATOM
|
||
WINAPI
|
||
RegisterClassX(
|
||
CONST WNDCLASSW *lpWndClass)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("RegisterClass\n");
|
||
#endif
|
||
|
||
WNDCLASSA wc;
|
||
ATOM ret;
|
||
BOOL fAtom = FALSE;
|
||
|
||
|
||
memcpy(&wc, lpWndClass, sizeof(WNDCLASS));
|
||
|
||
wc.lpszMenuName = Convert(lpWndClass->lpszMenuName);
|
||
if (wc.lpszMenuName==ERR)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
if (HIWORD(lpWndClass->lpszClassName) == 0)
|
||
{
|
||
wc.lpszClassName = (LPSTR) lpWndClass->lpszClassName;
|
||
fAtom = TRUE;
|
||
}
|
||
else
|
||
{
|
||
wc.lpszClassName = Convert(lpWndClass->lpszClassName);
|
||
if (wc.lpszClassName==ERR)
|
||
{
|
||
if ((LPSTR) wc.lpszMenuName)
|
||
delete (LPSTR) wc.lpszMenuName;
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
ret = RegisterClassA(&wc);
|
||
if ((LPSTR) wc.lpszMenuName)
|
||
delete (LPSTR) wc.lpszMenuName;
|
||
if (!fAtom) delete (LPSTR) wc.lpszClassName;
|
||
return ret;
|
||
}
|
||
|
||
BOOL
|
||
WINAPI
|
||
UnregisterClassX(
|
||
LPCWSTR lpClassName,
|
||
HINSTANCE hInstance)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("UnregisterClass\n");
|
||
#endif
|
||
|
||
LPSTR sz;
|
||
BOOL ret;
|
||
BOOL fAtom = FALSE;
|
||
|
||
if (HIWORD(lpClassName) == 0)
|
||
{
|
||
sz = (LPSTR) lpClassName;
|
||
fAtom = TRUE;
|
||
}
|
||
else
|
||
{
|
||
sz = Convert(lpClassName);
|
||
if (sz == ERR)
|
||
return FALSE;
|
||
}
|
||
|
||
ret = UnregisterClassA(sz, hInstance);
|
||
if (!fAtom) delete sz;
|
||
return ret;
|
||
}
|
||
|
||
HANDLE
|
||
WINAPI
|
||
GetPropX(
|
||
HWND hWnd,
|
||
LPCWSTR lpString)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("GetProp\n");
|
||
#endif
|
||
|
||
HANDLE ret;
|
||
LPSTR sz;
|
||
BOOL fAtom = FALSE;
|
||
|
||
if (HIWORD(lpString)==0)
|
||
{
|
||
fAtom = TRUE;
|
||
sz = (LPSTR) lpString;
|
||
}
|
||
else
|
||
{
|
||
sz = Convert(lpString);
|
||
if (sz == ERR)
|
||
return NULL;
|
||
}
|
||
|
||
ret = GetPropA(hWnd, sz);
|
||
if (!fAtom) delete sz;
|
||
return ret;
|
||
}
|
||
|
||
|
||
BOOL
|
||
WINAPI
|
||
SetPropX(
|
||
HWND hWnd,
|
||
LPCWSTR lpString,
|
||
HANDLE hData)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("SetProp\n");
|
||
#endif
|
||
|
||
BOOL ret;
|
||
LPSTR sz;
|
||
BOOL fAtom = FALSE;
|
||
|
||
if (HIWORD(lpString)==0)
|
||
{
|
||
sz = (LPSTR) lpString;
|
||
fAtom = TRUE;
|
||
}
|
||
else
|
||
{
|
||
sz = Convert(lpString);
|
||
if (sz == ERR)
|
||
return NULL;
|
||
}
|
||
|
||
ret = SetPropA(hWnd, sz, hData);
|
||
if (!fAtom) delete sz;
|
||
return ret;
|
||
}
|
||
|
||
|
||
HANDLE
|
||
WINAPI
|
||
RemovePropX(
|
||
HWND hWnd,
|
||
LPCWSTR lpString)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("RemoveProp\n");
|
||
#endif
|
||
|
||
HANDLE ret;
|
||
LPSTR sz;
|
||
BOOL fAtom = FALSE;
|
||
|
||
if (HIWORD(lpString)==0)
|
||
{
|
||
sz = (LPSTR) lpString;
|
||
fAtom = TRUE;
|
||
}
|
||
else
|
||
{
|
||
sz = Convert(lpString);
|
||
if (sz == ERR)
|
||
return NULL;
|
||
}
|
||
|
||
ret = RemovePropA(hWnd, sz);
|
||
if (!fAtom) delete sz;
|
||
return ret;
|
||
}
|
||
|
||
|
||
UINT
|
||
WINAPI
|
||
GetProfileIntX(
|
||
LPCWSTR lpAppName,
|
||
LPCWSTR lpKeyName,
|
||
INT nDefault
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("GetProfileInt\n");
|
||
#endif
|
||
|
||
LPSTR szApp;
|
||
LPSTR szKey;
|
||
UINT ret;
|
||
|
||
szApp = Convert(lpAppName);
|
||
if (szApp==ERR)
|
||
{
|
||
return nDefault;
|
||
}
|
||
|
||
szKey = Convert(lpKeyName);
|
||
if (szApp==ERR)
|
||
{
|
||
if (szApp)
|
||
delete szApp;
|
||
return nDefault;
|
||
}
|
||
|
||
ret = GetProfileIntA(szApp, szKey, nDefault);
|
||
if (szApp)
|
||
delete szApp;
|
||
if (szKey)
|
||
delete szKey;
|
||
return ret;
|
||
}
|
||
|
||
ATOM
|
||
WINAPI
|
||
GlobalAddAtomX(
|
||
LPCWSTR lpString
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("GlobalAddAtom\n");
|
||
#endif
|
||
|
||
ATOM ret;
|
||
LPSTR sz;
|
||
|
||
sz = Convert(lpString);
|
||
if (sz==ERR)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
ret = GlobalAddAtomA(sz);
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
UINT
|
||
WINAPI
|
||
GlobalGetAtomNameX(
|
||
ATOM nAtom,
|
||
LPWSTR pwszBuffer,
|
||
int nSize
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("GlobalGetAtomName\n");
|
||
#endif
|
||
|
||
LPSTR sz;
|
||
UINT ret;
|
||
|
||
sz = new CHAR[nSize];
|
||
if (sz == NULL)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
ret = GlobalGetAtomNameA(nAtom, sz, nSize);
|
||
if (ret)
|
||
{
|
||
AnsiToUnicode(pwszBuffer, sz, lstrlenA(sz) + 1);
|
||
}
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
|
||
DWORD
|
||
WINAPI
|
||
GetModuleFileNameX(
|
||
HINSTANCE hModule,
|
||
LPWSTR pwszFilename,
|
||
DWORD nSize
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("GetModuleFileName\n");
|
||
#endif
|
||
|
||
LPSTR sz;
|
||
DWORD ret;
|
||
|
||
sz = new CHAR[nSize];
|
||
if (sz == NULL)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
ret = GetModuleFileNameA(hModule, sz, nSize);
|
||
if (ret)
|
||
{
|
||
AnsiToUnicode(pwszFilename, sz, lstrlenA(sz) + 1);
|
||
}
|
||
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
|
||
LPWSTR
|
||
WINAPI
|
||
CharPrevX(
|
||
LPCWSTR lpszStart,
|
||
LPCWSTR lpszCurrent)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("CharPrev\n");
|
||
#endif
|
||
|
||
if (lpszCurrent == lpszStart)
|
||
{
|
||
return (LPWSTR) lpszStart;
|
||
}
|
||
else
|
||
{
|
||
return (LPWSTR) lpszCurrent - 1;
|
||
}
|
||
}
|
||
|
||
HFONT WINAPI CreateFontX(int a, int b, int c, int d, int e, DWORD f,
|
||
DWORD g, DWORD h, DWORD i, DWORD j, DWORD k,
|
||
DWORD l, DWORD m, LPCWSTR pwsz)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("CreateFont\n");
|
||
#endif
|
||
|
||
LPSTR sz;
|
||
HFONT ret;
|
||
|
||
sz = Convert(pwsz);
|
||
if (sz == ERR)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
ret = CreateFontA(a,b,c,d,e,f,g,h,i,j,k,l,m,sz);
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
|
||
HINSTANCE
|
||
WINAPI
|
||
LoadLibraryX(
|
||
LPCWSTR pwszFileName
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("LoadLibrary\n");
|
||
#endif
|
||
|
||
HINSTANCE ret;
|
||
LPSTR sz;
|
||
|
||
sz = Convert(pwszFileName);
|
||
if (sz == ERR)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
ret = LoadLibraryA(sz);
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
|
||
HMODULE
|
||
WINAPI
|
||
LoadLibraryExX(
|
||
LPCWSTR lpLibFileName,
|
||
HANDLE hFile,
|
||
DWORD dwFlags
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("LoadLibrary\n");
|
||
#endif
|
||
|
||
HINSTANCE ret;
|
||
LPSTR sz;
|
||
|
||
sz = ConvertOem(lpLibFileName);
|
||
if (sz == ERR)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
ret = LoadLibraryExA(sz, hFile, dwFlags);
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
|
||
|
||
LONG
|
||
APIENTRY
|
||
RegDeleteKeyX(
|
||
HKEY hKey,
|
||
LPCWSTR pwszSubKey
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("RegDeleteKey\n");
|
||
#endif
|
||
|
||
LONG ret;
|
||
LPSTR sz;
|
||
|
||
sz = Convert(pwszSubKey);
|
||
if (sz == ERR)
|
||
{
|
||
return ERROR_OUTOFMEMORY;
|
||
}
|
||
|
||
ret = RegDeleteKeyA(hKey, sz);
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
BOOL
|
||
APIENTRY
|
||
CreateProcessX(
|
||
LPCWSTR lpApplicationName,
|
||
LPWSTR lpCommandLine,
|
||
LPSECURITY_ATTRIBUTES lpProcessAttributes,
|
||
LPSECURITY_ATTRIBUTES lpThreadAttributes,
|
||
BOOL bInheritHandles,
|
||
DWORD dwCreationFlags,
|
||
LPVOID lpEnvironment,
|
||
LPCWSTR lpCurrentDirectory,
|
||
LPSTARTUPINFOW lpStartupInfo,
|
||
LPPROCESS_INFORMATION lpProcessInformation
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("CreateProcess\n");
|
||
#endif
|
||
|
||
STARTUPINFOA si;
|
||
BOOL ret = FALSE;
|
||
LPSTR szApp = NULL;
|
||
LPSTR szCommand = NULL;
|
||
LPSTR szDir = NULL;
|
||
|
||
memcpy(&si, lpStartupInfo, sizeof(STARTUPINFO));
|
||
|
||
si.lpTitle = NULL;
|
||
|
||
si.lpDesktop = Convert(lpStartupInfo->lpDesktop);
|
||
if (si.lpDesktop == ERR)
|
||
{
|
||
si.lpDesktop = NULL;
|
||
goto Error;
|
||
}
|
||
si.lpTitle = Convert(lpStartupInfo->lpTitle);
|
||
if (si.lpTitle == ERR)
|
||
{
|
||
si.lpTitle = NULL;
|
||
goto Error;
|
||
}
|
||
|
||
szApp = Convert(lpApplicationName);
|
||
if (szApp == ERR)
|
||
{
|
||
szApp = NULL;
|
||
goto Error;
|
||
}
|
||
szCommand = ConvertOem(lpCommandLine);
|
||
if (szCommand == ERR)
|
||
{
|
||
szCommand = NULL;
|
||
goto Error;
|
||
}
|
||
szDir = Convert(lpCurrentDirectory);
|
||
if (szDir == ERR)
|
||
{
|
||
szDir = NULL;
|
||
goto Error;
|
||
}
|
||
|
||
ret = CreateProcessA(szApp, szCommand, lpProcessAttributes,
|
||
lpThreadAttributes, bInheritHandles, dwCreationFlags,
|
||
lpEnvironment, szDir, &si, lpProcessInformation);
|
||
|
||
Error:
|
||
if (si.lpDesktop)
|
||
delete si.lpDesktop;
|
||
if (si.lpTitle)
|
||
delete si.lpTitle;
|
||
|
||
if (szApp)
|
||
delete szApp;
|
||
if (szCommand)
|
||
delete szCommand;
|
||
if (szDir)
|
||
delete szDir;
|
||
|
||
return ret;
|
||
}
|
||
|
||
LONG
|
||
APIENTRY
|
||
RegEnumKeyExX(
|
||
HKEY hKey,
|
||
DWORD dwIndex,
|
||
LPWSTR lpName,
|
||
LPDWORD lpcbName,
|
||
LPDWORD lpReserved,
|
||
LPWSTR lpClass,
|
||
LPDWORD lpcbClass,
|
||
PFILETIME lpftLastWriteTime
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("RegEnumKeyEx\n");
|
||
#endif
|
||
|
||
LPSTR szName;
|
||
LPSTR szClass = NULL;
|
||
LONG ret = ERROR_OUTOFMEMORY;
|
||
|
||
szName = new CHAR[*lpcbName];
|
||
if (szName == NULL)
|
||
goto Exit;
|
||
|
||
if (lpClass != NULL)
|
||
{
|
||
szClass = new CHAR[*lpcbClass + 1];
|
||
if (szName == NULL)
|
||
goto Exit;
|
||
}
|
||
|
||
//
|
||
// Return lengths do not include zero char.
|
||
//
|
||
ret = RegEnumKeyExA(hKey, dwIndex, szName, lpcbName, lpReserved,
|
||
szClass, lpcbClass, lpftLastWriteTime);
|
||
|
||
if (ret == ERROR_SUCCESS)
|
||
{
|
||
AnsiToUnicode(lpName, szName, *lpcbName + 1);
|
||
|
||
if (szClass)
|
||
{
|
||
AnsiToUnicode(lpClass, szClass, *lpcbClass + 1);
|
||
}
|
||
}
|
||
|
||
Exit:
|
||
return ret;
|
||
}
|
||
|
||
BOOL
|
||
WINAPI
|
||
AppendMenuX(
|
||
HMENU hMenu,
|
||
UINT uFlags,
|
||
UINT uIDnewItem,
|
||
LPCWSTR lpnewItem
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("AppendMenu\n");
|
||
#endif
|
||
|
||
BOOL ret;
|
||
LPSTR sz;
|
||
|
||
if (uFlags == MF_STRING)
|
||
{
|
||
sz = Convert(lpnewItem);
|
||
if (sz==ERR)
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
sz = (LPSTR) lpnewItem;
|
||
}
|
||
|
||
ret = AppendMenuA(hMenu, uFlags, uIDnewItem, sz);
|
||
|
||
if (uFlags == MF_STRING)
|
||
{
|
||
if (sz)
|
||
delete sz;
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
HANDLE
|
||
WINAPI
|
||
OpenEventX(
|
||
DWORD dwDesiredAccess,
|
||
BOOL bInheritHandle,
|
||
LPCWSTR lpName
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("OpenEvent\n");
|
||
#endif
|
||
|
||
LPSTR sz;
|
||
HANDLE ret;
|
||
|
||
sz = Convert(lpName);
|
||
if (sz == ERR)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
ret = OpenEventA(dwDesiredAccess, bInheritHandle, sz);
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
HANDLE
|
||
WINAPI
|
||
CreateEventX(
|
||
LPSECURITY_ATTRIBUTES lpEventAttributes,
|
||
BOOL bManualReset,
|
||
BOOL bInitialState,
|
||
LPCWSTR lpName
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("CreateEvent\n");
|
||
#endif
|
||
|
||
LPSTR sz;
|
||
HANDLE ret;
|
||
|
||
sz = Convert(lpName);
|
||
if (sz == ERR)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
ret = CreateEventA(lpEventAttributes, bManualReset, bInitialState, sz);
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
UINT
|
||
WINAPI
|
||
GetDriveTypeX(
|
||
LPCWSTR lpRootPathName
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("GetDriveType\n");
|
||
#endif
|
||
|
||
LPSTR sz;
|
||
UINT ret;
|
||
|
||
sz = Convert(lpRootPathName);
|
||
if (sz == ERR)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
ret = GetDriveTypeA(sz);
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
DWORD
|
||
WINAPI
|
||
GetFileAttributesX(
|
||
LPCWSTR lpFileName
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("GetFileAttributes\n");
|
||
#endif
|
||
|
||
LPSTR sz;
|
||
DWORD ret;
|
||
|
||
sz = ConvertOem(lpFileName);
|
||
if (sz == ERR)
|
||
return 0xFFFFFFFF;
|
||
|
||
ret = GetFileAttributesA(sz);
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
LONG
|
||
APIENTRY
|
||
RegEnumKeyX(
|
||
HKEY hKey,
|
||
DWORD dwIndex,
|
||
LPWSTR lpName,
|
||
DWORD cbName
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("RegEnumKey\n");
|
||
#endif
|
||
|
||
CHAR sz[MAX_PATH+1];
|
||
LONG ret;
|
||
|
||
//
|
||
// Return lengths do not include zero char.
|
||
//
|
||
ret = RegEnumKeyA(hKey, dwIndex, sz, cbName);
|
||
if (ret == ERROR_SUCCESS)
|
||
{
|
||
AnsiToUnicode(lpName, sz, lstrlenA(sz) + 1);
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
HFINDFILE
|
||
WINAPI
|
||
FindFirstFileX(
|
||
LPCWSTR lpFileName,
|
||
LPWIN32_FIND_DATAW pwszFd
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("FindFirstFile\n");
|
||
#endif
|
||
|
||
WIN32_FIND_DATAA fd;
|
||
CHAR sz[MAX_PATH * 2];
|
||
HFINDFILE ret;
|
||
int len = wcslen(lpFileName) + 1;
|
||
|
||
UnicodeToAnsiOem(sz, lpFileName, sizeof(sz));
|
||
ret = FindFirstFileA(sz, &fd);
|
||
if (ret != INVALID_HANDLE_VALUE)
|
||
{
|
||
memcpy(pwszFd, &fd, sizeof(FILETIME)*3 + sizeof(DWORD)*5);
|
||
AnsiToUnicodeOem(pwszFd->cFileName, fd.cFileName,
|
||
lstrlenA(fd.cFileName) + 1);
|
||
AnsiToUnicodeOem(pwszFd->cAlternateFileName, fd.cAlternateFileName,
|
||
14);
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
//+---------------------------------------------------------------------------
|
||
//
|
||
// Function: wsprintfX
|
||
//
|
||
// Synopsis: Nightmare string function
|
||
//
|
||
// Arguments: [pwszOut] --
|
||
// [pwszFormat] --
|
||
// [...] --
|
||
//
|
||
// Returns:
|
||
//
|
||
// History: 1-06-94 ErikGav Created
|
||
//
|
||
// Notes: If you're reading this, you're probably having a problem with
|
||
// this function. Make sure that your "%s" in the format string
|
||
// says "%ws" if you are passing wide strings.
|
||
//
|
||
// %s on NT means "wide string"
|
||
// %s on Chicago means "ANSI string"
|
||
//
|
||
//----------------------------------------------------------------------------
|
||
|
||
int WINAPIV wsprintfX(LPWSTR pwszOut, LPCWSTR pwszFormat, ...)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("wsprintf\n");
|
||
#endif
|
||
|
||
LPSTR szFormat;
|
||
LPWSTR pwszTemp = NULL;
|
||
int i = 0;
|
||
|
||
// Convert the format string over
|
||
|
||
szFormat = Convert(pwszFormat);
|
||
if (szFormat == ERR)
|
||
{
|
||
szFormat = NULL;
|
||
goto Exit;
|
||
}
|
||
|
||
// magic voodoo follows:
|
||
//
|
||
// 1. Call wvsprintf passing the varargs
|
||
// 2. Use the pwszOut as a temp buffer to hold the ANSI output
|
||
// 3. Save the returned characters
|
||
|
||
i = wvsprintfA((LPSTR) pwszOut, szFormat,
|
||
(LPSTR) ((BYTE*)&pwszFormat) + sizeof(pwszFormat));
|
||
|
||
// allocate a buffer for the Ansi to Unicode conversion
|
||
|
||
pwszTemp = new WCHAR[i+1];
|
||
|
||
// convert the string
|
||
|
||
AnsiToUnicode(pwszTemp, (LPSTR) pwszOut, i+1);
|
||
|
||
// copy it to the out buffer
|
||
|
||
wcsncpy(pwszOut, pwszTemp, i+1);
|
||
|
||
Exit:
|
||
if (pwszTemp)
|
||
delete pwszTemp;
|
||
if (szFormat)
|
||
delete szFormat;
|
||
return i;
|
||
}
|
||
|
||
BOOL
|
||
WINAPI
|
||
GetComputerNameX(
|
||
LPWSTR pwszName,
|
||
LPDWORD lpcchBuffer
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("GetComputerName\n");
|
||
#endif
|
||
|
||
BOOL ret;
|
||
LPSTR sz;
|
||
|
||
sz = new CHAR[*lpcchBuffer];
|
||
ret = GetComputerNameA(sz, lpcchBuffer);
|
||
|
||
if (ret)
|
||
{
|
||
AnsiToUnicode(pwszName, sz, *lpcchBuffer);
|
||
}
|
||
|
||
if (sz)
|
||
delete sz;
|
||
return ret;
|
||
}
|
||
|
||
DWORD
|
||
WINAPI
|
||
GetFullPathNameX(
|
||
LPCWSTR lpFileName,
|
||
DWORD cchBuffer,
|
||
LPWSTR lpPathBuffer,
|
||
LPWSTR *lppFilePart
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("GetFullPathName\n");
|
||
#endif
|
||
|
||
LPSTR szFileName;
|
||
CHAR szPathBuffer[MAX_PATH];
|
||
LPSTR szFilePart;
|
||
DWORD ret;
|
||
|
||
|
||
szFileName = ConvertOem(lpFileName);
|
||
if (szFileName == ERR)
|
||
return 0;
|
||
|
||
ret = GetFullPathNameA(szFileName, cchBuffer, szPathBuffer, &szFilePart);
|
||
|
||
AnsiToUnicode(lpPathBuffer, szPathBuffer, cchBuffer);
|
||
|
||
*lppFilePart = lpPathBuffer + (szFilePart - szPathBuffer);
|
||
|
||
if (szFileName)
|
||
delete szFileName;
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
DWORD
|
||
WINAPI
|
||
GetShortPathNameX(
|
||
LPCWSTR lpszFullPath,
|
||
LPWSTR lpszShortPath,
|
||
DWORD cchBuffer
|
||
)
|
||
{
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("GetShortPathName\n");
|
||
#endif
|
||
|
||
LPSTR szFullPath;
|
||
CHAR szShortBuffer[MAX_PATH];
|
||
DWORD ret;
|
||
|
||
|
||
szFullPath = Convert(lpszFullPath);
|
||
if (szFullPath == ERR)
|
||
return 0;
|
||
|
||
if (lpszShortPath == NULL)
|
||
{
|
||
ret = GetShortPathNameA(szFullPath, NULL, cchBuffer);
|
||
}
|
||
else
|
||
{
|
||
ret = GetShortPathNameA(szFullPath, szShortBuffer, sizeof(szShortBuffer));
|
||
|
||
//
|
||
// Only convert the actual data, not the whole buffer.
|
||
//
|
||
if (cchBuffer > ret + 1)
|
||
cchBuffer = ret + 1;
|
||
|
||
AnsiToUnicode(lpszShortPath, szShortBuffer, cchBuffer);
|
||
}
|
||
|
||
delete szFullPath;
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
DWORD
|
||
WINAPI
|
||
SearchPathX(
|
||
LPCWSTR lpPath,
|
||
LPCWSTR lpFileName,
|
||
LPCWSTR lpExtension,
|
||
DWORD nBufferLength,
|
||
LPWSTR lpBuffer,
|
||
LPWSTR *lpFilePart
|
||
)
|
||
{
|
||
LPSTR lpszFileName;
|
||
CHAR szBuffer[MAX_PATH];
|
||
DWORD ret;
|
||
|
||
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("SearchPath\n");
|
||
#endif
|
||
|
||
lpszFileName = Convert(lpFileName);
|
||
if (lpszFileName == ERR)
|
||
return 0;
|
||
|
||
ret = SearchPathA(NULL, lpszFileName, NULL, sizeof(szBuffer), szBuffer, NULL);
|
||
|
||
AnsiToUnicode(lpBuffer, szBuffer, lstrlenA(szBuffer) + 1);
|
||
|
||
delete lpszFileName;
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
ATOM
|
||
WINAPI
|
||
GlobalFindAtomX(
|
||
LPCWSTR lpString
|
||
)
|
||
{
|
||
LPSTR lpszString;
|
||
ATOM retAtom;
|
||
|
||
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("GlobalFindAtom\n");
|
||
#endif
|
||
|
||
lpszString = Convert(lpString);
|
||
if (lpszString == ERR)
|
||
return 0;
|
||
|
||
retAtom = GlobalFindAtomA(lpszString);
|
||
|
||
delete lpszString;
|
||
|
||
return retAtom;
|
||
}
|
||
|
||
|
||
int
|
||
WINAPI
|
||
GetClassNameX(
|
||
HWND hWnd,
|
||
LPWSTR lpClassName,
|
||
int nMaxCount)
|
||
{
|
||
LPSTR lpszClassName;
|
||
int ret;
|
||
|
||
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("GetClassName\n");
|
||
#endif
|
||
|
||
lpszClassName = Convert(lpClassName);
|
||
if (lpszClassName == ERR)
|
||
return 0;
|
||
|
||
ret = GetClassNameA(hWnd, lpszClassName, nMaxCount);
|
||
|
||
delete lpszClassName;
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
int
|
||
WINAPI
|
||
lstrlenX(LPCWSTR lpString)
|
||
{
|
||
return wcslen(lpString);
|
||
}
|
||
|
||
LPWSTR
|
||
WINAPI
|
||
lstrcatX(
|
||
LPWSTR lpString1,
|
||
LPCWSTR lpString2)
|
||
{
|
||
return wcscat(lpString1, lpString2);
|
||
}
|
||
|
||
int
|
||
WINAPI
|
||
lstrcmpX(
|
||
LPCWSTR lpString1,
|
||
LPCWSTR lpString2
|
||
)
|
||
{
|
||
return wcscmp(lpString1, lpString2);
|
||
}
|
||
|
||
int
|
||
WINAPI
|
||
lstrcmpiX(
|
||
LPCWSTR lpString1,
|
||
LPCWSTR lpString2
|
||
)
|
||
{
|
||
return _wcsicmp(lpString1, lpString2);
|
||
}
|
||
|
||
LPWSTR
|
||
WINAPI
|
||
lstrcpyX(
|
||
LPWSTR lpString1,
|
||
LPCWSTR lpString2
|
||
)
|
||
{
|
||
return wcscpy(lpString1, lpString2);
|
||
}
|
||
|
||
|
||
|
||
HANDLE
|
||
WINAPI
|
||
CreateFileMappingX(
|
||
HANDLE hFile,
|
||
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
|
||
DWORD flProtect,
|
||
DWORD dwMaximumSizeHigh,
|
||
DWORD dwMaximumSizeLow,
|
||
LPCWSTR lpName
|
||
)
|
||
{
|
||
LPSTR lpszAName;
|
||
HANDLE ret;
|
||
|
||
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("CreateFileMapping\n");
|
||
#endif
|
||
|
||
lpszAName = Convert(lpName);
|
||
|
||
if (lpszAName == ERR)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
ret = CreateFileMappingA(
|
||
hFile,
|
||
lpFileMappingAttributes,
|
||
flProtect,
|
||
dwMaximumSizeHigh,
|
||
dwMaximumSizeLow,
|
||
lpszAName);
|
||
|
||
delete lpszAName;
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
HANDLE
|
||
WINAPI
|
||
OpenFileMappingX(
|
||
DWORD dwDesiredAccess,
|
||
BOOL bInheritHandle,
|
||
LPCWSTR lpName
|
||
)
|
||
{
|
||
LPSTR lpszAName;
|
||
HANDLE ret;
|
||
|
||
|
||
#ifdef DEBUG_OUTPUT
|
||
OutputDebugString("CreateFileMapping\n");
|
||
#endif
|
||
|
||
lpszAName = Convert(lpName);
|
||
|
||
if (lpszAName == ERR)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
ret = OpenFileMappingA(
|
||
dwDesiredAccess,
|
||
bInheritHandle,
|
||
lpszAName);
|
||
|
||
delete lpszAName;
|
||
|
||
return ret;
|
||
}
|
||
|
||
#endif // CHICAGO
|
||
|