;;/*++++++++++++++++++++++++++++++++++++++++++++++++++ ;; ;; Copyright (c) 2000-2001, Microsoft Corporation All rights reserved. ;; ;; Module Name: ;; ;; unicows.tpl ;; ;; Abstract: ;; ;; The 'Template' file that drives genthnk. It contains all of the functions to ;; handle out params and such -- anything not automatable by genthnk. ;; ;; Revision History: ;; ;; 7 Nov 2000 v-michka Created. ;; ;;-------------------------------------------------*/ ; // This template is a [Code] template. It is expanded by genthnk once ; // via the -cTemplateName command-line option. Stuff inside the Begin= ; // End= section is C code or genthnk macros which are prefixed by an 'at' char. ; // [Code] TemplateName=UnicodeWrappers Begin= @NoFormat( /*++ Copyright (c) 2000-2001, Microsoft Corporation All rights reserved. Module Name: Win9xU.c (Windows 9x Unicode wrapper functions) Abstract: Auto-generated file that contains the thunks. WARNING: Do not edit! This file is auto-generated by getthnk. See unicows.tpl if you want to make changes. Revision History: 7 Nov 2000 v-michka Created. --*/ #include "precomp.h" // work around thick-skulled genthnk. It wants ApiName to expand to the // name of the original Ansi API. We want to call the Ansi API by // appending "A". So... from makefile.inc we generate a bunch of #defines // of the form: // #define AddAtomWA AddAtomA // then from the .tpl file we can use ApiNameA to generate AddAtomWA for // the AddAtomW API thunk and get it expanded to the right thing. #include "fixaw.h" // A few globals: set on startup and used everywhere thereafter // We init these vars with some nice defaults; they *will* be fixed later UINT g_acp = CP_ACP; // CP_ACP; it is faster to call with the actual cpg than the CP_ACP const UINT g_oemcp = CP_OEMCP; // CP_OEMCP; it is faster to call with the actual cpg than the CP_OEMCP const UINT g_mcs = 2; // The maximum character size (in bytes) of a character on CP_ACP DWORD g_dwVersion = 0x80000001; // The return from GetVersion, used many places // VSANSI comments: // Static buffers for GetClassInfo[Ex] to return the classname // and menuname in Unicode, when running on an Ansi system. // The contract of GetClassInfo is that it returns const ptrs // back to the class name and menu name. Unfortuntely, this // prevents us from translating these back from Ansi to Unicode, // without having some static buffers to use. Since we strongly // believe that the only people calling this are doing it just to // see if it succeeds or not, so they know whether the class is // already registered, we've willing to just have one set of // static buffers to use. // CAUTION: this will work as long as two threads don't call // GetClassInfo[Ex] at the same time! static WCHAR m_wzMenuName[256]; static WCHAR m_wzClassName[256]; // Similar buffers for the strings returned by GetStartupInfo // Note that these two buffers are not really hacks; on NT, there // is a permanent buffer set aside for the ANSI version of this // call, per process. So we are no worse for doing the same thing // here for Win9x. static WCHAR m_wzDesktop[256]; static WCHAR m_wzTitle[256]; // The Ver* APIs are not very helpful to us since we have no place // from which to alloc pointers to Unicode strings. Therefore, we // will add a small area to the front of any GetFileVersionInfoSize // call that we can use. Note that this means that the calls to // VerQueryValue will erase the data from earlier calls, but we can't // pull the memory out of our butt, either. #define VERINFO_BUFFER (MAX_PATH * sizeof(WCHAR)) // For FormatMessageW: // We will support a max of 99 arguments, up to 1023 cch per arg #define MAXINSERTS 99 #define CCHMAXPERINSERT 1023 // Need a few intrinsics #pragma intrinsic (strlen, strcmp, memcpy) // We have no header file, so lets add forward declares for any Godot // function that is used by other functions BOOL __stdcall GodotExtTextOutW(HDC hdc,int X,int Y,UINT fuOptions,const LPRECT lprc,LPCWSTR lpString,UINT cbCount,const PINT lpDx); HRSRC __stdcall GodotFindResourceExW(HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage); BOOL __stdcall GodotGetCharWidthW(HDC hdc,UINT iFirstChar,UINT iLastChar,LPINT lpBuffer); BOOL __stdcall GodotGetMonitorInfoW(HMONITOR hMonitor, LPMONITORINFO lpmi); BOOL __stdcall GodotIsClipboardFormatAvailable(UINT format); int __stdcall GodotwvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, va_list arglist); // Functions we dynamically link to since they might not exist on all // platforms that Godot runs upon. First the typdefs, then the function // pointers themselves will follow. typedef LONG (__stdcall *PFNcdsea) (LPCSTR, LPDEVMODEA, HWND, DWORD, LPVOID); typedef BOOL (__stdcall *PFNcfea) (LPCSTR, LPCSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD); typedef HRESULT (__stdcall *PFNcsapa) (HWND, LPCSTR, LONG, const IID *, void **); typedef HANDLE (__stdcall *PFNcwta) (LPSECURITY_ATTRIBUTES, BOOL, LPCSTR); typedef BOOL (__stdcall *PFNeciea) (CALINFO_ENUMPROCEXA, LCID, CALID, CALTYPE); typedef BOOL (__stdcall *PFNedfea) (DATEFMT_ENUMPROCEXA, LCID, DWORD); typedef BOOL (__stdcall *PFNedda) (LPCSTR, DWORD, PDISPLAY_DEVICEA, DWORD); typedef BOOL (__stdcall *PFNedsea) (LPCSTR, DWORD, LPDEVMODEA, DWORD); typedef BOOL (__stdcall *PFNgatia) (HWND, int, PALTTABINFO, LPSTR, UINT); typedef BOOL (__stdcall *PFNgcia) (LCID, CALID, CALTYPE, LPSTR, int, LPDWORD); typedef BOOL (__stdcall *PFNgciea) (UINT, DWORD, LPCPINFOEXA); typedef BOOL (__stdcall *PFNgchpa) (LPHW_PROFILE_INFOA); typedef BOOL (__stdcall *PFNgdfsea) (LPCSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER); typedef BOOL (__stdcall *PFNgfnaea) (LPCSTR, GET_FILEEX_INFO_LEVELS, LPVOID); typedef BOOL (__stdcall *PFNglpna) (LPCSTR, LPSTR, DWORD); typedef BOOL (__stdcall *PFNgmia) (HMONITOR, LPMONITORINFO); typedef HRESULT (__stdcall *PFNrgta) (DWORD, LPSTR, UINT); typedef HRESULT (__stdcall *PFNgsta) (DWORD, LPSTR, UINT); typedef UINT (__stdcall *PFNgwmfna) (HWND, LPSTR, UINT); typedef BOOL (__stdcall *pfnIDRA) (LPCSTR, LPQOCINFO); typedef HANDLE (__stdcall *PFNowta) (DWORD, BOOL, LPCSTR); typedef DWORD (__stdcall *pfnRCN) (HRASCONN, HANDLE, DWORD); typedef DWORD (__stdcall *pfnRCPE) (HWND, LPCSTR); typedef DWORD (__stdcall *pfnRDE) (LPCSTR, LPCSTR); typedef DWORD (__stdcall *pfnRDSE) (LPCSTR, LPCSTR, DWORD); typedef DWORD (__stdcall *pfnRD) (LPRASDIALEXTENSIONS, LPCSTR, LPRASDIALPARAMSA, DWORD, LPVOID, LPHRASCONN); typedef DWORD (__stdcall *pfnREPE) (HWND, LPCSTR, LPCSTR); typedef DWORD (__stdcall *pfnREC) (struct tagRASCONNA * , LPDWORD, LPDWORD); typedef DWORD (__stdcall *pfnRED) (LPRASDEVINFOA, LPDWORD, LPDWORD); typedef DWORD (__stdcall *pfnREE) (LPCSTR, LPCSTR, LPRASENTRYNAMEA, LPDWORD, LPDWORD); typedef DWORD (__stdcall *pfnRGCS) (HRASCONN, LPRASCONNSTATUSA); typedef DWORD (__stdcall *pfnRGEDP) (LPCSTR, LPRASDIALPARAMSA, LPBOOL); typedef DWORD (__stdcall *pfnRGEP) (LPCSTR, LPCSTR, LPRASENTRYA, LPDWORD, LPBYTE, LPDWORD); typedef DWORD (__stdcall *pfnRGES) (UINT, LPSTR, DWORD); typedef DWORD (__stdcall *pfnRHU) (HRASCONN); typedef DWORD (__stdcall *pfnRRE) (LPCSTR, LPCSTR, LPCSTR); typedef DWORD (__stdcall *pfnRSEDP) (LPCSTR, LPRASDIALPARAMSA, BOOL); typedef DWORD (__stdcall *pfnRSEP) (LPCSTR, LPCSTR, LPRASENTRYA, DWORD, LPBYTE, DWORD); typedef DWORD (__stdcall *pfnRSSEP) (LPCSTR, LPCSTR, DWORD, LPRASSUBENTRYA, DWORD, LPBYTE, DWORD); typedef DWORD (__stdcall *pfnRVEN) (LPCSTR, LPCSTR); typedef HDEVNOTIFY (__stdcall *PFNrdna) (HANDLE, LPVOID, DWORD); typedef BOOL (__stdcall *PFNscia) (LCID, CALID, CALTYPE, LPCSTR); static PFNcdsea s_pfnChangeDisplaySettingsExA; static PFNcfea s_pfnCopyFileExA; static PFNcsapa s_pfnCreateStdAccessibleProxy; static PFNcwta s_pfnCreateWaitableTimerA; static PFNeciea s_pfnEnumCalendarInfoExA; static PFNedfea s_pfnEnumDateFormatsExA; static PFNedda s_pfnEnumDisplayDevicesA; static PFNedsea s_pfnEnumDisplaySettingsExA; static PFNgatia s_pfnGetAltTabInfoA; static PFNgcia s_pfnGetCalendarInfoA; static PFNgciea s_pfnGetCPInfoExA; static PFNgchpa s_pfnGetCurrentHwProfileA; static PFNgdfsea s_pfnGetDiskFreeSpaceExA; static PFNgfnaea s_pfnGetFileAttributesExA; static PFNglpna s_pfnGetLongPathNameA; static PFNgmia s_pfnGetMonitorInfoA; static PFNrgta s_pfnGetRoleTextA; static PFNgsta s_pfnGetStateTextA; static PFNgwmfna s_pfnGetWindowModuleFileNameA; static pfnIDRA s_pfnIsDestinationReachableA; static PFNowta s_pfnOpenWaitableTimerA; static pfnRCN s_pfnRasConnectionNotificationA; static pfnRCPE s_pfnRasCreatePhonebookEntryA; static pfnRDE s_pfnRasDeleteEntryA; static pfnRDSE s_pfnRasDeleteSubEntryA; static pfnRD s_pfnRasDialA; static pfnREPE s_pfnRasEditPhonebookEntryA; static pfnREC s_pfnRasEnumConnectionsA; static pfnRED s_pfnRasEnumDevicesA; static pfnREE s_pfnRasEnumEntriesA; static pfnRGCS s_pfnRasGetConnectStatusA; static pfnRGEDP s_pfnRasGetEntryDialParamsA; static pfnRGEP s_pfnRasGetEntryPropertiesA; static pfnRGES s_pfnRasGetErrorStringA; static pfnRHU s_pfnRasHangUpA; static pfnRRE s_pfnRasRenameEntryA; static pfnRSEDP s_pfnRasSetEntryDialParamsA; static pfnRSEP s_pfnRasSetEntryPropertiesA; static pfnRSSEP s_pfnRasSetSubEntryPropertiesA; static pfnRVEN s_pfnRasValidateEntryNameA; static PFNrdna s_pfnRegisterDeviceNotificationA; static PFNscia s_pfnSetCalendarInfoA; BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { // Perform actions based on the reason for calling. switch(fdwReason) { case DLL_PROCESS_ATTACH: g_tls = TlsAlloc(); if (g_tls==TLS_OUT_OF_INDEXES) { // We are gonna go no further, we NEED that slot! // CONSIDER: Let us succeeed, but maybe we could try again later? SetLastError(ERROR_MAX_THRDS_REACHED); return(FALSE); } // CONSIDER: Can't this raise a STATUS_NO_MEMORY exception? // Perhaps we need to handle this InitializeCriticalSection(&g_csThreads); InitializeCriticalSection(&g_csWnds); // Set up some global information used elsewhere. No InterlockedExchange // is needed for these globals since the code is only ever called once // per process, and calls to DllMain are serialized by the OS, anyway. g_acp = GetACP(); g_oemcp = GetOEMCP(); g_dwVersion = GetVersion(); g_mcs = CbPerChOfCpg(g_acp); break; case DLL_THREAD_ATTACH: break; case DLL_THREAD_DETACH: // Any time we get this notification, make sure // we free up our resources. If all else fails // we will get it on process close, but why not // try to get it here? UninitThread(); break; case DLL_PROCESS_DETACH: if(g_tls) { // Free up our resources, if any UninitAllThreads(); // Clean up the TLS TlsFree(g_tls); } // free up our critical sections if(&g_csThreads) DeleteCriticalSection(&g_csThreads); if(&g_csWnds) DeleteCriticalSection(&g_csWnds); break; } return TRUE; UNREFERENCED_PARAMETER(hinstDLL); UNREFERENCED_PARAMETER(lpvReserved); } @Template(ApiWrapper) End= ; // These templates are [Types] templates. They are expanded whenever ; // an API argument type matches. ; // ArgName - name of the argument [Types] TypeName=LPWSTR Also=LPCWSTR IndLevel=0 Direction=IN Locals= LPSTR @ArgNameAnsi; End= Precall= GODOT_TO_ACP_STACKALLOC(@ArgName, @ArgNameAnsi); #define @ArgName @ArgNameAnsi End= Postcall= #undef @ArgName End= ; // ; // This template is an [IFunc] template. It is expanded once for each API. ; // Macros: ; // ApiName - the name of the API ; // ArgList() - expands the contents for each argument to the API ; // ListCol - text formatting - makes a nice column ; // ArgMod - type modifier like const/volatile ; // ArgType - type of the argument ; // ArgName - name of the argument (genthnk will assign a name if the prototype didn't name the arg) ; // ArgMore() - expands iff there are more args after the current one ; // IfApiRet() - expands iff the return type of the API is non-void ; // ApiFnRet - return type of the API ; // Types() - expands any applicable parts of [Types] templates ; // IfApiCode() - expands any applicable parts of [EFunc] templates ; // [IFunc] TemplateName=ApiWrapper Begin= @ApiFnRet @ApiFnMod Godot@ApiName(@ArgList(@ListCol@ArgMod @ArgType @ArgName@ArgMore(,))) { // Begin locals @IfApiRet(@ApiFnRet RetVal;) @Types(Locals) @IfApiCode(Locals) // Begin precall @Types(Precall) @IfApiCode(Precall) // Call the 'A' version of the API @IfApiRet(RetVal=)@ApiNameA(@ArgList(@ListCol@ArgName@ArgMore(,))); // Begin postcall @Types(Postcall) @IfApiCode(Postcall) // Finished return @IfApiRet(RetVal); } End= [EFunc] TemplateName=AcquireCredentialsHandleW Begin= SECURITY_STATUS __stdcall GodotAcquireCredentialsHandleW( SEC_WCHAR SEC_FAR * pPrincipal, SEC_WCHAR SEC_FAR * pPackage, unsigned long int fCredentialUse, void * pvLogonId, void * pAuthData, SEC_GET_KEY_FN pGetKeyFn, void * pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry ) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(SEC_E_UNSUPPORTED_FUNCTION); } End= [EFunc] TemplateName=AddJobW Begin= BOOL __stdcall GodotAddJobW(HANDLE hPrinter, DWORD Level, LPBYTE pData, DWORD cbBuf, LPDWORD pcbNeeded) { // Begin locals BOOL RetVal; LPADDJOB_INFO_1A lpajia; LPADDJOB_INFO_1W lpaji; if(Level != 1) { SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } if(cbBuf == 0) SetLastError(ERROR_INVALID_USER_BUFFER); if((cbBuf == 0) || (cbBuf < (sizeof(ADDJOB_INFO_1W) + MAX_PATH * sizeof(WCHAR)))) { if(pcbNeeded) *pcbNeeded = (sizeof(ADDJOB_INFO_1W) + MAX_PATH * sizeof(WCHAR)); return(FALSE); } _STACKALLOC(sizeof(ADDJOB_INFO_1A) + (MAX_PATH * g_mcs), lpajia); if(lpajia==NULL) return(FALSE); ZeroMemory(lpajia, sizeof(ADDJOB_INFO_1A) + (MAX_PATH * g_mcs)); RetVal=AddJobA(hPrinter, Level, (LPBYTE)lpajia, cbBuf, pcbNeeded); if(RetVal) { lpaji = (LPADDJOB_INFO_1W)pData; MultiByteToWideChar(g_acp, 0, lpajia->Path, MAX_PATH, (LPWSTR)(pData + sizeof(ADDJOB_INFO_1A)), MAX_PATH); lpaji->Path = (LPWSTR)(pData + sizeof(ADDJOB_INFO_1A)); lpaji->JobId = lpajia->JobId; if(pcbNeeded) *pcbNeeded = (sizeof(ADDJOB_INFO_1W) + MAX_PATH * sizeof(WCHAR)); } // Finished return RetVal; } End= [EFunc] TemplateName=AddMonitorW Begin= BOOL __stdcall GodotAddMonitorW(LPWSTR pName, DWORD Level, LPBYTE pMonitors) { if(Level != 2) { SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } else { LPSTR pNameAnsi; MONITOR_INFO_2A mia; LPMONITOR_INFO_2W lpmi; // Begin precall GODOT_TO_ACP_STACKALLOC(pName, pNameAnsi); if(!pNameAnsi && pName) { return(FALSE); } ZeroMemory(&mia, sizeof(MONITOR_INFO_2A)); lpmi = (LPMONITOR_INFO_2W)pMonitors; GODOT_TO_ACP_STACKALLOC(lpmi->pName, mia.pName); GODOT_TO_ACP_STACKALLOC(lpmi->pEnvironment, mia.pEnvironment); GODOT_TO_ACP_STACKALLOC(lpmi->pDLLName, mia.pDLLName); if((!(mia.pName) && (lpmi->pName)) || (!(mia.pEnvironment) && (lpmi->pEnvironment)) || (!(mia.pDLLName) && (lpmi->pDLLName))) return(FALSE); return(AddMonitorA(pNameAnsi, Level, (LPBYTE)&mia)); } } End= [EFunc] TemplateName=AddPortW Begin= BOOL __stdcall GodotAddPortW(LPWSTR pName, HWND hWnd, LPWSTR pMonitorName) { BOOL RetVal = FALSE; LPSTR pNameAnsi = NULL; LPSTR pMonitorNameAnsi = NULL; ALLOCRETURN arName = GodotToAcpOnHeap(pName, &pNameAnsi); ALLOCRETURN arMonitorName = GodotToAcpOnHeap(pMonitorName, &pMonitorNameAnsi); if(arName != arFailed && arMonitorName != arFailed) RetVal = AddPortA(pNameAnsi, hWnd, pMonitorNameAnsi); if(arName==arAlloc) GodotHeapFree(pNameAnsi); if(arMonitorName==arAlloc) GodotHeapFree(pMonitorName); if(arName == arFailed || arMonitorName == arFailed) SetLastError(ERROR_OUTOFMEMORY); return RetVal; } End= [EFunc] TemplateName=AddPrinterW Begin= HANDLE __stdcall GodotAddPrinterW(LPWSTR pName, DWORD Level, LPBYTE pPrinter) { LPSTR pNameAnsi; GODOT_TO_ACP_STACKALLOC(pName, pNameAnsi); if(pNameAnsi==NULL && pName != NULL) { return(FALSE); } return(AddPrinterA(pNameAnsi, Level, pPrinter)); } End= [EFunc] TemplateName=AddPrinterDriverW Begin= BOOL __stdcall GodotAddPrinterDriverW(LPWSTR pName, DWORD Level, LPBYTE pDriverInfo) { LPSTR pNameAnsi; GODOT_TO_ACP_STACKALLOC(pName, pNameAnsi); if(!pNameAnsi && pName) return(FALSE); return(AddPrinterDriverA(pNameAnsi, Level, pDriverInfo)); } End= [EFunc] TemplateName=AddPrintProcessorW Begin= BOOL __stdcall GodotAddPrintProcessorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPathName, LPWSTR pPrintProcessorName) { BOOL RetVal = FALSE; LPSTR pNameAnsi = NULL; LPSTR pEnvironmentAnsi = NULL; LPSTR pPathNameAnsi = NULL; LPSTR pPrintProcessorNameAnsi = NULL; ALLOCRETURN arName = GodotToAcpOnHeap(pName, &pNameAnsi); ALLOCRETURN arEnvironmentName = GodotToAcpOnHeap(pEnvironment, &pEnvironmentAnsi); ALLOCRETURN arPathName = GodotToAcpOnHeap(pPathName, &pPathNameAnsi); ALLOCRETURN arProcessorName = GodotToAcpOnHeap(pPrintProcessorName, &pPrintProcessorNameAnsi); if(arName != arFailed && arEnvironmentName != arFailed && arPathName != arFailed && arProcessorName != arFailed) RetVal = AddPrintProcessorA(pNameAnsi, pEnvironmentAnsi, pPathNameAnsi, pPrintProcessorNameAnsi); if(arName==arAlloc) GodotHeapFree(pNameAnsi); if(arEnvironmentName==arAlloc) GodotHeapFree(pEnvironmentAnsi); if(arPathName==arAlloc) GodotHeapFree(pPathNameAnsi); if(arProcessorName==arAlloc) GodotHeapFree(pPrintProcessorNameAnsi); if(arName == arFailed || arEnvironmentName == arFailed || arPathName == arFailed || arProcessorName == arFailed) SetLastError(ERROR_OUTOFMEMORY); return(RetVal); } End= [EFunc] TemplateName=AddPrintProviderW Begin= BOOL __stdcall GodotAddPrintProvidorW(LPWSTR pName, DWORD level, LPBYTE pProvidorInfo) { LPSTR pNameAnsi; PROVIDOR_INFO_1A pia; GODOT_TO_ACP_STACKALLOC(pName, pNameAnsi); GODOT_TO_ACP_STACKALLOC(((PROVIDOR_INFO_1)pProviderInfo)->pName, pia.pName); GODOT_TO_ACP_STACKALLOC(((PROVIDOR_INFO_1)pProviderInfo)->pEnvironment, pia.pEnvironment); GODOT_TO_ACP_STACKALLOC(((PROVIDOR_INFO_1)pProviderInfo)->pDLLName, pia.pDLLName); if((!pNameAnsi && pName) || (!(pia.pName) && ((PROVIDOR_INFO_1)pProviderInfo)->pName) || (!(pia.pEnvironment) && ((PROVIDOR_INFO_1)pProviderInfo)->pEnvironment) || (!(pia.pDLLName) && ((PROVIDOR_INFO_1)pProviderInfo)->pDLLName)) return(FALSE); return(AddPrintProvidorA(pNameAnsi, level, (LPBYTE)&pia)); } End= [EFunc] TemplateName=AdvancedDocumentPropertiesW Begin= LONG __stdcall GodotAdvancedDocumentPropertiesW(HWND hWnd, HANDLE hPrinter, LPWSTR pDeviceName, PDEVMODEW pDevModeOutput, PDEVMODEW pDevModeInput) { LONG RetVal; LPSTR pDeviceNameAnsi; LPDEVMODEA lpdmaOutput; LPDEVMODEA lpdmaInput; size_t cbInput, cbOutput; if(pDevModeOutput==NULL || pDevModeInput==NULL) { SetLastError(ERROR_INVALID_PARAMETER); return(0); } cbInput = sizeof(DEVMODEA) + (pDevModeInput ? pDevModeInput->dmDriverExtra : 0); lpdmaInput = GodotHeapAlloc(cbInput); if(lpdmaInput==NULL) { SetLastError(ERROR_OUTOFMEMORY); return(0); } ZeroMemory(lpdmaInput, cbInput); DevModeAfromW(lpdmaInput, pDevModeInput); cbOutput = sizeof(DEVMODEA) + (pDevModeOutput ? pDevModeOutput->dmDriverExtra : 0); _STACKALLOC(cbOutput, lpdmaOutput); if(lpdmaOutput==NULL) { GodotHeapFree(lpdmaInput); return(0); } ZeroMemory(lpdmaOutput, cbOutput); GODOT_TO_ACP_STACKALLOC(pDeviceName, pDeviceNameAnsi); if(pDeviceNameAnsi==NULL && pDeviceName != NULL) { GodotHeapFree(lpdmaInput); return(0); } RetVal=AdvancedDocumentPropertiesA(hWnd, hPrinter, pDeviceNameAnsi, lpdmaOutput, lpdmaInput); if(RetVal) DevModeWfromA(pDevModeOutput, lpdmaOutput); GodotHeapFree(lpdmaInput); return RetVal; } End= [EFunc] TemplateName=AppendMenuW Begin= BOOL __stdcall GodotAppendMenuW(HMENU hMenu, UINT uFlags, UINT_PTR uIDNewItem, LPCWSTR lpNewItem) { // To detect the string case, we basically need to detect the // lack of the ownerdraw/bitmap case (since MF_STRING is // actually 0). if(!(uFlags & MF_BITMAP || uFlags & MF_OWNERDRAW)) { LPSTR lpNewItemAnsi; GODOT_TO_ACP_STACKALLOC(lpNewItem, lpNewItemAnsi); return(AppendMenuA(hMenu, uFlags, uIDNewItem, lpNewItemAnsi)); } return(AppendMenuA(hMenu, uFlags, uIDNewItem, (LPCSTR)lpNewItem)); } End= [EFunc] TemplateName=auxGetDevCapsW Begin= MMRESULT __stdcall GodotauxGetDevCapsW(UINT_PTR uDeviceID, LPAUXCAPSW pac, UINT cbac) { // UNSUPPORTED FUNCTION: Documented as a failure stub if(cbac < sizeof(AUXCAPSW)) { return(MMSYSERR_INVALPARAM); } else { AUXCAPSA acA; MMRESULT RetVal; ZeroMemory(&acA, sizeof(AUXCAPSA)); RetVal = auxGetDevCapsA(uDeviceID, &acA, sizeof(AUXCAPSA)); if(RetVal == MMSYSERR_NOERROR) { pac->wMid = acA.wMid; pac->wPid = acA.wPid; pac->vDriverVersion = acA.vDriverVersion; pac->wTechnology = acA.wTechnology; pac->wReserved1 = acA.wReserved1; pac->dwSupport = acA.dwSupport; MultiByteToWideChar(g_acp, 0, acA.szPname, MAXPNAMELEN, pac->szPname, MAXPNAMELEN); } return(RetVal); } } End= [EFunc] TemplateName=BeginUpdateResourceW Begin= HANDLE __stdcall GodotBeginUpdateResourceW(LPCWSTR pFileName, BOOL bDeleteExistingResources) { // UNSUPPORTED FUNCTION: Documented as a failure stub return(BeginUpdateResourceInternalW(pFileName, bDeleteExistingResources)); } End= [EFunc] TemplateName=BroadcastSystemMessageW Begin= long __stdcall GodotBroadcastSystemMessageW(DWORD dwFlags, LPDWORD lpdwRcp, UINT uiMessage, WPARAM wParam, LPARAM lParam) { // Note that we overloaded a few params here rather than add even // more params to GodotTransmitMessage. Slightly hacky but it keeps // things central return(GodotTransmitMessage(mtBroadcastSystemMessage, 0, uiMessage, wParam, lParam, 0, 0, 0, (UINT)dwFlags, 0, lpdwRcp)); } End= [EFunc] TemplateName=CallWindowProcA Begin= LRESULT __stdcall GodotCallWindowProcA(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) { return(GodotTransmitMessage(mtCallWindowProcA, hWnd, Msg, wParam, lParam, lpPrevWndFunc, 0, 0, 0, 0, 0)); } End= [EFunc] TemplateName=CallWindowProcW Begin= LRESULT __stdcall GodotCallWindowProcW(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) { return(GodotTransmitMessage(mtCallWindowProc, hWnd, Msg, wParam, lParam, lpPrevWndFunc, 0, 0, 0, 0, 0)); } End= [EFunc] TemplateName=capCreateCaptureWindowW Begin= HWND __stdcall GodotcapCreateCaptureWindowW( LPCWSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hwndParent, int nID ) { HWND RetVal; LPSTR lpszWindowNameAnsi; LPGODOTTLSINFO lpgti = GetThreadInfoSafe(TRUE); GODOT_TO_ACP_STACKALLOC(lpszWindowName, lpszWindowNameAnsi); if(!lpgti || (!lpszWindowNameAnsi && lpszWindowName)) return(0); INIT_WINDOW_SNIFF(lpgti->hHook); RetVal=capCreateCaptureWindowA(lpszWindowNameAnsi, dwStyle, x, y, nWidth, nHeight, hwndParent, nID); TERM_WINDOW_SNIFF(lpgti->hHook); return RetVal; } End= [EFunc] TemplateName=capGetDriverDescriptionW Begin= BOOL __stdcall GodotcapGetDriverDescriptionW(UINT wDriverIndex, LPWSTR lpszName, int cbName, LPWSTR lpszVer, int cbVer) { BOOL RetVal; LPSTR lpszNameAnsi; LPSTR lpszVerAnsi; _STACKALLOC((cbName*g_mcs)+1, lpszNameAnsi); _STACKALLOC((cbVer*g_mcs)+1, lpszVerAnsi); if((lpszNameAnsi==NULL) || (lpszVerAnsi==NULL)) return(FALSE); ZeroMemory(lpszNameAnsi, (cbName*g_mcs)+1); ZeroMemory(lpszVerAnsi, (cbVer*g_mcs)+1); RetVal=capGetDriverDescriptionA(wDriverIndex, lpszNameAnsi, cbName, lpszVerAnsi, cbVer); if(RetVal) { MultiByteToWideChar(g_acp, 0, lpszNameAnsi, -1, lpszName, cbName); MultiByteToWideChar(g_acp, 0, lpszVerAnsi, -1, lpszVer, cbVer); } return(RetVal); } End= [EFunc] TemplateName=CharToOemW Begin= BOOL __stdcall GodotCharToOemW(LPCWSTR lpszSrc, LPSTR lpszDst) { size_t cchSrc; // MSDN claims this function never returns FALSE. It lies (in the // case where the buffers are identical, for example). if ((void *)lpszSrc == (void *)lpszDst) { SetLastError(ERROR_INVALID_ADDRESS); return(FALSE); } // Why thunk? This function is just a WCHAR->CP_OEM converter, anyway! // We should never be longer than the unicode string * g_mcs cchSrc = gwcslen(lpszSrc); // (Copied the default char choice from oemxlate.c in the Windows depot). WideCharToMultiByte(g_oemcp, 0, lpszSrc, cchSrc, lpszDst, cchSrc*g_mcs, "_", NULL); return(TRUE); } End= [EFunc] TemplateName=CharToOemBuffW Begin= BOOL __stdcall GodotCharToOemBuffW(LPCWSTR lpszSrc, LPSTR lpszDst, DWORD cchDstLength) { LPSTR pTemp; // MSDN claims this function never returns FALSE. It lies (in the // case where the buffers are identical, for example). if ((void *)lpszSrc == (void *)lpszDst) { SetLastError(ERROR_INVALID_ADDRESS); return(FALSE); } // Validate the input and output pointers (taken from the actual API) if(IsBadReadPtr(pTemp = (LPSTR)lpszSrc, cchDstLength) || IsBadWritePtr(pTemp = (LPSTR)lpszDst, cchDstLength)) { SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } // Why thunk? This function is just a WCHAR->CP_OEM converter, anyway! // (Copied the default char choice from oemxlate.c in the Windows depot). WideCharToMultiByte(g_oemcp, 0, lpszSrc, cchDstLength, lpszDst, cchDstLength*g_mcs, "_", NULL); return(TRUE); } End= [EFunc] TemplateName=ChangeDisplaySettingsW Begin= LONG __stdcall GodotChangeDisplaySettingsW(LPDEVMODEW lpDevMode, DWORD dwFlags) { LPDEVMODEA lpdma; _STACKALLOC(sizeof(DEVMODEA) + lpDevMode->dmDriverExtra, lpdma); if(lpdma==NULL) { return(DISP_CHANGE_FAILED); } ZeroMemory(lpdma, sizeof(DEVMODEA) + lpDevMode->dmDriverExtra); if(lpDevMode) DevModeAfromW(lpdma, lpDevMode); return(ChangeDisplaySettingsA(lpdma, dwFlags)); } End= [EFunc] TemplateName=ChangeDisplaySettingsExW Begin= LONG __stdcall GodotChangeDisplaySettingsExW( LPCWSTR lpszDeviceName, LPDEVMODEW lpDevMode, HWND hwnd, DWORD dwflags, LPVOID lParam ) { // Begin locals LONG RetVal = DISP_CHANGE_FAILED; if (s_pfnChangeDisplaySettingsExA == NULL) { // Must allocate stuff for this API call s_pfnChangeDisplaySettingsExA = (PFNcdsea)GetUserProc("ChangeDisplaySettingsExA"); } if (s_pfnChangeDisplaySettingsExA) { LPSTR lpszDeviceNameAnsi; LPDEVMODEA lpdma; _STACKALLOC(sizeof(DEVMODEA) + (lpDevMode ? lpDevMode->dmDriverExtra : 0), lpdma); if(lpdma==NULL) { return(DISP_CHANGE_FAILED); } ZeroMemory(lpdma, sizeof(DEVMODEA) + (lpDevMode ? lpDevMode->dmDriverExtra : 0)); if(lpDevMode) DevModeAfromW(lpdma, lpDevMode); GODOT_TO_ACP_STACKALLOC(lpszDeviceName, lpszDeviceNameAnsi); RetVal=(s_pfnChangeDisplaySettingsExA(lpszDeviceNameAnsi, lpdma, hwnd, dwflags, lParam)); } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return RetVal; } End= [EFunc] TemplateName=CharLowerW Begin= LPWSTR __stdcall GodotCharLowerW(LPWSTR lpsz) { if(lpsz) { if (FSTRING_VALID(lpsz)) { CaseHelper(lpsz, (DWORD)-1, FALSE); } else { CaseHelper((LPWSTR)&lpsz, 1, FALSE); } } return lpsz; } End= [EFunc] TemplateName=CharLowerBuffW Begin= DWORD __stdcall GodotCharLowerBuffW(LPWSTR lpsz, DWORD cchLength) { if (!lpsz || !cchLength) return 0; CaseHelper(lpsz, cchLength, FALSE); return cchLength; } End= [EFunc] TemplateName=CharNextW Begin= LPWSTR __stdcall GodotCharNextW(LPCWSTR lpsz) { LPWSTR RetVal = (LPWSTR)lpsz; if (lpsz && (L'\0' != *lpsz)) RetVal++; // this is what _wcsinc does return RetVal; } End= [EFunc] TemplateName=CharPrevW Begin= LPWSTR __stdcall GodotCharPrevW(LPCWSTR lpszStart, LPCWSTR lpszCurrent) { LPWSTR RetVal = (LPWSTR)lpszCurrent; if (lpszStart && lpszCurrent && (lpszCurrent > lpszStart)) RetVal--; // this is what _wcsdec does else RetVal = (LPWSTR)lpszStart; return RetVal; } End= [EFunc] TemplateName=CharUpperW Begin= LPWSTR __stdcall GodotCharUpperW(LPWSTR lpsz) { if(lpsz) { if (FSTRING_VALID(lpsz)) CaseHelper(lpsz, (DWORD)-1, TRUE); else CaseHelper((LPWSTR)&lpsz, 1, TRUE); } return lpsz; } End= [EFunc] TemplateName=CharUpperBuffW Begin= DWORD __stdcall GodotCharUpperBuffW(LPWSTR lpsz, DWORD cchLength) { if (!lpsz || !cchLength) return 0; CaseHelper(lpsz, cchLength, TRUE); return cchLength; } End= [EFunc] TemplateName=ChooseColorW Begin= BOOL __stdcall GodotChooseColorW(LPCHOOSECOLORW lpcc) { // Begin locals BOOL RetVal; CHOOSECOLORA ccAnsi; LPGODOTTLSINFO lpgti; // If we cannot get out TLS info, then we cannot proceed if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(0); } ZeroMemory(&ccAnsi, sizeof(CHOOSECOLORA)); // Do the hook if((lpgti->pfnChooseColor) && (lpcc->Flags & CC_ENABLEHOOK) && (lpcc->lpfnHook)) { SetLastError(ERROR_INVALID_FILTER_PROC); return(0); } if ((lpcc->Flags & CC_ENABLEHOOK) && (lpcc->lpfnHook)) lpgti->pfnChooseColor = lpcc->lpfnHook; ccAnsi.lpfnHook = &CCHookProc; ccAnsi.lStructSize = sizeof(CHOOSECOLORA); ccAnsi.hwndOwner = lpcc->hwndOwner; if((lpcc->Flags & CC_ENABLETEMPLATEHANDLE) || (lpcc->Flags & CC_ENABLETEMPLATE)) ccAnsi.hInstance = lpcc->hInstance; ccAnsi.rgbResult = lpcc->rgbResult; ccAnsi.lpCustColors = lpcc->lpCustColors; // pointer to an array of 16 COLORREFs ccAnsi.Flags = lpcc->Flags; ccAnsi.lCustData = lpcc->lCustData; if(lpcc->Flags & CC_ENABLETEMPLATE) { GODOT_TO_ACP_STACKALLOC(lpcc->lpTemplateName, ccAnsi.lpTemplateName); } INIT_WINDOW_SNIFF(lpgti->hHook); RetVal=ChooseColorA(&ccAnsi); TERM_WINDOW_SNIFF(lpgti->hHook); if ((lpcc->Flags & CC_ENABLEHOOK) && (lpcc->lpfnHook)) lpgti->pfnChooseColor = NULL; // Begin postcall if(RetVal) { lpcc->rgbResult = ccAnsi.rgbResult; lpcc->lpCustColors = ccAnsi.lpCustColors; // pointer to an array of 16 COLORREFs lpcc->Flags = ccAnsi.Flags; lpcc->lCustData = ccAnsi.lCustData; } // Finished return RetVal; } End= [EFunc] TemplateName=ChooseFontW Begin= BOOL __stdcall GodotChooseFontW(LPCHOOSEFONTW lpcf) { // Begin locals BOOL RetVal; CHOOSEFONTA cfa; LPGODOTTLSINFO lpgti; // If we cannot get out TLS info, then we cannot proceed if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(0); } ZeroMemory(&cfa, sizeof(CHOOSEFONTA)); // Do the hook if((lpgti->pfnChooseFont) && (lpcf->Flags & CF_ENABLEHOOK) && (lpcf->lpfnHook)) { SetLastError(ERROR_INVALID_FILTER_PROC); return(0); } if ((lpcf->Flags & CF_ENABLEHOOK) && (lpcf->lpfnHook)) lpgti->pfnChooseFont = lpcf->lpfnHook; cfa.lpfnHook = &CFHookProc; cfa.lStructSize = sizeof(CHOOSEFONTA); cfa.hwndOwner = lpcf->hwndOwner; if((lpcf->Flags & CF_PRINTERFONTS) || (lpcf->Flags & CF_BOTH)) cfa.hDC = lpcf->hDC; _STACKALLOC(sizeof(LOGFONTA), cfa.lpLogFont); ZeroMemory(cfa.lpLogFont, sizeof(LOGFONTA)); LogFontAfromW(cfa.lpLogFont, lpcf->lpLogFont); cfa.iPointSize = lpcf->iPointSize; cfa.Flags = lpcf->Flags; cfa.rgbColors = lpcf->rgbColors; cfa.lCustData = lpcf->lCustData; if(lpcf->Flags & CF_ENABLETEMPLATE) { GODOT_TO_ACP_STACKALLOC(lpcf->lpTemplateName, cfa.lpTemplateName); } //if((lpcf->Flags & CF_ENABLETEMPLATEHANDLE) || (lpcf->Flags & CF_ENABLETEMPLATE)) cfa.hInstance = lpcf->hInstance; GODOT_TO_ACP_STACKALLOC(lpcf->lpszStyle, cfa.lpszStyle); cfa.nFontType = lpcf->nFontType; cfa.nSizeMin = lpcf->nSizeMin; cfa.nSizeMax = lpcf->nSizeMax; INIT_WINDOW_SNIFF(lpgti->hHook); RetVal=ChooseFontA(&cfa); TERM_WINDOW_SNIFF(lpgti->hHook); if ((lpcf->Flags & CF_ENABLEHOOK) && (lpcf->lpfnHook)) lpgti->pfnChooseFont = NULL; // Begin postcall if(RetVal) { size_t cbStyle; lpcf->hDC = cfa.hDC; LogFontWfromA(lpcf->lpLogFont, cfa.lpLogFont); lpcf->iPointSize = cfa.iPointSize; lpcf->Flags = cfa.Flags; lpcf->rgbColors = cfa.rgbColors; lpcf->lCustData = cfa.lCustData; cbStyle = (lpcf->lpszStyle==NULL ? 0 : lstrlenA( cfa.lpszStyle)); if(FSTRING_VALID(cfa.lpszStyle) && FSTRING_VALID(lpcf->lpszStyle) && (cbStyle > 0)) MultiByteToWideChar(g_acp, 0, cfa.lpszStyle, -1, lpcf->lpszStyle, cbStyle); lpcf->nFontType = cfa.nFontType; lpcf->nSizeMin = cfa.nSizeMin; lpcf->nSizeMax = cfa.nSizeMax; } // Finished return RetVal; } End= [EFunc] TemplateName=CompareStringW Begin= int __stdcall GodotCompareStringW( LCID Locale, DWORD dwCmpFlags, LPCWSTR lpString1, int cchCount1, LPCWSTR lpString2, int cchCount2 ) { // Begin locals int RetVal; LPSTR lpString1A, lpString2A; size_t cchString1, cchString2; UINT cpg; UINT mcs; cpg = CpgFromLocale(Locale); mcs = CbPerChOfCpg(cpg); // Begin precall if (FSTRING_VALID(lpString1)) { if(cchCount1==-1) cchString1 = gwcslen(lpString1) + 1; else cchString1 = cchCount1 + 1; _STACKALLOC(cchString1*mcs, lpString1A); if(!lpString1A) { return(FALSE); } WideCharToMultiByte(cpg, 0, lpString1, cchString1, lpString1A, cchString1*mcs, NULL, NULL); } else lpString1A = (LPSTR)lpString1; if (FSTRING_VALID(lpString2)) { if(cchCount2==-1) cchString2 = gwcslen(lpString2) + 1; else cchString2 = cchCount2 + 1; _STACKALLOC(cchString2*mcs, lpString2A); if(!lpString2A) { return(FALSE); } WideCharToMultiByte(cpg, 0, lpString2, cchString2, lpString2A, cchString2*mcs, NULL, NULL); } else lpString2A = (LPSTR)lpString2; RetVal=CompareStringA(Locale, dwCmpFlags, lpString1A, cchCount1, lpString2A, cchCount2); // Finished return RetVal; } End= [EFunc] TemplateName=ConfigurePortW Begin= BOOL __stdcall GodotConfigurePortW(LPWSTR pName, HWND hWnd, LPWSTR pPortName) { BOOL RetVal = FALSE; LPSTR pNameAnsi = NULL; LPSTR pPortNameAnsi = NULL; ALLOCRETURN arName = GodotToAcpOnHeap(pName, &pNameAnsi); ALLOCRETURN arPortName = GodotToAcpOnHeap(pPortName, &pPortNameAnsi); if(arName != arFailed && arPortName != arFailed) RetVal = ConfigurePortA(pNameAnsi, hWnd, pPortNameAnsi); if(arName==arAlloc) GodotHeapFree(pNameAnsi); if(arPortName==arAlloc) GodotHeapFree(pPortNameAnsi); if(arName == arFailed || arPortName == arFailed) SetLastError(ERROR_OUTOFMEMORY); return(RetVal); } End= [EFunc] TemplateName=CopyFileW Begin= BOOL __stdcall GodotCopyFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, BOOL bFailIfExists) { LPSTR lpExistingFileNameA, lpNewFileNameA; UINT cpg = FILES_CPG; // Begin precall GODOT_TO_CPG_STACKALLOC(lpExistingFileName, lpExistingFileNameA, cpg, g_mcs); GODOT_TO_CPG_STACKALLOC(lpNewFileName, lpNewFileNameA, cpg, g_mcs); return(CopyFileA(lpExistingFileNameA, lpNewFileNameA, bFailIfExists)); } End= [EFunc] TemplateName=CopyFileExW Begin= BOOL __stdcall GodotCopyFileExW( LPCWSTR lpExisting, LPCWSTR lpNew, LPPROGRESS_ROUTINE lpProgress, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags ) { // Begin locals LPSTR lpEfnA, lpNfnA; UINT cpg = FILES_CPG; if (s_pfnCopyFileExA == NULL) { // Must allocate stuff for this API call s_pfnCopyFileExA = (PFNcfea)GetKernelProc("CopyFileExA"); } if (s_pfnCopyFileExA) { GODOT_TO_CPG_STACKALLOC(lpExisting, lpEfnA, cpg, g_mcs); GODOT_TO_CPG_STACKALLOC(lpNew, lpNfnA, cpg, g_mcs); return((s_pfnCopyFileExA(lpEfnA, lpNfnA, lpProgress, lpData, pbCancel, dwCopyFlags))); } SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return FALSE; } End= [EFunc] TemplateName=CreateColorSpaceW Begin= HCOLORSPACE __stdcall GodotCreateColorSpaceW(LPLOGCOLORSPACEW plcs) { LOGCOLORSPACEA lcsa; // Begin precall ZeroMemory(&lcsa, sizeof(LOGCOLORSPACEA)); memcpy(&lcsa, plcs, 6*sizeof(DWORD)+sizeof(LCSCSTYPE)+sizeof(LCSGAMUTMATCH)+sizeof(CIEXYZTRIPLE)); lcsa.lcsSize = sizeof(LOGCOLORSPACEA); WideCharToMultiByte(g_acp, 0, plcs->lcsFilename, MAX_PATH, lcsa.lcsFilename, MAX_PATH, NULL, NULL); return(CreateColorSpaceA(&lcsa)); } End= [EFunc] TemplateName=CreateDCW Begin= HDC __stdcall GodotCreateDCW(LPCWSTR lpszDriver, LPCWSTR lpszDevice, LPCWSTR lpszOutput, DEVMODEW * lpInitData) { LPSTR lpszDriverAnsi, lpszDeviceAnsi, lpszOutputAnsi; LPDEVMODEA lpdma; // Begin precall GODOT_TO_ACP_STACKALLOC(lpszDriver, lpszDriverAnsi); GODOT_TO_ACP_STACKALLOC(lpszDevice, lpszDeviceAnsi); GODOT_TO_ACP_STACKALLOC(lpszOutput, lpszOutputAnsi); if((!lpszDriverAnsi && lpszDriver) || (!lpszDeviceAnsi && lpszDevice) || (!lpszOutputAnsi && lpszOutput)) { return(0); } if (lpInitData) { _STACKALLOC(sizeof(DEVMODEA) + lpInitData->dmDriverExtra, lpdma); if(lpdma==NULL) { return(0); } ZeroMemory(lpdma, sizeof(DEVMODEA) + lpInitData->dmDriverExtra); DevModeAfromW(lpdma, lpInitData); return(CreateDCA(lpszDriverAnsi, lpszDeviceAnsi, lpszOutputAnsi, lpdma)); } else return(CreateDCA(lpszDriverAnsi, lpszDeviceAnsi, lpszOutputAnsi, NULL)); } End= [EFunc] TemplateName=CreateDialogIndirectParamW Begin= HWND __stdcall GodotCreateDialogIndirectParamW( HINSTANCE hInst, LPCDLGTEMPLATEW lpTemplate, HWND hWnd, DLGPROC lpfn, LPARAM dwParam ) { LPGODOTTLSINFO lpgti = GetThreadInfoSafe(TRUE); HWND RetVal; if(!lpgti) { RetVal = 0; } else { lpgti->pfnDlgProc = lpfn; INIT_WINDOW_SNIFF(lpgti->hHook); RetVal = CreateDialogIndirectParamA(hInst, lpTemplate, hWnd, &DialogProc, dwParam); TERM_WINDOW_SNIFF(lpgti->hHook); } return(RetVal); } End= [EFunc] TemplateName=CreateDialogParamW Begin= HWND __stdcall GodotCreateDialogParamW(HINSTANCE hInst, LPCWSTR lpTemplate, HWND hWnd, DLGPROC lpfn, LPARAM dwParam) { LPGODOTTLSINFO lpgti = GetThreadInfoSafe(TRUE); if(!lpgti) { return(0); } else { LPSTR lpTemplateAnsi; HWND RetVal; lpgti->pfnDlgProc = lpfn; GODOT_TO_ACP_STACKALLOC(lpTemplate, lpTemplateAnsi); if(!lpTemplateAnsi && lpTemplate) return(0); INIT_WINDOW_SNIFF(lpgti->hHook); RetVal = CreateDialogParamA(hInst, lpTemplateAnsi, hWnd, &DialogProc, dwParam); TERM_WINDOW_SNIFF(lpgti->hHook); return(RetVal); } } End= [EFunc] TemplateName=CreateDirectoryW Begin= BOOL __stdcall GodotCreateDirectoryW(LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes) { // Begin locals LPSTR lpPathNameAnsi; // Begin precall GODOT_TO_CPG_STACKALLOC(lpPathName, lpPathNameAnsi, FILES_CPG, g_mcs); return(CreateDirectoryA(lpPathNameAnsi, lpSecurityAttributes)); } End= [EFunc] TemplateName=CreateDirectoryExW Begin= BOOL __stdcall GodotCreateDirectoryExW(LPCWSTR lpTemplate, LPCWSTR lpNew, LPSECURITY_ATTRIBUTES lpSecurityAttributes) { // Begin locals LPSTR lpTemplateAnsi, lpNewAnsi; UINT cpg = FILES_CPG; // Begin precall GODOT_TO_CPG_STACKALLOC(lpTemplate, lpTemplateAnsi, cpg, g_mcs); GODOT_TO_CPG_STACKALLOC(lpNew, lpNewAnsi, cpg, g_mcs); return(CreateDirectoryExA(lpTemplateAnsi, lpNewAnsi, lpSecurityAttributes)); } End= [EFunc] TemplateName=CreateFileW Begin= HANDLE __stdcall GodotCreateFileW( LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile ) { LPSTR lpFileNameAnsi; // Begin precall GODOT_TO_CPG_STACKALLOC(lpFileName, lpFileNameAnsi, FILES_CPG, g_mcs); return(CreateFileA(lpFileNameAnsi, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile )); } End= [EFunc] TemplateName=CreateFontIndirectW Begin= HFONT __stdcall GodotCreateFontIndirectW(LOGFONTW * lplf ) { LOGFONTA lfa; ZeroMemory(&lfa, sizeof(LOGFONTA)); LogFontAfromW(&lfa, lplf); return(CreateFontIndirectA(&lfa)); } End= [EFunc] TemplateName=CreateICW Begin= HDC __stdcall GodotCreateICW( LPCWSTR lpszDriver, LPCWSTR lpszDevice, LPCWSTR lpszOutput, DEVMODEW * lpdvmInit ) { LPSTR lpszDriverAnsi, lpszDeviceAnsi; LPDEVMODEA lpdma; // Begin precall GODOT_TO_ACP_STACKALLOC(lpszDriver, lpszDriverAnsi); GODOT_TO_ACP_STACKALLOC(lpszDevice, lpszDeviceAnsi); if((!lpszDriverAnsi && lpszDriver) || (!lpszDeviceAnsi && lpszDevice)) { return(0); } if(lpdvmInit) { _STACKALLOC(sizeof(DEVMODEA) + lpdvmInit->dmDriverExtra, lpdma); if(lpdma==NULL) { return(0); } ZeroMemory(lpdma, sizeof(DEVMODEA) + lpdvmInit->dmDriverExtra); DevModeAfromW(lpdma, lpdvmInit); return(CreateICA(lpszDriverAnsi, lpszDeviceAnsi, NULL, lpdma)); } else return(CreateICA(lpszDriverAnsi, lpszDeviceAnsi, NULL, NULL)); } End= [EFunc] TemplateName=CreateMDIWindowW Begin= HWND __stdcall GodotCreateMDIWindowW( LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HINSTANCE hInstance, LPARAM lParam ) { HWND RetVal; LPSTR lpClassNameAnsi, lpWindowNameAnsi; LPGODOTTLSINFO lpgti = GetThreadInfoSafe(TRUE); GODOT_TO_ACP_STACKALLOC(lpClassName, lpClassNameAnsi); GODOT_TO_ACP_STACKALLOC(lpWindowName, lpWindowNameAnsi); if(!lpgti || (lpClassName && !lpClassNameAnsi) || (lpWindowName && !lpWindowNameAnsi)) return(0); INIT_WINDOW_SNIFF(lpgti->hHook); RetVal=CreateMDIWindowA(lpClassNameAnsi, lpWindowNameAnsi, dwStyle, X, Y, nWidth, nHeight, hWndParent, hInstance, lParam); TERM_WINDOW_SNIFF(lpgti->hHook); // Finished return RetVal; } End= [EFunc] TemplateName=CreateProcessW Begin= BOOL __stdcall GodotCreateProcessW( LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpsiw, LPPROCESS_INFORMATION lpProcessInformation ) { LPSTR lpApplicationNameAnsi, lpCommandLineAnsi, lpCurrentDirectoryAnsi; STARTUPINFOA sia; // Begin precall ZeroMemory(&sia, sizeof(STARTUPINFOA)); GODOT_TO_ACP_STACKALLOC(lpApplicationName, lpApplicationNameAnsi); GODOT_TO_ACP_STACKALLOC(lpCommandLine, lpCommandLineAnsi); GODOT_TO_ACP_STACKALLOC(lpCurrentDirectory, lpCurrentDirectoryAnsi); sia.cb = sizeof(STARTUPINFOA); GODOT_TO_ACP_STACKALLOC(lpsiw->lpReserved, sia.lpReserved); GODOT_TO_ACP_STACKALLOC(lpsiw->lpDesktop, sia.lpDesktop); GODOT_TO_ACP_STACKALLOC(lpsiw->lpTitle, sia.lpTitle); sia.dwX = lpsiw->dwX; sia.dwY = lpsiw->dwY; sia.dwXSize = lpsiw->dwXSize; sia.dwYSize = lpsiw->dwYSize; sia.dwXCountChars = lpsiw->dwXCountChars; sia.dwYCountChars = lpsiw->dwYCountChars; sia.dwFillAttribute = lpsiw->dwFillAttribute; sia.dwFlags = lpsiw->dwFlags; sia.wShowWindow = lpsiw->wShowWindow; sia.cbReserved2 = lpsiw->cbReserved2; sia.lpReserved2 = lpsiw->lpReserved2; sia.hStdInput = lpsiw->hStdInput; sia.hStdOutput = lpsiw->hStdOutput; sia.hStdError = lpsiw->hStdError; return(CreateProcessA(lpApplicationNameAnsi, lpCommandLineAnsi, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectoryAnsi, &sia, lpProcessInformation )); } End= [EFunc] TemplateName=CreateStdAccessibleProxyW Begin= HRESULT __stdcall GodotCreateStdAccessibleProxyW(HWND hwnd, LPCWSTR pClassName, LONG idObject, const IID * riid, void ** ppv) { HRESULT RetVal = E_NOTIMPL; if (s_pfnCreateStdAccessibleProxy == NULL) { // Must allocate stuff for this API call s_pfnCreateStdAccessibleProxy = (PFNcsapa)GetOleAccProc("CreateStdAccessibleProxyA"); } if (s_pfnCreateStdAccessibleProxy) { LPSTR pClassNameAnsi; GODOT_TO_ACP_STACKALLOC(pClassName, pClassNameAnsi); if(!pClassNameAnsi && pClassName) return(E_FAIL); RetVal = (s_pfnCreateStdAccessibleProxy(hwnd, pClassNameAnsi, idObject, riid, ppv)); } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return RetVal; } End= [EFunc] TemplateName=CreateWindowExW Begin= HWND __stdcall GodotCreateWindowExW( DWORD dwExStyle, LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam ) { // Begin locals HWND RetVal; LPSTR lpClassNameAnsi = NULL; LPSTR lpWindowNameAnsi = NULL; LPGODOTTLSINFO lpgti = GetThreadInfoSafe(TRUE); GODOT_TO_ACP_STACKALLOC(lpClassName, lpClassNameAnsi); GODOT_TO_ACP_STACKALLOC(lpWindowName, lpWindowNameAnsi); if(!lpgti || (!lpClassNameAnsi && lpClassName) || (!lpWindowNameAnsi && lpWindowName)) return(0); INIT_WINDOW_SNIFF(lpgti->hHook); RetVal=CreateWindowExA(dwExStyle, lpClassNameAnsi, lpWindowNameAnsi, dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam ); TERM_WINDOW_SNIFF(lpgti->hHook); // Finished return RetVal; } End= [EFunc] TemplateName=CreateWaitableTimerW Begin= HANDLE __stdcall GodotCreateWaitableTimerW(LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCWSTR lpTimerName) { // Begin locals HANDLE RetVal = NULL; if (s_pfnCreateWaitableTimerA == NULL) { // Must allocate stuff for this API call s_pfnCreateWaitableTimerA = (PFNcwta)GetKernelProc("CreateWaitableTimerA"); } if (s_pfnCreateWaitableTimerA) { LPSTR lpTimerNameAnsi; GODOT_TO_ACP_STACKALLOC(lpTimerName, lpTimerNameAnsi); RetVal = (s_pfnCreateWaitableTimerA(lpTimerAttributes, bManualReset, lpTimerNameAnsi)); } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return RetVal; } End= [EFunc] TemplateName=DdeConnect Begin= HCONV __stdcall GodotDdeConnect(DWORD idInst, HSZ hszService, HSZ hszTopic, PCONVCONTEXT pCC) { if(pCC) { // CP_WINUNICODE is not a valid param for Win95/98/ME, so // we will munge it here it it exists. Nothing else needs to // change if(pCC->iCodePage == CP_WINUNICODE) pCC->iCodePage = CP_WINANSI; } return(DdeConnect(idInst, hszService, hszTopic, pCC)); } End= [EFunc] TemplateName=DdeConnectList Begin= HCONVLIST __stdcall GodotDdeConnectList(DWORD idInst, HSZ hszService, HSZ hszTopic, HCONVLIST hConvList, PCONVCONTEXT pCC) { if(pCC) { // CP_WINUNICODE is not a valid param for Win95/98/ME, so // we will munge it here it it exists. Nothing else needs to // change if(pCC->iCodePage == CP_WINUNICODE) pCC->iCodePage = CP_WINANSI; } return(DdeConnectList(idInst, hszService, hszTopic, hConvList, pCC)); } End= [EFunc] TemplateName=DdeCreateStringHandleW Begin= HSZ __stdcall GodotDdeCreateStringHandleW(DWORD idInst, LPCWSTR psz, int iCodePage) { // Begin locals HSZ RetVal; LPSTR pszAnsi; if(iCodePage == CP_WINUNICODE) { GODOT_TO_ACP_STACKALLOC(psz, pszAnsi); if(pszAnsi==NULL) { RetVal = 0L; } RetVal=DdeCreateStringHandleA(idInst, pszAnsi, iCodePage); } else if((iCodePage == CP_WINANSI) || // This is what the docs say it must be (iCodePage == (int)GetACP()) || // Turns out it can be this, (iCodePage == (int)GetOEMCP())) // and it can also be this { // No conversion needed RetVal=DdeCreateStringHandleA(idInst, (LPSTR)psz, iCodePage); } else { SetLastError(ERROR_INVALID_PARAMETER); RetVal = 0L; } // Finished return RetVal; } End= [EFunc] TemplateName=DdeInitializeW Begin= UINT __stdcall GodotDdeInitializeW(LPDWORD pidInst, PFNCALLBACK pfnCallback, DWORD afCmd, DWORD ulRes) { // CONSIDER: Several DDE messages might not have the right iCodePage flag in them: // XTYP_CONNECT - CONVCONTEXT in dwData1 // XTYP_WILDCONNECT - CONVCONTEXT in dwData1 // XTYP_MONITOR - several potential structures that do this return(DdeInitializeA(pidInst, pfnCallback, afCmd, ulRes)); } End= [EFunc] TemplateName=DdeQueryConvInfo Begin= UINT __stdcall GodotDdeQueryConvInfo(HCONV hConv, DWORD idTransaction, PCONVINFO pConvInfo) { UINT RetVal; BOOL fUnicode = FALSE; // Munge the structure if it is there to fix up CP_WINUNICODE refs if(pConvInfo) { if(pConvInfo->ConvCtxt.iCodePage == CP_WINUNICODE) { fUnicode = TRUE; pConvInfo->ConvCtxt.iCodePage = CP_WINANSI; } } // Call the API RetVal=DdeQueryConvInfo(hConv, idTransaction, pConvInfo); // Fix the structure back if we mucked with it if(fUnicode) pConvInfo->ConvCtxt.iCodePage = CP_WINUNICODE; // Finished return RetVal; } End= [EFunc] TemplateName=DdeQueryStringW Begin= DWORD __stdcall GodotDdeQueryStringW(DWORD idInst, HSZ hsz, LPWSTR psz, DWORD cchMax, int iCodePage) { // Begin locals DWORD RetVal; LPSTR pszAnsi; if(iCodePage == CP_WINUNICODE) { if(psz) { _STACKALLOC(cchMax*g_mcs, pszAnsi); } else pszAnsi = NULL; RetVal=DdeQueryStringA(idInst, hsz, pszAnsi, cchMax, CP_WINANSI); if(psz && pszAnsi) { MultiByteToWideChar(g_acp, 0, pszAnsi, cchMax*g_mcs, psz, cchMax); RetVal = gwcslen(psz); } else { // We have been given a return that the PSDK claims is ANSI TCHARs. This // count should match the Unicode cch so we can leave it alone. } } else if((iCodePage == CP_WINANSI) || // This is what the docs say it must be (iCodePage == (int)GetACP()) || // Turns out it can be this, (iCodePage == (int)GetOEMCP())) // and it can also be this { // Not doing a Unicode code page, so no conversion needed or wanted RetVal=DdeQueryStringA(idInst, hsz, (LPSTR)psz, cchMax, iCodePage); } else { SetLastError(ERROR_INVALID_PARAMETER); RetVal = 0L; } return RetVal; } End= [EFunc] TemplateName=DefDlgProcW Begin= LRESULT __stdcall GodotDefDlgProcW(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam) { return(GodotTransmitMessage(mtDefDlgProc, hDlg, Msg, wParam, lParam, 0, 0, 0, 0, 0, 0)); } End= [EFunc] TemplateName=DefFrameProcW Begin= LRESULT __stdcall GodotDefFrameProcW(HWND hWnd, HWND hWndMDIClient, UINT uMsg, WPARAM wParam, LPARAM lParam) { // Overloading GTM's dwData param for hWndMDIClient return(GodotTransmitMessage(mtDefFrameProc, hWnd, uMsg, wParam, lParam, 0, 0, (DWORD)hWndMDIClient, 0, 0, 0)); } End= [EFunc] TemplateName=DefMDIChildProcW Begin= LRESULT __stdcall GodotDefMDIChildProcW(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { return(GodotTransmitMessage(mtDefMDIChildProc, hWnd, uMsg, wParam, lParam, 0, 0, 0, 0, 0, 0)); } End= [EFunc] TemplateName=DefWindowProcW Begin= LRESULT __stdcall GodotDefWindowProcW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) { return(GodotTransmitMessage(mtDefWindowProc, hWnd, Msg, wParam, lParam, 0, 0, 0, 0, 0, 0)); } End= [EFunc] TemplateName=DeleteFileW Begin= BOOL __stdcall GodotDeleteFileW(LPCWSTR lpFileName) { LPSTR lpFileNameAnsi; GODOT_TO_CPG_STACKALLOC(lpFileName, lpFileNameAnsi, FILES_CPG, g_mcs); return(DeleteFileA(lpFileNameAnsi)); } End= [EFunc] TemplateName=DeleteMinitorW Begin= BOOL __stdcall GodotDeleteMonitorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pMonitorName) { BOOL RetVal = FALSE; LPSTR pNameAnsi = NULL; LPSTR pEnvironmentAnsi = NULL; LPSTR pMonitorNameAnsi = NULL; ALLOCRETURN arName = GodotToAcpOnHeap(pName, &pNameAnsi); ALLOCRETURN arEnvironmentName = GodotToAcpOnHeap(pEnvironment, &pEnvironmentAnsi); ALLOCRETURN arMonitorName = GodotToAcpOnHeap(pMonitorName, &pMonitorNameAnsi); if(arName != arFailed && arEnvironmentName != arFailed && arMonitorName != arFailed) RetVal=DeleteMonitorWA(pNameAnsi, pEnvironmentAnsi, pMonitorNameAnsi); if(arName==arAlloc) GodotHeapFree(pNameAnsi); if(arEnvironmentName==arAlloc) GodotHeapFree(pEnvironmentAnsi); if(arMonitorName==arAlloc) GodotHeapFree(pMonitorNameAnsi); if(arName == arFailed || arEnvironmentName == arFailed || arMonitorName == arFailed) SetLastError(ERROR_OUTOFMEMORY); return RetVal; } End= [EFunc] TemplateName=DeletePortW Begin= BOOL __stdcall GodotDeletePortW(LPWSTR pName, HWND hWnd, LPWSTR pPortName) { BOOL RetVal = FALSE; LPSTR pNameAnsi = NULL; LPSTR pPortNameAnsi = NULL; ALLOCRETURN arName = GodotToAcpOnHeap(pName, &pNameAnsi); ALLOCRETURN arPortName = GodotToAcpOnHeap(pPortName, &pPortNameAnsi); if(arName != arFailed && arPortName != arFailed) RetVal = DeletePortA(pNameAnsi, hWnd, pPortNameAnsi); if(arName==arAlloc) GodotHeapFree(pNameAnsi); if(arPortName==arAlloc) GodotHeapFree(pPortNameAnsi); if(arName == arFailed || arPortName == arFailed) SetLastError(ERROR_OUTOFMEMORY); return(RetVal); } End= [EFunc] TemplateName=DeletePrinterDriverW Begin= BOOL __stdcall GodotDeletePrinterDriverW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pDriverName) { BOOL RetVal = FALSE; LPSTR pNameAnsi = NULL; LPSTR pEnvironmentAnsi = NULL; LPSTR pDriverNameAnsi = NULL; ALLOCRETURN arName = GodotToAcpOnHeap(pName, &pNameAnsi); ALLOCRETURN arEnvironmentName = GodotToAcpOnHeap(pEnvironment, &pEnvironmentAnsi); ALLOCRETURN arDriverName = GodotToAcpOnHeap(pDriverName, &pDriverNameAnsi); if(arName != arFailed && arEnvironmentName != arFailed && arDriverName != arFailed) RetVal = DeletePrinterDriverA(pNameAnsi, pEnvironmentAnsi, pDriverNameAnsi); if(arName==arAlloc) GodotHeapFree(pNameAnsi); if(arEnvironmentName==arAlloc) GodotHeapFree(pEnvironmentAnsi); if(arDriverName==arAlloc) GodotHeapFree(pDriverNameAnsi); if(arName == arFailed || arEnvironmentName == arFailed || arDriverName == arFailed) SetLastError(ERROR_OUTOFMEMORY); return(RetVal); } End= [EFunc] TemplateName=DeletePrintProcessorW Begin= BOOL __stdcall GodotDeletePrintProcessorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPrintProcessorName) { BOOL RetVal = FALSE; LPSTR pNameAnsi = NULL; LPSTR pEnvironmentAnsi = NULL; LPSTR pPrintProcessorNameAnsi = NULL; ALLOCRETURN arName = GodotToAcpOnHeap(pName, &pNameAnsi); ALLOCRETURN arEnvironmentName = GodotToAcpOnHeap(pEnvironment, &pEnvironmentAnsi); ALLOCRETURN arProcessorName = GodotToAcpOnHeap(pPrintProcessorName, &pPrintProcessorNameAnsi); if(arName != arFailed && arEnvironmentName != arFailed && arProcessorName != arFailed) RetVal = DeletePrintProcessorA(pNameAnsi, pEnvironmentAnsi, pPrintProcessorNameAnsi); if(arName==arAlloc) GodotHeapFree(pNameAnsi); if(arEnvironmentName==arAlloc) GodotHeapFree(pEnvironmentAnsi); if(arProcessorName==arAlloc) GodotHeapFree(pPrintProcessorNameAnsi); if(arName == arFailed || arEnvironmentName == arFailed || arProcessorName == arFailed) SetLastError(ERROR_OUTOFMEMORY); return(RetVal); } End= [EFunc] TemplateName=DeletePrintProvidorW Begin= BOOL __stdcall GodotDeletePrintProvidorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPrintProvidorName) { BOOL RetVal = FALSE; LPSTR pNameAnsi = NULL; LPSTR pEnvironmentAnsi = NULL; LPSTR pPrintProvidorNameAnsi = NULL; ALLOCRETURN arName = GodotToAcpOnHeap(pName, &pNameAnsi); ALLOCRETURN arEnvironmentName = GodotToAcpOnHeap(pEnvironment, &pEnvironmentAnsi); ALLOCRETURN arPrintProvidorName = GodotToAcpOnHeap(pPrintProvidorName, &pPrintProvidorNameAnsi); if(arName != arFailed && arEnvironmentName != arFailed && arPrintProvidorName != arFailed) RetVal=DeletePrintProvidorWA(pNameAnsi, pEnvironmentAnsi, pPrintProvidorNameAnsi); if(arName==arAlloc) GodotHeapFree(pNameAnsi); if(arEnvironmentName==arAlloc) GodotHeapFree(pEnvironmentAnsi); if(arPrintProvidorName==arAlloc) GodotHeapFree(pPrintProvidorNameAnsi); if(arName == arFailed || arEnvironmentName == arFailed || arPrintProvidorName == arFailed) SetLastError(ERROR_OUTOFMEMORY); return(RetVal); } End= [EFunc] TemplateName=DeviceCapabilitiesW Begin= int __stdcall GodotDeviceCapabilitiesW(LPCWSTR pDevice, LPCWSTR pPort, WORD fwCapability, LPWSTR pOutput, const DEVMODEW * pDevMode) { // UNSUPPORTED FUNCTION: Documented as a failure stub LPCSTR pDeviceAnsi; LPCSTR pPortAnsi; int RetVal; LPDEVMODEA pdma; GODOT_TO_ACP_STACKALLOC(pDevice, pDeviceAnsi); GODOT_TO_ACP_STACKALLOC(pPort, pPortAnsi); if((pDeviceAnsi==NULL && pDevice != NULL) || (pPortAnsi==NULL && pPort != NULL)) { return(0); } if(pDevMode==NULL) pdma = NULL; else { pdma = GodotHeapAlloc(sizeof(DEVMODEA) + pDevMode->dmDriverExtra); if(pdma==NULL) { SetLastError(ERROR_OUTOFMEMORY); return(0); } DevModeAfromW(pdma, (LPDEVMODEW)pDevMode); } switch(fwCapability) { case DC_BINNAMES: case DC_PAPERNAMES: case DC_FILEDEPENDENCIES: { // Array of 24-char or 64-char strings, RetVal is the number of them // The strings are null-terminated unless the name is 64 characters long. // Always get the size, either because that is all // the caller wanted or because we need it ourselves. RetVal = DeviceCapabilitiesA(pDeviceAnsi, pPortAnsi, fwCapability, NULL, pdma); if(pOutput!=NULL) { LPSTR pOutputAnsi; size_t cchBuf = ((fwCapability==DC_BINNAMES ? 24 : 64) * RetVal); _STACKALLOC((cchBuf * RetVal), pOutputAnsi); if(pOutputAnsi==NULL) { if(pdma) GodotHeapFree(pdma); return(0); } RetVal = DeviceCapabilitiesA(pDeviceAnsi, pPortAnsi, fwCapability, pOutputAnsi, pdma); if(RetVal > 0) { // Failure is -1 and 0 means nothing to convert so this // is a good conditional for the conversion. MultiByteToWideChar(g_acp, 0, pOutputAnsi, cchBuf, pOutput, cchBuf); } } break; } case DC_BINS: case DC_ENUMRESOLUTIONS: case DC_PAPERS: case DC_PAPERSIZE: // Output param is an array of values (LONG or WORD or POINT) // CONSIDER: Why bother will a special case here? RetVal = DeviceCapabilitiesA(pDeviceAnsi, pPortAnsi, fwCapability, (LPSTR)pOutput, pdma); break; default: // Output param is not used RetVal = DeviceCapabilitiesA(pDeviceAnsi, pPortAnsi, fwCapability, (LPSTR)pOutput, pdma); break; } if(pdma) GodotHeapFree(pdma); return(RetVal); } End= [EFunc] TemplateName=DialogBoxIndirectParamW Begin= INT_PTR __stdcall GodotDialogBoxIndirectParamW(HINSTANCE hInst, LPCDLGTEMPLATEW hdt, HWND hWnd, DLGPROC lpfn, LPARAM dwParam) { LPGODOTTLSINFO lpgti = GetThreadInfoSafe(TRUE); if(!lpgti) { SetLastError(ERROR_OUTOFMEMORY); return(0); } else { INT_PTR RetVal; INIT_WINDOW_SNIFF(lpgti->hHook); lpgti->pfnDlgProc = lpfn; RetVal = DialogBoxIndirectParamA(hInst, (LPCDLGTEMPLATEA)hdt, hWnd, &DialogProc, dwParam); TERM_WINDOW_SNIFF(lpgti->hHook); return(RetVal); } } End= [EFunc] TemplateName=DialogBoxParamW Begin= INT_PTR __stdcall GodotDialogBoxParamW(HINSTANCE hInst, LPCWSTR lpTemplate, HWND hWndParent, DLGPROC lpfn, LPARAM dwParam) { LPGODOTTLSINFO lpgti = GetThreadInfoSafe(TRUE); if(!lpgti) { SetLastError(ERROR_OUTOFMEMORY); return(0); } else { INT_PTR RetVal; LPSTR lpTemplateAnsi; GODOT_TO_ACP_STACKALLOC(lpTemplate, lpTemplateAnsi); lpgti->pfnDlgProc = lpfn; INIT_WINDOW_SNIFF(lpgti->hHook); RetVal=DialogBoxParamA(hInst, lpTemplateAnsi, hWndParent, &DialogProc, dwParam); TERM_WINDOW_SNIFF(lpgti->hHook); return RetVal; } } End= [EFunc] TemplateName=DispatchMessageW Begin= LRESULT __stdcall GodotDispatchMessageW(const MSG * lpMsg) { return(GodotDispatchMessage(mtDispatchMessage, NULL, NULL, (LPMSG)lpMsg)); } End= [EFunc] TemplateName=DlgDirListW Begin= int __stdcall GodotDlgDirListW(HWND hDlg, LPWSTR lpPathSpec, int nIDListBox, int nIDStaticPath, UINT uFileType) { // Begin locals int RetVal; LPSTR lpPathSpecAnsi; // Begin precall GODOT_TO_ACP_STACKALLOC(lpPathSpec, lpPathSpecAnsi); RetVal=DlgDirListA(hDlg, lpPathSpecAnsi, nIDListBox, nIDStaticPath, uFileType); if(RetVal) MultiByteToWideChar(g_acp, 0, lpPathSpecAnsi, -1, lpPathSpec, gwcslen(lpPathSpec)); // Finished return RetVal; } End= [EFunc] TemplateName=DlgDirListComboBoxW Begin= int __stdcall GodotDlgDirListComboBoxW(HWND hDlg, LPWSTR lpPathSpec, int nIDComboBox, int nIDStaticPath, UINT uFiletype) { // Begin locals int RetVal; LPSTR lpPathSpecAnsi; // Begin precall GODOT_TO_ACP_STACKALLOC(lpPathSpec, lpPathSpecAnsi); RetVal=DlgDirListComboBoxA(hDlg, lpPathSpecAnsi, nIDComboBox, nIDStaticPath, uFiletype); if(RetVal) MultiByteToWideChar(g_acp, 0, lpPathSpecAnsi, -1, lpPathSpec, gwcslen(lpPathSpec)); // Finished return RetVal; } End= [EFunc] TemplateName=DlgDirSelectComboBoxExW Begin= BOOL __stdcall GodotDlgDirSelectComboBoxExW(HWND hDlg, LPWSTR lpString, int nCount, int nIDComboBox) { BOOL RetVal; LPSTR lpStringAnsi; _STACKALLOC((nCount * g_mcs) + 1, lpStringAnsi); if(!lpStringAnsi) return(FALSE); RetVal=DlgDirSelectComboBoxExA(hDlg, lpStringAnsi, nCount, nIDComboBox); if(FSTRING_VALID(lpString) && FSTRING_VALID(lpStringAnsi)) MultiByteToWideChar(g_acp, 0, lpStringAnsi, -1, lpString, nCount); else if(FSTRING_VALID(lpString)) { lpString[0] = '\0'; } return RetVal; } End= [EFunc] TemplateName=DlgDirSelectExW Begin= BOOL __stdcall GodotDlgDirSelectExW(HWND hDlg, LPWSTR lpString, int nCount, int nIDListBox) { BOOL RetVal; LPSTR lpStringAnsi; _STACKALLOC((nCount * g_mcs) + 1, lpStringAnsi); if(!lpStringAnsi) { SetLastError(ERROR_STACK_OVERFLOW); return(FALSE); } RetVal=DlgDirSelectExA(hDlg, lpStringAnsi, nCount, nIDListBox); if(FSTRING_VALID(lpString) && FSTRING_VALID(lpStringAnsi)) MultiByteToWideChar(g_acp, 0, lpStringAnsi, -1, lpString, nCount); else if(FSTRING_VALID(lpString)) { lpString[0] = '\0'; } return RetVal; } End= [EFunc] TemplateName=DocumentPropertiesW Begin= LONG __stdcall GodotDocumentPropertiesW(HWND hWnd, HANDLE hPrinter, LPWSTR pDeviceName, PDEVMODEW pDevModeOutput, PDEVMODEW pDevModeInput, DWORD fMode) { // UNSUPPORTED FUNCTION: Documented as a failure stub LPDEVMODEA lpdmaOut = NULL; LPDEVMODEA lpdmaIn = NULL; LONG RetVal = 0; LPSTR pDeviceNameAnsi = NULL; ALLOCRETURN arDeviceName = GodotToAcpOnHeap(pDeviceName, &pDeviceNameAnsi); if(arDeviceName==arFailed) { SetLastError(ERROR_OUTOFMEMORY); return(0); } if((fMode & DM_OUT_BUFFER) && pDevModeOutput) { LONG cb = DocumentPropertiesA(hWnd, hPrinter, pDeviceNameAnsi, NULL, NULL, 0); _STACKALLOC(cb, lpdmaOut); if(!lpdmaOut && (cb > 0)) { if(arDeviceName==arAlloc) GodotHeapFree(pDeviceNameAnsi); return(0); } } if((fMode & DM_IN_BUFFER) && pDevModeInput) { lpdmaIn = GodotHeapAlloc(sizeof(DEVMODEA) + (pDevModeInput ? pDevModeInput->dmDriverExtra : 0)); if(lpdmaIn==NULL) { if(arDeviceName==arAlloc) GodotHeapFree(pDeviceNameAnsi); return(0); } ZeroMemory(lpdmaIn, sizeof(DEVMODEA) + (pDevModeInput ? pDevModeInput->dmDriverExtra : 0)); DevModeAfromW(lpdmaIn, pDevModeInput); } RetVal = DocumentPropertiesA(hWnd, hPrinter, pDeviceNameAnsi, lpdmaOut, lpdmaIn, fMode); if(fMode == 0) { // More accurate calculation of the DEVMODE size to return RetVal += sizeof(DEVMODEW) - sizeof(DEVMODEA); } else if(RetVal==IDOK && (fMode & DM_OUT_BUFFER)) { DevModeWfromA(pDevModeOutput, lpdmaOut); } if(arDeviceName==arAlloc) GodotHeapFree(pDeviceNameAnsi); if(lpdmaIn) GodotHeapFree(lpdmaIn); return(RetVal); } End= [EFunc] TemplateName=DragQueryFileW Begin= UINT __stdcall GodotDragQueryFileW(HDROP hDrop, UINT iFile, LPWSTR lpszFile, UINT cch) { UINT RetVal; if(iFile != 0xFFFFFFFF) { LPSTR lpszFileAnsi; if(lpszFile) { _STACKALLOC(cch * g_mcs, lpszFileAnsi); if(lpszFileAnsi==NULL) { return(0); } ZeroMemory(lpszFileAnsi, cch * g_mcs); } else lpszFileAnsi = NULL; RetVal=DragQueryFileA(hDrop, iFile, lpszFileAnsi, cch); if((RetVal > 0) && (lpszFile)) MultiByteToWideChar(g_acp, 0, lpszFileAnsi, -1, lpszFile, cch); } else { RetVal=DragQueryFileA(hDrop, iFile, (LPSTR)lpszFile, cch); } return RetVal; } End= [EFunc] TemplateName=DrawTextW Begin= int __stdcall GodotDrawTextW(HDC hDC, LPCWSTR lpString, int nCount, LPRECT lpRect, UINT uFormat) { int RetVal; LPSTR lpStringAnsi; BOOL fExtra =((uFormat & DT_MODIFYSTRING) && (uFormat & (DT_PATH_ELLIPSIS | DT_WORD_ELLIPSIS | DT_END_ELLIPSIS))); int Adj = (fExtra ? 4 : 0); UINT cpg = CpgFromHdc(hDC); UINT mcs = CbPerChOfCpg(cpg); if (FSTRING_VALID(lpString)) { size_t lpStringLength = gwcslen(lpString) + 1; _STACKALLOC((lpStringLength+Adj)*mcs, lpStringAnsi); if(lpStringAnsi==NULL) { return(0); } WideCharToMultiByte(cpg, 0, lpString, lpStringLength, lpStringAnsi, (lpStringLength+Adj)*mcs, NULL, NULL); } else lpStringAnsi = (LPSTR)lpString; RetVal=DrawTextA(hDC, lpStringAnsi, nCount, lpRect, uFormat); // Note that lpString is only modified if fExtraChars is True if (RetVal && fExtra) MultiByteToWideChar(cpg, 0, lpStringAnsi, -1, (LPWSTR)lpString, (gwcslen(lpString) + Adj)); return RetVal; } End= [EFunc] TemplateName=DrawTextExW Begin= int __stdcall GodotDrawTextExW( HDC hdc, LPWSTR lpchText, int cchText, LPRECT lprc, UINT dwDTF, LPDRAWTEXTPARAMS lpDTParams ) { int RetVal; LPSTR lpchTextAnsi; BOOL fExtra =((dwDTF & DT_MODIFYSTRING) && (dwDTF & (DT_PATH_ELLIPSIS | DT_WORD_ELLIPSIS | DT_END_ELLIPSIS))); int Adj = (fExtra ? 4 : 0); UINT cpg = CpgFromHdc(hdc); UINT mcs = CbPerChOfCpg(cpg); if (FSTRING_VALID(lpchText)) { size_t lpchTextAnsiLength = gwcslen(lpchText) + 1; _STACKALLOC((lpchTextAnsiLength+Adj)*mcs, lpchTextAnsi); if(lpchTextAnsi==NULL) { return(0); } WideCharToMultiByte(cpg, 0, lpchText, lpchTextAnsiLength, lpchTextAnsi, (lpchTextAnsiLength+Adj)*mcs, NULL, NULL); } else lpchTextAnsi = (LPSTR)lpchText; RetVal=DrawTextExA(hdc, lpchTextAnsi, cchText, lprc, dwDTF, lpDTParams); // Note that lpString is only modified if fExtraChars is True if (RetVal && fExtra) MultiByteToWideChar(cpg, 0, lpchTextAnsi, -1, (LPWSTR)lpchText, (gwcslen(lpchText) + Adj)); return RetVal; } End= [EFunc] TemplateName=EnableWindow Begin= BOOL __stdcall GodotEnableWindow(HWND hWnd, BOOL bEnable) { // We wrap this API in order to get consistent behavior on both // NT and Win9x. It seems that on NT, any non-zero value of bEnable // will enable the window. Based on empirical data, Win9x seems to // look at only the low 16 bits of bEnable. This causes a problem, // for example, if the caller passes a count of items with the intent // to enable a window when the count is >0. That will fail when the // count is a multiple of 64K, but will be nearly impossible to find // and fix the problem. See Visual Studio 7 bug # 178556 for an // example of such a bug. return(EnableWindow(hWnd, (bEnable != 0))); } End= [EFunc] TemplateName=EndUpdateResourceW Begin= BOOL __stdcall GodotEndUpdateResourceW(HANDLE hUpdate, BOOL fDiscard) { // UNSUPPORTED FUNCTION: Documented as a failure stub return(EndUpdateResourceInternalW(hUpdate, fDiscard)); } End= [EFunc] TemplateName=EnumCalendarInfoW Begin= BOOL __stdcall GodotEnumCalendarInfoW(CALINFO_ENUMPROCW lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType) { // Begin locals BOOL RetVal = FALSE; LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(FALSE); } if((lpgti->pfnCalendarInfo && (lpgti->pfnCalendarInfo != lpCalInfoEnumProc)) || lpgti->cCalendarInfo >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(FALSE); } lpgti->pfnCalendarInfo = lpCalInfoEnumProc; lpgti->cCalendarInfo++; RetVal=EnumCalendarInfoA(&EnumCalendarInfoProc, Locale, Calendar, CalType); lpgti->pfnCalendarInfo = NULL; lpgti->cCalendarInfo--; return RetVal; } End= [EFunc] TemplateName=EnumCalendarInfoExW Begin= BOOL __stdcall GodotEnumCalendarInfoExW(CALINFO_ENUMPROCEXW lpEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType) { // Begin locals BOOL RetVal = FALSE; if (s_pfnEnumCalendarInfoExA == NULL) { // Must allocate stuff for this API call s_pfnEnumCalendarInfoExA = (PFNeciea)GetKernelProc("EnumCalendarInfoExA"); } if (s_pfnEnumCalendarInfoExA) { LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(FALSE); } if((lpgti->pfnCalendarInfoEx && (lpgti->pfnCalendarInfoEx != lpEnumProcEx)) || lpgti->cCalendarInfoEx >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(FALSE); } lpgti->pfnCalendarInfoEx = lpEnumProcEx; lpgti->cCalendarInfoEx++; RetVal = (s_pfnEnumCalendarInfoExA (&EnumCalendarInfoProcEx, Locale, Calendar, CalType )); lpgti->pfnCalendarInfoEx = NULL; lpgti->cCalendarInfoEx--; } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return RetVal; } End= [EFunc] TemplateName=EnumClipboardFormats Begin= UINT __stdcall GodotEnumClipboardFormats(UINT uFormat) { UINT RetVal = EnumClipboardFormats(uFormat); if((RetVal==0) && (GetLastError() == 0)) { // The zero return with no error can mean one of three things to us: // 1) uFormat is one of our faux formats that we told them is valid // 2) uFormat is an entirely invalid format that is not really in anyone's chain // 3) uFormat is the last legitimate member of the chain according to the system BOOL fSystemLikes = IsClipboardFormatAvailable(uFormat); BOOL fGodotLikes = GodotIsClipboardFormatAvailable(uFormat); if(!fSystemLikes && fGodotLikes) { // This is case #1 above. Therefore, if this is CF_TEXT then // we have one more to pass, otherwise we are done. if(uFormat==CF_TEXT) RetVal = CF_OEMTEXT; } else if(!fSystemLikes && !fGodotLikes) { // This is case #2 above, nothing to do here at all } else { // This is case #3 above: our hardest one to do. Basically, we have to // add 0-2 formats to the chain: // a) if system has CF_TEXT but not CF_UNICODETEXT, then we pass CF_UNICODETEXT // b) if system has CF_UNICODETEXT but not CF_TEXT, then as pass CF_TEXT // (CF_OEMTEXT will be passed next time via case #1 above) // c) if system has neither, then we are done if(IsClipboardFormatAvailable(CF_TEXT) && !IsClipboardFormatAvailable(CF_UNICODETEXT)) { RetVal = CF_UNICODETEXT; } else if(IsClipboardFormatAvailable(CF_UNICODETEXT) && !IsClipboardFormatAvailable(CF_TEXT)) { RetVal = CF_TEXT; } } } return(RetVal); } End= [EFunc] TemplateName=EnumDateFormatsW Begin= BOOL __stdcall GodotEnumDateFormatsW(DATEFMT_ENUMPROCW lpDateFmtEnumProc, LCID Locale, DWORD dwFlags) { // Begin locals BOOL RetVal = FALSE; LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(FALSE); } if((lpgti->pfnDateFormats && (lpgti->pfnDateFormats != lpDateFmtEnumProc)) || lpgti->cDateFormats >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(FALSE); } lpgti->pfnDateFormats = lpDateFmtEnumProc; lpgti->cDateFormats++; RetVal=EnumDateFormatsA(&EnumDateFormatsProc, Locale, dwFlags); lpgti->pfnDateFormats = NULL; lpgti->cDateFormats--; return RetVal; } End= [EFunc] TemplateName=EnumDateFormatsExW Begin= BOOL __stdcall GodotEnumDateFormatsExW(DATEFMT_ENUMPROCEXW lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags) { // Begin locals BOOL RetVal = FALSE; if (s_pfnEnumDateFormatsExA == NULL) { // Must allocate stuff for this API call s_pfnEnumDateFormatsExA = (PFNedfea)GetKernelProc("EnumDateFormatsExA"); } if (s_pfnEnumDateFormatsExA) { LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(FALSE); } if((lpgti->pfnDateFormatsEx && (lpgti->pfnDateFormatsEx != lpDateFmtEnumProcEx)) || lpgti->cDateFormats >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(FALSE); } lpgti->pfnDateFormatsEx = lpDateFmtEnumProcEx; lpgti->cDateFormats++; RetVal = (s_pfnEnumDateFormatsExA (&EnumDateFormatsProcEx, Locale, dwFlags)); lpgti->pfnDateFormatsEx = NULL; lpgti->cDateFormats--; } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return RetVal; } End= [EFunc] TemplateName=EnumDisplayDevicesW Begin= BOOL __stdcall GodotEnumDisplayDevicesW(LPCWSTR lpDevice, DWORD iDevNum, PDISPLAY_DEVICEW pddw, DWORD dwFlags) { BOOL RetVal = FALSE; if (!s_pfnEnumDisplayDevicesA) // Must allocate stuff for this API call s_pfnEnumDisplayDevicesA = (PFNedda)GetUserProc("EnumDisplayDevicesA"); if (s_pfnEnumDisplayDevicesA) { LPSTR lpDeviceAnsi; DISPLAY_DEVICEA dda; GODOT_TO_ACP_STACKALLOC(lpDevice, lpDeviceAnsi); ZeroMemory(&dda, sizeof(DISPLAY_DEVICEA)); dda.cb = sizeof(DISPLAY_DEVICEA); RetVal = (s_pfnEnumDisplayDevicesA(lpDeviceAnsi, iDevNum, &dda, dwFlags)); if(RetVal) { MultiByteToWideChar(g_acp, 0, dda.DeviceName, -1, pddw->DeviceName, 32); MultiByteToWideChar(g_acp, 0, dda.DeviceString, -1, pddw->DeviceString, 128); pddw->StateFlags = dda.StateFlags; MultiByteToWideChar(g_acp, 0, dda.DeviceID, -1, pddw->DeviceID, 128); MultiByteToWideChar(g_acp, 0, dda.DeviceKey, -1, pddw->DeviceKey, 128); } } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return RetVal; } End= [EFunc] TemplateName=EnumDisplaySettingsW Begin= BOOL __stdcall GodotEnumDisplaySettingsW(LPCWSTR lpszDeviceName, DWORD iModeNum, LPDEVMODEW lpDevMode) { // Begin locals BOOL RetVal; LPSTR lpszDeviceNameAnsi; DEVMODEA dma; // Begin precall GODOT_TO_ACP_STACKALLOC(lpszDeviceName, lpszDeviceNameAnsi); if(!lpszDeviceNameAnsi && lpszDeviceName) return(FALSE); RetVal=EnumDisplaySettingsA(lpszDeviceNameAnsi, iModeNum, &dma); if(RetVal && lpDevMode) { // We assume that lpDevMode will have room for the extra bytes, if any DevModeWfromA(lpDevMode, &dma); } // Finished return RetVal; } End= [EFunc] TemplateName=EnumDisplaySettingsExW Begin= BOOL __stdcall GodotEnumDisplaySettingsExW(LPCWSTR lpszDeviceName, DWORD iModeNum, LPDEVMODEW lpDevMode, DWORD dwFlags) { // Begin locals BOOL RetVal = FALSE; if (s_pfnEnumDisplaySettingsExA == NULL) { // Must allocate stuff for this API call s_pfnEnumDisplaySettingsExA = (PFNedsea)GetUserProc("EnumDisplaySettingsExA"); } if (s_pfnEnumDisplaySettingsExA) { LPSTR lpszDeviceNameAnsi; DEVMODEA dma; GODOT_TO_ACP_STACKALLOC(lpszDeviceName, lpszDeviceNameAnsi); if(!lpszDeviceNameAnsi && lpszDeviceName) return(FALSE); ZeroMemory(&dma, sizeof(DEVMODEA)); dma.dmSize = sizeof(DEVMODEA); RetVal = (s_pfnEnumDisplaySettingsExA(lpszDeviceNameAnsi, iModeNum, &dma, dwFlags)); if(RetVal && lpDevMode) { // We assume that lpDevMode will have room for the extra bytes, if any DevModeWfromA(lpDevMode, &dma); } } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return RetVal; } End= [EFunc] TemplateName=EnumerateSecurityPackagesW Begin= SECURITY_STATUS __stdcall GodotEnumerateSecurityPackagesW(unsigned long int * pcPackages, PSecPkgInfoW * ppPackageInfo) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(SEC_E_UNSUPPORTED_FUNCTION); } End= [EFunc] TemplateName=EnumFontFamiliesW Begin= int __stdcall GodotEnumFontFamiliesW(HDC hdc, LPCWSTR lpszFamily, FONTENUMPROCW lpEnumFontFamProc, LPARAM lParam) { // Begin locals int RetVal; LPSTR lpszFamilyAnsi; LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(0); } if((lpgti->pfnFontFamilies && (lpgti->pfnFontFamilies != lpEnumFontFamProc)) || lpgti->cFontFamilies >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(0); } lpgti->pfnFontFamilies = lpEnumFontFamProc; lpgti->cFontFamilies++; GODOT_TO_ACP_STACKALLOC(lpszFamily, lpszFamilyAnsi); RetVal=EnumFontFamiliesA(hdc, lpszFamilyAnsi, (FONTENUMPROCA)&EnumFontFamProc, lParam); lpgti->pfnFontFamilies = NULL; lpgti->cFontFamilies--; return RetVal; } End= [EFunc] TemplateName=EnumFontFamiliesExW Begin= int __stdcall GodotEnumFontFamiliesExW( HDC hdc, LPLOGFONTW lpLogfont, FONTENUMPROCW lpEnumFontFamExProc, LPARAM lParam, DWORD dwFlags ) { // Begin locals int RetVal; LOGFONTA lfa; LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(0); } if((lpgti->pfnFontFamiliesEx && (lpgti->pfnFontFamiliesEx != lpEnumFontFamExProc)) || lpgti->cFontFamiliesEx >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(0); } lpgti->pfnFontFamiliesEx = lpEnumFontFamExProc; lpgti->cFontFamiliesEx++; ZeroMemory(&lfa, sizeof(LOGFONTA)); LogFontAfromW(&lfa, lpLogfont); RetVal=EnumFontFamiliesExA(hdc, &lfa, (FONTENUMPROCA)&EnumFontFamExProc, lParam, dwFlags); lpgti->pfnFontFamiliesEx = NULL; lpgti->cFontFamiliesEx--; return RetVal; } End= [EFunc] TemplateName=EnumFontsW Begin= int __stdcall GodotEnumFontsW(HDC hdc, LPCWSTR lpFaceName, FONTENUMPROCW lpFontFunc, LPARAM lParam) { // Begin locals int RetVal; LPSTR lpFaceNameAnsi; LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(0); } if((lpgti->pfnFonts && (lpgti->pfnFonts != lpFontFunc)) || lpgti->cFonts >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(0); } lpgti->pfnFonts = lpFontFunc; lpgti->cFonts++; GODOT_TO_ACP_STACKALLOC(lpFaceName, lpFaceNameAnsi); RetVal=EnumFontsA(hdc, lpFaceNameAnsi, &EnumFontsProc, lParam); lpgti->pfnFonts = NULL; lpgti->cFonts--; return RetVal; } End= [EFunc] TemplateName=EnumICMProfilesW Begin= int __stdcall GodotEnumICMProfilesW(HDC hDC, ICMENUMPROCW lpEnumICMProfilesFunc, LPARAM lParam) { // Begin locals int RetVal; LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(0); } if((lpgti->pfnICMProfiles && (lpgti->pfnICMProfiles != lpEnumICMProfilesFunc)) || lpgti->cICMProfiles >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(0); } lpgti->pfnICMProfiles = lpEnumICMProfilesFunc; lpgti->cICMProfiles++; RetVal=EnumICMProfilesA(hDC, &EnumICMProfilesProcCallback, lParam); lpgti->pfnICMProfiles = NULL; lpgti->cICMProfiles--; return RetVal; } End= [EFunc] TemplateName=EnumMonitorsW Begin= BOOL __stdcall GodotEnumMonitorsW(LPWSTR _noname0, DWORD _noname1, LPBYTE _noname2, DWORD _noname3, LPDWORD _noname4, LPDWORD _noname5) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(EnumMonitorsW(_noname0, _noname1, _noname2, _noname3, _noname4, _noname5)); } End= [EFunc] TemplateName=EnumPortsW Begin= BOOL __stdcall GodotEnumPortsW(LPWSTR _noname0, DWORD _noname1, LPBYTE _noname2, DWORD _noname3, LPDWORD _noname4, LPDWORD _noname5) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(EnumPortsW(_noname0, _noname1, _noname2, _noname3, _noname4, _noname5)); } End= [EFunc] TemplateName=EnumPrinterDriversW Begin= BOOL __stdcall GodotEnumPrinterDriversW(LPWSTR _noname0, LPWSTR _noname1, DWORD _noname2, LPBYTE _noname3, DWORD _noname4, LPDWORD _noname5, LPDWORD _noname6) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(EnumPrinterDriversW(_noname0, _noname1, _noname2, _noname3, _noname4, _noname5, _noname6)); } End= [EFunc] TemplateName=EnumPrintersW Begin= BOOL __stdcall GodotEnumPrintersW(DWORD _noname0, LPWSTR _noname1, DWORD _noname2, LPBYTE _noname3, DWORD _noname4, LPDWORD _noname5, LPDWORD _noname6) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(EnumPrintersW(_noname0, _noname1, _noname2, _noname3, _noname4, _noname5, _noname6)); } End= [EFunc] TemplateName=EnumPrintProcessorDatatypesW Begin= BOOL __stdcall GodotEnumPrintProcessorDatatypesW(LPWSTR _noname0, LPWSTR _noname1, DWORD _noname2, LPBYTE _noname3, DWORD _noname4, LPDWORD _noname5, LPDWORD _noname6) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(EnumPrintProcessorDatatypesW(_noname0, _noname1, _noname2, _noname3, _noname4, _noname5, _noname6)); } End= [EFunc] TemplateName=EnumPrintProcessorsW Begin= BOOL __stdcall GodotEnumPrintProcessorsW(LPWSTR pName, LPWSTR pEnvironment, DWORD Level, LPBYTE pPrintProcessorInfo, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned) { // UNSUPPORTED FUNCTION: Documented as a failure stub LPSTR pNameA, pEnvironmentA; BOOL RetVal; DWORD cbNeeded = 0; DWORD cReturned = 0; GODOT_TO_ACP_STACKALLOC(pName, pNameA); GODOT_TO_ACP_STACKALLOC(pEnvironment, pEnvironmentA); if((!pNameA && pName) || (!pEnvironmentA && pEnvironment)) { SetLastError(ERROR_STACK_OVERFLOW); return(FALSE); } if(pPrintProcessorInfo==NULL || cbBuf==0) { RetVal = EnumPrintProcessorsA(pNameA, pEnvironmentA, Level, NULL, 0, &cbNeeded, &cReturned); // Note that the size we return is potentially twice as // big as it needs to be on DBCS platforms. Unfortunate, // but there is not much else we can do. if(RetVal==FALSE && GetLastError()== ERROR_INSUFFICIENT_BUFFER && pcbNeeded) *pcbNeeded = cbNeeded * sizeof(WCHAR); if(pcReturned) *pcReturned = cReturned; } else { LPBYTE pPrintProcessorInfoA; DWORD cbBufA = (FDBCS_CPG(g_acp ? cbBuf : cbBuf / 2)); _STACKALLOC(cbBufA, pPrintProcessorInfoA); if(pPrintProcessorInfoA==NULL) { return(FALSE); } RetVal = EnumPrintProcessorsA(pNameA, pEnvironmentA, Level, pPrintProcessorInfoA, cbBufA, &cbNeeded, &cReturned); if(RetVal==FALSE && GetLastError()== ERROR_INSUFFICIENT_BUFFER && pcbNeeded) *pcbNeeded = cbNeeded * sizeof(WCHAR); else if(RetVal) { PPRINTPROCESSOR_INFO_1W pPPIW = (PPRINTPROCESSOR_INFO_1W)pPrintProcessorInfo; PPRINTPROCESSOR_INFO_1A pPPIA = (PPRINTPROCESSOR_INFO_1A)pPrintProcessorInfoA; DWORD dwOffsetStr = (sizeof(PRINTPROCESSOR_INFO_1A) * cReturned); DWORD ippi; int cch = 0; cbBufA -= dwOffsetStr; for(ippi = 0; ippi < cReturned ; ippi++) { LPWSTR lpwz = (LPWSTR)pPrintProcessorInfo + dwOffsetStr; cch = MultiByteToWideChar(g_acp, 0, pPPIA[ippi].pName, -1, lpwz, cbBufA/sizeof(WCHAR)); pPPIW[ippi].pName = lpwz; dwOffsetStr += cch; cbBufA -= cch; } if(pcbNeeded) *pcbNeeded = dwOffsetStr + cch - (DWORD)pPrintProcessorInfo; } if(pcReturned) *pcReturned = cReturned; } return(RetVal); } End= [EFunc] TemplateName=EnumPropsA Begin= int __stdcall GodotEnumPropsA(HWND hWnd, PROPENUMPROCA lpEnumFunc) { // Begin locals int RetVal = 0; LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(0); } if((lpgti->pfnPropA && (lpgti->pfnPropA != lpEnumFunc)) || lpgti->cPropA >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(0); } lpgti->pfnPropA = lpEnumFunc; lpgti->cPropA++; RetVal=EnumPropsA(hWnd, &PropEnumProcA); lpgti->pfnPropA = NULL; lpgti->cPropA--; return RetVal; } End= [EFunc] TemplateName=EnumPropsW Begin= int __stdcall GodotEnumPropsW(HWND hWnd, PROPENUMPROCW lpEnumFunc) { // Begin locals int RetVal = 0; LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(0); } if((lpgti->pfnProp && (lpgti->pfnProp != lpEnumFunc)) || lpgti->cProp >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(0); } lpgti->pfnProp = lpEnumFunc; lpgti->cProp++; RetVal=EnumPropsA(hWnd, &PropEnumProc); lpgti->pfnProp = NULL; lpgti->cProp--; return RetVal; } End= [EFunc] TemplateName=EnumPropsExA Begin= int __stdcall GodotEnumPropsExA(HWND hWnd, PROPENUMPROCEXA lpEnumFunc, LPARAM lParam) { // Begin locals int RetVal; LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(0); } if((lpgti->pfnPropExA && (lpgti->pfnPropExA != lpEnumFunc)) || lpgti->cPropExA >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(0); } lpgti->pfnPropExA = lpEnumFunc; lpgti->cPropExA++; RetVal=EnumPropsExA(hWnd, &PropEnumProcExA, lParam); lpgti->pfnPropExA = NULL; lpgti->cPropExA--; return RetVal; } End= [EFunc] TemplateName=EnumPropsExW Begin= int __stdcall GodotEnumPropsExW(HWND hWnd, PROPENUMPROCEXW lpEnumFunc, LPARAM lParam) { // Begin locals int RetVal; LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(0); } if((lpgti->pfnPropEx && (lpgti->pfnPropEx != lpEnumFunc)) || lpgti->cPropEx >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(0); } lpgti->pfnPropEx = lpEnumFunc; lpgti->cPropEx++; RetVal=EnumPropsExA(hWnd, &PropEnumProcEx, lParam); lpgti->pfnPropEx = NULL; lpgti->cPropEx--; return RetVal; } End= [EFunc] TemplateName=EnumSystemCodePagesW Begin= #define NLS_CODEPAGE_KEY "SYSTEM\\CurrentControlSet\\Control\\nls\\codepage" #define MAX_KEYVALUEFULLINFO 256 /* max string length for key value full info */ #define ENUM_MAX_CP_SIZE 6 /* max size for cp id in registry */ BOOL __stdcall GodotEnumSystemCodePagesW(CODEPAGE_ENUMPROCW lpCodePageEnumProc, DWORD dwFlags) { // Begin locals BOOL fInstalled; BOOL fCallEnumProc; HKEY hKey; LPSTR lpszValue; LPSTR lpszData; WCHAR wzValueString[MAX_KEYVALUEFULLINFO]; BYTE pStatic1[MAX_KEYVALUEFULLINFO]; BYTE pStatic2[MAX_KEYVALUEFULLINFO]; ULONG cbValue; /* size of value */ ULONG cbData; /* # bytes written Data */ DWORD dwIndex = 0; DWORD dwType; LONG rc; BOOL fCancel = FALSE; // Invalid Parameter Check: // (function pointer is null) if (lpCodePageEnumProc == NULL) { SetLastError( ERROR_INVALID_PARAMETER ); return ( FALSE ); } // Invalid Flags Check: // - flags other than valid ones // - more than one of either supported or installed if ( (dwFlags != CP_INSTALLED) && (dwFlags != CP_SUPPORTED) ) { SetLastError(ERROR_INVALID_FLAGS); return (FALSE); } // Initialize flag option. fInstalled = dwFlags & CP_INSTALLED; // Loop through the code page ids in the registry, call the function // pointer for each one that meets the flag criteria. // End loop if either FALSE is returned from the callback function // or the end of the list is reached. // Always need to ignore the ACP, OEMCP, MACCP, and OEMHAL entries. if (ERROR_SUCCESS != RegOpenKeyExA(HKEY_LOCAL_MACHINE, NLS_CODEPAGE_KEY, 0, KEY_QUERY_VALUE, &hKey) ) { SetLastError(ERROR_BADDB); return (FALSE); } // Initialize some buffers ZeroMemory(pStatic1, MAX_KEYVALUEFULLINFO); ZeroMemory(pStatic2, MAX_KEYVALUEFULLINFO); lpszValue = (LPSTR)pStatic1; lpszData = (LPSTR)pStatic2; cbValue = MAX_KEYVALUEFULLINFO; cbData = MAX_KEYVALUEFULLINFO; // Call the first time rc = RegEnumValueA(hKey, dwIndex, lpszValue, &cbValue, NULL, &dwType, (LPBYTE)lpszData, &cbData); while (rc != ERROR_NO_MORE_ITEMS) { fCallEnumProc = TRUE; if (rc != ERROR_SUCCESS) { // If we get a different error, then the registry // is corrupt. Just return FALSE. SetLastError(ERROR_BADDB); RegCloseKey(hKey); return (FALSE); } // Check character size of the system CodePage value if ( (cbValue >= ENUM_MAX_CP_SIZE) || ((*lpszValue < '0') || (*lpszValue > '9')) ) fCallEnumProc = FALSE; // Check flag to call the callback function and size of CodePage value. if (fCallEnumProc) { if ( !fInstalled || (fInstalled && (*lpszData)) ) { // Convert the string to Unicode ZeroMemory(wzValueString, MAX_KEYVALUEFULLINFO * sizeof(WCHAR)); MultiByteToWideChar(g_acp, 0, lpszValue, -1, wzValueString, MAX_KEYVALUEFULLINFO - 1); // Call the callback function. if (((*lpCodePageEnumProc)(wzValueString)) != TRUE) { fCancel = TRUE; break; } } } // Increment enumeration index value and get the next enumeration. // Initialize buffer of system locale value & data variables dwIndex++; ZeroMemory(pStatic1, MAX_KEYVALUEFULLINFO); ZeroMemory(pStatic2, MAX_KEYVALUEFULLINFO); lpszValue = (LPSTR)pStatic1; lpszData = (LPSTR)pStatic2; cbValue = MAX_KEYVALUEFULLINFO; cbData = MAX_KEYVALUEFULLINFO; rc = RegEnumValueA(hKey, dwIndex, lpszValue, &cbValue, NULL, &dwType, (LPBYTE)lpszData, &cbData); } // If they have not cancelled yet, tack on custom ones if(!fCancel) { // UTF-7 if ((* lpCodePageEnumProc)(L"65000")) { // UTF-8 if ((* lpCodePageEnumProc)(L"65001")) { // GB 18030: we test the "installed" bit by whether or not // we can get a handle to the DLL via our LoadLibrary call. if(!fInstalled || (fInstalled && GetGB18030Handle())) (* lpCodePageEnumProc)(L"54936"); } } } // Returns success if we made it this far, even if they cancelled RegCloseKey(hKey); return(TRUE); } End= [EFunc] TemplateName=EnumSystemLocalesW Begin= BOOL __stdcall GodotEnumSystemLocalesW(LOCALE_ENUMPROCW lpLocaleEnumProc, DWORD dwFlags) { // Begin locals BOOL RetVal; LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(FALSE); } if((lpgti->pfnLocales && (lpgti->pfnLocales != lpLocaleEnumProc)) || lpgti->cLocales >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(FALSE); } lpgti->pfnLocales = lpLocaleEnumProc; RetVal=EnumSystemLocalesA(&EnumLocalesProc, dwFlags); lpgti->pfnLocales = NULL; return RetVal; } End= [EFunc] TemplateName=EnumTimeFormatsW Begin= BOOL __stdcall GodotEnumTimeFormatsW(TIMEFMT_ENUMPROCW lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags) { // Begin locals BOOL RetVal; LPGODOTTLSINFO lpgti; if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(FALSE); } if((lpgti->pfnTimeFormats && (lpgti->pfnTimeFormats != lpTimeFmtEnumProc)) || lpgti->cTimeFormats >= GODOTMAXREFCOUNT) { // A hook is already defined and it is a different hook. We // must fail the call here. SetLastError(ERROR_INVALID_FILTER_PROC); return(FALSE); } lpgti->pfnTimeFormats = lpTimeFmtEnumProc; lpgti->cTimeFormats++; RetVal=EnumTimeFormatsA(&EnumTimeFormatsProc, Locale, dwFlags); lpgti->pfnTimeFormats = NULL; lpgti->cTimeFormats--; return RetVal; } End= [EFunc] TemplateName=ExpandEnvironmentStringsW Begin= DWORD __stdcall GodotExpandEnvironmentStringsW(LPCWSTR lpSrc, LPWSTR lpDst, DWORD nSize) { // Begin locals DWORD RetVal; LPSTR lpSrcAnsi; LPSTR lpDstAnsi; _STACKALLOC((nSize*g_mcs)+1, lpDstAnsi); GODOT_TO_ACP_STACKALLOC(lpSrc, lpSrcAnsi); if((!lpSrcAnsi && lpSrc) || (!lpDstAnsi)) { return(0); } ZeroMemory(lpDstAnsi, (nSize*g_mcs)+1); RetVal=ExpandEnvironmentStringsA(lpSrcAnsi, lpDstAnsi, nSize); if(RetVal <= nSize) { // Only convert if the call succeeded; RetVal will // always contain the size whether the function // succeeded or not MultiByteToWideChar(g_acp, 0, lpDstAnsi, -1, lpDst, RetVal); } // Finished return RetVal; } End= [EFunc] TemplateName=ExtractIconW Begin= HICON __stdcall GodotExtractIconW( HINSTANCE hInst, LPCWSTR lpszExeFileName, UINT nIconIndex ) { LPSTR lpszExeFileNameAnsi; GODOT_TO_ACP_STACKALLOC(lpszExeFileName, lpszExeFileNameAnsi); return(ExtractIconA(hInst, lpszExeFileNameAnsi, nIconIndex)); } End= [EFunc] TemplateName=ExtractIconExW Begin= UINT __stdcall GodotExtractIconExW(LPCWSTR lpszFile, int nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons) { LPSTR lpszFileAnsi; GODOT_TO_ACP_STACKALLOC(lpszFile, lpszFileAnsi); return(ExtractIconExA(lpszFileAnsi, nIconIndex, phiconLarge, phiconSmall, nIcons)); } End= [EFunc] TemplateName=ExtTextOutW Begin= BOOL __stdcall GodotExtTextOutW(HDC hdc, int X, int Y, UINT eto, const LPRECT lprc, LPCWSTR lpString, UINT cbCount, const PINT lpDx) { // Obtained all logic here from Office's MsoExtTextOutW function. :-) if ((!lpString) || (cbCount == 0)) { char chT; return ExtTextOutA(hdc, X, Y, eto, lprc, &chT, cbCount, lpDx); } // Optimize for all < 128 case // CONSIDER: This code could likely be faster, couldn't it??? if (!(eto & ETO_GLYPH_INDEX) && cbCount < 256 && lpString[0] <= 127) { char lpchA[256]; register UINT ich; BOOL fAscii = TRUE; // Optimize for the pure ASCII case for (ich = 0; ich < cbCount; ich++) { WCHAR wch = lpString[ich]; if ( wch <= 127 ) lpchA[ich] = (char) wch; else { fAscii = FALSE; break; } } if (fAscii) return ExtTextOutA(hdc, X, Y, eto, lprc, lpchA, cbCount, lpDx); } // Call the 'W' version of the API, its safe now! return ExtTextOutW(hdc, X, Y, eto, lprc, lpString, cbCount, lpDx); } End= [EFunc] TemplateName=FillConsoleOutputCharacterW Begin= BOOL __stdcall GodotFillConsoleOutputCharacterW( HANDLE hConsoleOutput, WCHAR cCharacter, DWORD nLength, COORD dwWriteCoord, LPDWORD lpNumberOfCharsWritten ) { // Begin locals char * cCharacterAnsi[2]; WideCharToMultiByte(g_oemcp, 0, (LPWSTR)&cCharacter, 1, (LPSTR)&cCharacterAnsi, 2, NULL, NULL); // Call the 'A' version of the API return(FillConsoleOutputCharacterA(hConsoleOutput, *cCharacterAnsi[0], nLength, dwWriteCoord, lpNumberOfCharsWritten )); } End= [EFunc] TemplateName=FindExecutableW Begin= HINSTANCE __stdcall GodotFindExecutableW(LPCWSTR lpFile, LPCWSTR lpDirectory, LPWSTR lpResult) { // UNSUPPORTED FUNCTION: Documented as a failure stub char lpResultAnsi[MAX_PATH + 1]; LPSTR lpFileAnsi, lpDirectoryAnsi; HINSTANCE RetVal; GODOT_TO_ACP_STACKALLOC(lpFile, lpFileAnsi); GODOT_TO_ACP_STACKALLOC(lpDirectory, lpDirectoryAnsi); if((!lpFileAnsi && lpFile) || (!lpDirectoryAnsi && lpDirectory)) { return(0); } RetVal = FindExecutableA(lpFileAnsi, lpDirectoryAnsi, lpResultAnsi); if(lpResult) { if(RetVal) MultiByteToWideChar(g_acp, 0, lpResultAnsi, -1, lpResult, MAX_PATH); else *lpResult = L'\0'; } return(RetVal); } End= [EFunc] TemplateName=FindFirstChangeNotificationW Begin= HANDLE __stdcall GodotFindFirstChangeNotificationW(LPCWSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter) { // Begin locals LPSTR lpPathNameAnsi; // Begin precall GODOT_TO_CPG_STACKALLOC(lpPathName, lpPathNameAnsi, FILES_CPG, g_mcs); if(lpPathNameAnsi==NULL) { return(INVALID_HANDLE_VALUE); } return(FindFirstChangeNotificationA(lpPathNameAnsi, bWatchSubtree, dwNotifyFilter)); } End= [EFunc] TemplateName=FindFirstFileW Begin= // We need an alternate "default" char when looking for file names, because the // usual "?" is a valid wildcard character. For other file handling functions, // the "?" is illegal so we can leave the call alone and let the API itself // throw the error and call SetLastError. const char c_szAltDefaultChar[] = "<"; HANDLE __stdcall GodotFindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData) { // Begin locals HANDLE RetVal; LPSTR lpFileNameAnsi; size_t lpFileNameLength; WIN32_FIND_DATAA ffda; // Begin precall ZeroMemory(&ffda, sizeof(WIN32_FIND_DATAA)); if (FSTRING_VALID(lpFileName)) { lpFileNameLength = gwcslen(lpFileName)+1; _STACKALLOC(lpFileNameLength*g_mcs, lpFileNameAnsi); if(lpFileNameAnsi==NULL) { return(0); } WideCharToMultiByte(FILES_CPG, WC_DEFAULTCHAR|WC_COMPOSITECHECK, // enable default char handling lpFileName, lpFileNameLength, lpFileNameAnsi, lpFileNameLength*g_mcs, c_szAltDefaultChar, NULL); } else lpFileNameAnsi = (LPSTR)lpFileName; RetVal=FindFirstFileA(lpFileNameAnsi, &ffda); if(RetVal != INVALID_HANDLE_VALUE) Win32FindDataWfromA(lpFindFileData, &ffda); // Finished return RetVal; } End= [EFunc] TemplateName=FindNextFileW Begin= BOOL __stdcall GodotFindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData) { // Begin locals BOOL RetVal; WIN32_FIND_DATAA ffda; // Call the 'A' version of the API ZeroMemory(&ffda, sizeof(WIN32_FIND_DATAA)); RetVal=FindNextFileA(hFindFile, &ffda); // Begin postcall if(RetVal) Win32FindDataWfromA(lpFindFileData, &ffda); // Finished return RetVal; } End= [EFunc] TemplateName=FindResourceW Begin= HRSRC __stdcall GodotFindResourceW(HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType) { // We must wrap this function, see GodotFindResourceExW for more info. // Just call through to GodotFindResourceExW with 0 for the language, // anyway (which is all the Win9x code does). return GodotFindResourceExW(hModule, lpType, lpName, 0); } End= [EFunc] TemplateName=FindResourceExW Begin= HRSRC __stdcall GodotFindResourceExW(HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage) { // We must wrap this function, even though it works on Win9x as // Unicode, due to OSR v 4.1 bug # 92854. They were always calling // LocalFree without alloc'ing, which corrupts the heap. if (FWIN95_OR_98()) { // Copy the params to stack variables. Win95/Win98 will fail in // their call to LocalFree, but they ignore failure in teardown. LPWSTR lpTypeC, lpNameC; HRSRC RetVal; if(FSTRING_VALID(lpType)) { _STACKALLOC((gwcslen(lpType) + 1) * sizeof(WCHAR), lpTypeC); if(lpTypeC==NULL) { return(0); } gwcscpy(lpTypeC, lpType); } else lpTypeC = (LPWSTR)lpType; if(FSTRING_VALID(lpName)) { _STACKALLOC((gwcslen(lpName) + 1) * sizeof(WCHAR), lpNameC); if(lpNameC==NULL) { return(0); } gwcscpy(lpNameC, lpName); } else lpNameC = (LPWSTR)lpName; RetVal = FindResourceExW(hModule, lpTypeC, lpNameC, wLanguage); // If the last error is invalid handle but the function succeeded, then lets // assume it came from the bogus LocalFree call and clear things out here. if ((RetVal != 0) && (GetLastError() == ERROR_INVALID_HANDLE)) SetLastError(ERROR_SUCCESS); return (RetVal); } // WinME case return FindResourceExW(hModule, lpType, lpName, wLanguage); } End= [EFunc] TemplateName=FindTextW Begin= HWND __stdcall GodotFindTextW(LPFINDREPLACEW lpfr) { return(FindReplaceTextHelper(lpfr, TRUE)); } End= [EFunc] TemplateName=FindWindowW Begin= HWND __stdcall GodotFindWindowW(LPCWSTR lpszClass, LPCWSTR lpszWindow) { LPSTR lpszClassAnsi, lpszWindowAnsi; GODOT_TO_ACP_STACKALLOC(lpszClass, lpszClassAnsi); GODOT_TO_ACP_STACKALLOC(lpszWindow, lpszWindowAnsi); if((!lpszClassAnsi && lpszClass) || (!lpszWindowAnsi && lpszWindow)) return(0); return(FindWindowA(lpszClassAnsi, lpszWindowAnsi)); } End= [EFunc] TemplateName=FindWindowExW Begin= HWND __stdcall GodotFindWindowExW(HWND hwndParent, HWND hwndChildAfter, LPCWSTR lpszClass, LPCWSTR lpszWindow) { LPSTR lpszClassAnsi, lpszWindowAnsi; GODOT_TO_ACP_STACKALLOC(lpszClass, lpszClassAnsi); GODOT_TO_ACP_STACKALLOC(lpszWindow, lpszWindowAnsi); if((!lpszClassAnsi && lpszClass) || (!lpszWindowAnsi && lpszWindow)) return(0); return(FindWindowExA(hwndParent, hwndChildAfter, lpszClassAnsi, lpszWindowAnsi)); } End= [EFunc] TemplateName=FormatMessageW Begin= DWORD __stdcall GodotFormatMessageW(DWORD dwFlags, LPCVOID lpSource, DWORD dwMsgId, DWORD dwLangId, LPWSTR lpBuffer, DWORD nSize, va_list * Args) { LPSTR lpSourceA; // "A" wrapper for lpSource va_list * ArgsA; // "A" wrapper for Args DWORD RetVal; // the return value LPSTR szBuffer; // "A" wrapper for lpBuffer UINT cpg; // code page for the conversions, if any UINT mcs; // max bytes per character LPSTR szScratch = NULL; // Our scratchpad buffer that we keep our strings in BOOL fAllocBuffer = (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER); // Take care of code page issues, and handle lpSource if (dwFlags & FORMAT_MESSAGE_FROM_STRING) { cpg = g_acp; mcs = g_mcs; GODOT_TO_ACP_STACKALLOC(lpSource, lpSourceA); } else { cpg = CpgFromLocale(dwLangId); mcs = CbPerChOfCpg(cpg); lpSourceA = (LPSTR)lpSource; } // First lets take care of Args, if we need to if((Args == NULL) || (dwFlags & FORMAT_MESSAGE_IGNORE_INSERTS)) { // They passed in no args, so lets give them no Args! ArgsA = NULL; szScratch = NULL; } else { PVOID pBuffer = NULL; // Ok, what we have to do here is call FormatMessage and ignore // inserts so we can get the unformatted string. We will use it // later to get arg counts and find out which args are strings. RetVal = FormatMessageA((dwFlags | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_ALLOCATE_BUFFER), lpSourceA, dwMsgId, dwLangId, (char*)&pBuffer, nSize, NULL); if(RetVal == 0) { // We did not even make it THIS far; lets give up return(0); } else { UINT rgConv[MAXINSERTS]; LPSTR pch; UINT cItems = 0; UINT cStrings = 0; // Init the shadow array: this way any inserts not // included will default to non-string parameters ZeroMemory(rgConv, (sizeof(UINT) * (MAXINSERTS))); // Ok, pBuffer points to the string. Use it, filling rgbString so we know // whether each param is a string or not, and also so we know the count for (pch = (LPSTR)pBuffer; *pch; pch++) { CHAR szNum[2]; UINT iNum; if (*pch == L'%') { pch++; // Found an insertion. Get the digit or two. if (*pch == '0') continue; // "%0" is special if (*pch < '0' || *pch > '9') { // skip % followed by nondigit continue; } szNum[0] = '\0'; szNum[1] = '\0'; // Move one past the digit we just detected pch++; if (*pch >= '0' && *pch <= '9') { // Move one past the optional second digit we just // detected and lets make those two digits a number pch++; memcpy(szNum, pch - 2, (sizeof(CHAR) * 2)); iNum = MiniAtoI(szNum); } else { // Its not a digit, so we will just make that one // string 'digit' a number memcpy(szNum, pch - 1, sizeof(CHAR)); iNum = MiniAtoI(szNum); } // We must allow for the fact that there may be more insert // tokens then actual inserts. Thus, cItems is no mere count // of items, it is a count of possible items? (see Windows // Bugs #368881 for details). if(cItems < iNum) cItems = iNum; // See if there is a formatting character if (*pch != '!') { // No optional type spec, so assume its a string rgConv[iNum - 1]=1; cStrings++; if(*pch == '\0') break; // Make sure we do not skip the next character // when the for loop increments us in a moment pch--; } else { // See "printf Type Field Characters" for details on our support here. // Note that e, E, f, G, and g are not supported by FormatMessage, so // everything we care about is either an int, UINT, or string. // Skip the exclamation point itself to get the formatting character pch++; switch(*pch) { case 'c': case 'C': case 's': case 'S': rgConv[iNum - 1]=1; cStrings++; break; case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': default: rgConv[iNum - 1]=0; break; } // Skip on past the formatting character (which ought // to put us on the closing exclamation point). pch++; } } } //free the buffer now LocalFree(pBuffer); if(cItems == 0) { // They passed in no args in their call even though // they said they had some, so lets give them no Args. ArgsA = NULL; szScratch = NULL; } else { ULONG rgpInserts[MAXINSERTS]; // our own argument array of inserts UINT idxInsert; // index of the insert we are working on DWORD dwOffset = 0; // number of bytes used in rgszInsert if(cStrings) { szScratch = GodotHeapAlloc(CCHMAXPERINSERT * cStrings); if(szScratch == NULL) { SetLastError(ERROR_OUTOFMEMORY); return(0); } } for (idxInsert = 0 ; idxInsert < cItems; idxInsert++) { LPWSTR lpwzT; // If this is an arg array, than treat Args like an array of LPWSTRs // and read the Args one at a time that way. Otherwise, use va_arg to // pick off the next item. if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY) lpwzT = (LPWSTR)Args[idxInsert]; else lpwzT = va_arg(*Args, LPWSTR); if(rgConv[idxInsert]==1) { // Convert strings W->A UINT cbInsert = WideCharToMultiByte(cpg, 0, lpwzT, -1, (LPSTR)(szScratch + dwOffset), CCHMAXPERINSERT, NULL, NULL); rgpInserts[idxInsert] = (ULONG)(LPSTR)(szScratch + dwOffset); dwOffset += cbInsert; } else { // Copy the data, directly. No conversion needed (or even wanted) rgpInserts[idxInsert] = (UINT)lpwzT; } } // We have allocated (CCHMAXPERINSERT * cStrings) bytes of space but we only need // dwOffset bytes. Lets shrink the buffer to give back as much space as we can. if(dwOffset < CCHMAXPERINSERT) szScratch = (LPSTR)GodotHeapReAlloc(szScratch, dwOffset+1); // We are turning this into an argument array list, so set the flags that way dwFlags |= FORMAT_MESSAGE_ARGUMENT_ARRAY; ArgsA = (va_list *)rgpInserts; } } } if (fAllocBuffer) { // Must pass address of szBuffer so the API can fill it in. We will // then copy it to our own LocalAlloc'ed buffer and free the OS one. szBuffer = NULL; RetVal=FormatMessageA(dwFlags, lpSourceA, dwMsgId, dwLangId, (char*)&szBuffer, (mcs * nSize), ArgsA); } else { // Must alloc szBuffer ourselves _STACKALLOC((mcs * nSize), szBuffer); if(szBuffer==NULL) { if(szScratch) GodotHeapFree(szScratch); // The API will have changed the last error; reset // it to the stack overflow so they will know why // we failed SetLastError(ERROR_STACK_OVERFLOW); return(FALSE); } RetVal=FormatMessageA(dwFlags, lpSourceA, dwMsgId, dwLangId, szBuffer, (mcs * nSize), ArgsA); } if (!RetVal) { if(fAllocBuffer) { lpBuffer = NULL; } else { if (FSTRING_VALID(lpBuffer) && (0 < nSize)) *lpBuffer = L'\0'; } } else { if (fAllocBuffer) { // szBuffer contains a LocalAlloc'ed ptr to new string. lpBuffer is a // WCHAR** when FORMAT_MESSAGE_ALLOCATE_BUFFER is defined. To act like // the API, we LocalAlloc our own buffer for the caller. WCHAR* lpBufferT = (WCHAR*)LocalAlloc(NONZEROLPTR, (RetVal + 1) * sizeof(WCHAR)); if(lpBufferT == NULL) RetVal = 0; else { if(RetVal = MultiByteToWideChar(g_acp, 0, szBuffer, -1, lpBufferT, RetVal+1)) RetVal--; lpBufferT[RetVal] = L'\0'; *(WCHAR**)lpBuffer = lpBufferT; } // free up the buffer the OS created, since we created our own for the user. LocalFree(szBuffer); } else { // Just convert RetVal = MultiByteToWideChar(cpg, 0, szBuffer, RetVal, lpBuffer, nSize); lpBuffer[RetVal] = L'\0'; } } if(szScratch) GodotHeapFree(szScratch); return(RetVal); } End= [EFunc] TemplateName=FreeContextBuffer Begin= SECURITY_STATUS __stdcall GodotFreeContextBuffer(void * pvContextBuffer) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(FreeContextBuffer(pvContextBuffer)); } End= [EFunc] TemplateName=FreeEnvironmentStringsW Begin= BOOL __stdcall GodotFreeEnvironmentStringsW(LPWSTR lpszEnvironmentBlock) { // Call the free function directly: we cannot thunk since we // freed THAT buffer which the OS gave us, long ago. // See comments under GodotGetEnvironmentStringsW for details. return(GodotHeapFree(lpszEnvironmentBlock)); } End= [EFunc] TemplateName=GetAltTabInfoW Begin= BOOL __stdcall GodotGetAltTabInfoW(HWND hwnd, int iItem, PALTTABINFO pati, LPWSTR pszItemText, UINT cchItemText) { // Begin locals BOOL RetVal = FALSE; if (s_pfnGetAltTabInfoA == NULL) { // Must allocate stuff for this API call s_pfnGetAltTabInfoA = (PFNgatia)GetUserProc("GetAltTabInfoA"); } if (s_pfnGetAltTabInfoA) { LPSTR pszItemTextAnsi; _STACKALLOC((cchItemText*g_mcs)+1, pszItemTextAnsi); if(pszItemTextAnsi==NULL) { return(FALSE); } RetVal = (s_pfnGetAltTabInfoA(hwnd, iItem, pati, pszItemTextAnsi, cchItemText)); // Begin postcall if (RetVal && (pszItemText != NULL)) MultiByteToWideChar(g_acp, 0, pszItemTextAnsi, -1, pszItemText, gwcslen(pszItemText)); } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return RetVal; } End= [EFunc] TemplateName=GetAtomNameW Begin= UINT __stdcall GodotGetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize) { // Begin locals UINT RetVal; LPSTR lpBufferAnsi; _STACKALLOC((nSize*g_mcs)+1, lpBufferAnsi); if(lpBufferAnsi==NULL) { return(0); } // Call the 'A' version of the API RetVal=GetAtomNameA(nAtom, lpBufferAnsi, nSize); // Begin postcall if (RetVal) MultiByteToWideChar(g_acp, 0, lpBufferAnsi, -1, lpBuffer, nSize); // Finished return RetVal; } End= [EFunc] TemplateName=GetCalendarInfoW Begin= int __stdcall GodotGetCalendarInfoW( LCID Locale, CALID Calendar, CALTYPE CalType, LPWSTR lpCalData, int cchData, LPDWORD lpValue ) { // Begin locals int RetVal = 0; LPSTR lpCalDataAnsi; UINT cpg; UINT mcs; if (s_pfnGetCalendarInfoA == NULL) { // Must allocate stuff for this API call s_pfnGetCalendarInfoA = (PFNgcia)GetKernelProc("GetCalendarInfoA"); } if (s_pfnGetCalendarInfoA) { if(CalType & CAL_USE_CP_ACP) { cpg = g_acp; mcs = g_mcs; } else { cpg = CpgFromLocale(Locale); mcs = CbPerChOfCpg(cpg); } _STACKALLOC((cchData+1)*mcs, lpCalDataAnsi); RetVal = (s_pfnGetCalendarInfoA (Locale, Calendar, CalType, lpCalDataAnsi, (cchData*mcs), // We can be optimists, we allocated for it! lpValue)); // Begin postcall if (lpCalDataAnsi != 0) MultiByteToWideChar(cpg, 0, lpCalDataAnsi, cchData*mcs, lpCalData, cchData); } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return RetVal; } End= [EFunc] TemplateName=GetCharABCWidthsW Begin= BOOL __stdcall GodotGetCharABCWidthsW(HDC hdc, UINT ichFirst, UINT ichLast, LPABC lpabc) { BOOL RetVal = FALSE; UINT ich; CHAR * sz[2]; UINT cpg = CpgFromHdc(hdc); UINT mcs = CbPerChOfCpg(cpg); // Do some basic param validation if((ichLast < ichFirst) || (!lpabc)) { SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } for (ich = ichFirst ; ich < ichLast ; ich++) { // Convert each character and call the API, one at a time. This might kind // of suck, perf-wise, but its the best we can do if we want to be able to // give them the values they expect from the API. sz[0] = '\0'; sz[1] = '\0'; WideCharToMultiByte(cpg, 0, (WCHAR *)ich, 1, (LPSTR)&sz, mcs, NULL, NULL); RetVal = GetCharABCWidthsA(hdc, ich, ich, &lpabc[ich - ichFirst]); if(!RetVal) { // The function failed, so bail break; } } return(RetVal); } End= [EFunc] TemplateName=GetCharABCWidthsFloatW Begin= BOOL __stdcall GodotGetCharABCWidthsFloatW(HDC hdc, UINT ichFirst, UINT ichLast, LPABCFLOAT lpABCF) { BOOL RetVal = FALSE; UINT ich; CHAR * sz[2]; UINT cpg = CpgFromHdc(hdc); UINT mcs = CbPerChOfCpg(cpg); // Do some basic param validation if((ichLast < ichFirst) || (!lpABCF)) { SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } for (ich = ichFirst ; ich < ichLast ; ich++) { // Convert each character and call the API, one at a time. This might kind // of suck, perf-wise, but its the best we can do if we want to be able to // give them the values they expect from the API. sz[0] = '\0'; sz[1] = '\0'; WideCharToMultiByte(cpg, 0, (WCHAR *)ich, 1, (LPSTR)&sz, mcs, NULL, NULL); RetVal = GetCharABCWidthsFloatA(hdc, ich, ich, &lpABCF[ich - ichFirst]); if(!RetVal) { // The function failed, so bail break; } } return(RetVal); } End= [EFunc] TemplateName=GetCharWidthW Begin= BOOL __stdcall GodotGetCharWidthW(HDC hdc, UINT iFirstChar, UINT iLastChar, LPINT lpBuffer) { // Due to a bug (feature?) in Win95, characters in Symbol/Wingding/other // fonts map to 0xf000, while in NT they map to chars in the default // codepage. We cannot really change the NT behavior and who would want to // change the Win9x behavior, anyway? Too complicated! if (iLastChar <= 127) { if (GetCharWidthA(hdc, iFirstChar, iLastChar, lpBuffer)) return TRUE; } // Call the 'W' version of the API here, since it is available return(GetCharWidthW(hdc, iFirstChar, iLastChar, lpBuffer)); } End= [EFunc] TemplateName=GetCharWidthFloatW Begin= BOOL __stdcall GodotGetCharWidthFloatW(HDC hdc, UINT ichFirst, UINT ichLast, PFLOAT pxBuffer) { BOOL RetVal = FALSE; UINT ich; CHAR * sz[2]; UINT cpg = CpgFromHdc(hdc); UINT mcs = CbPerChOfCpg(cpg); // Do some basic param validation if((ichLast < ichFirst) || (!pxBuffer)) { SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } for (ich = ichFirst ; ich < ichLast ; ich++) { // Convert each character and call the API, one at a time. This might kind // of suck, perf-wise, but its the best we can do if we want to be able to // give them the values they expect from the API. sz[0] = '\0'; sz[1] = '\0'; WideCharToMultiByte(cpg, 0, (WCHAR *)ich, 1, (LPSTR)&sz, mcs, NULL, NULL); RetVal = GetCharWidthFloatA(hdc, ich, ich, &pxBuffer[ich - ichFirst]); if(!RetVal) { // The function failed, so bail break; } } return(RetVal); } End= [EFunc] TemplateName=GetClassInfoW Begin= BOOL __stdcall GodotGetClassInfoW(HINSTANCE hInstance, LPCWSTR lpClassName, LPWNDCLASSW lpwc) { // Begin locals BOOL RetVal; LPSTR lpClassNameAnsi; WNDCLASSA wca; GODOT_TO_ACP_STACKALLOC(lpClassName, lpClassNameAnsi); if(!lpClassNameAnsi && lpClassName) return(FALSE); ZeroMemory(&wca, sizeof(WNDCLASSA)); RetVal=GetClassInfoA(hInstance, lpClassNameAnsi, &wca); // Begin postcall if(RetVal) { memcpy(lpwc, &wca, sizeof(UINT)+sizeof(WNDPROC)+2*sizeof(int)+4*sizeof(HANDLE)); // See comments at the top of the file for why we are using a // static buffer here for menu and class names if (FSTRING_VALID(wca.lpszMenuName)) { MultiByteToWideChar(g_acp, 0, wca.lpszMenuName, -1, m_wzMenuName, 256); lpwc->lpszMenuName = m_wzMenuName; } else lpwc->lpszMenuName = (LPWSTR)wca.lpszMenuName; if (FSTRING_VALID(wca.lpszClassName)) { MultiByteToWideChar(g_acp, 0, wca.lpszClassName, -1, m_wzClassName, 256); lpwc->lpszClassName = m_wzClassName; } else lpwc->lpszClassName = (LPWSTR)wca.lpszClassName; } // Finished return RetVal; } End= [EFunc] TemplateName=GetClassInfoExW Begin= BOOL __stdcall GodotGetClassInfoExW(HINSTANCE hinst, LPCWSTR lpszClass, LPWNDCLASSEXW lpwce) { // Begin locals BOOL RetVal; LPSTR lpszClassAnsi; WNDCLASSEXA wcea; GODOT_TO_ACP_STACKALLOC(lpszClass, lpszClassAnsi); if(!lpszClassAnsi && lpszClass) return(FALSE); ZeroMemory(&wcea, sizeof(WNDCLASSEXA)); wcea.cbSize = sizeof(WNDCLASSEXA); RetVal=GetClassInfoExA(hinst, lpszClassAnsi, &wcea); // Begin postcall if(RetVal) { memcpy(&lpwce->style, &wcea.style, sizeof(UINT)+sizeof(WNDPROC)+(2*sizeof(int))+(4*sizeof(HANDLE))); // See comments at the top of the file for why we are using a // static buffer here if (FSTRING_VALID(wcea.lpszMenuName)) { MultiByteToWideChar(g_acp, 0, wcea.lpszMenuName, -1, m_wzMenuName, 256); lpwce->lpszMenuName = m_wzMenuName; } else lpwce->lpszMenuName = (LPWSTR)wcea.lpszMenuName; if (FSTRING_VALID(wcea.lpszClassName)) { MultiByteToWideChar(g_acp, 0, wcea.lpszClassName, -1, m_wzClassName, 256); lpwce->lpszClassName = m_wzClassName; } else lpwce->lpszClassName = (LPWSTR)wcea.lpszClassName; lpwce->hIconSm = wcea.hIconSm; } // Finished return RetVal; } End= [EFunc] TemplateName=GetClassLongW Begin= DWORD __stdcall GodotGetClassLongW(HWND hWnd, int nIndex) { // Begin locals DWORD RetVal; RetVal=GetClassLongA(hWnd, nIndex); if((RetVal != 0) && (nIndex == GCL_MENUNAME)) { // We need to convert this string to Unicode and stick it in // our global buffer, then return the pointer to that buffer. // See comments at the dec. of g_szMenuName for why things // have to be done this way. MultiByteToWideChar(g_acp, 0, (LPSTR)RetVal, -1, m_wzMenuName, 256); RetVal = (DWORD)m_wzMenuName; } return(RetVal); } End= [EFunc] TemplateName=GetClassNameW Begin= int __stdcall GodotGetClassNameW(HWND hWnd, LPWSTR lpClassName, int nMaxCount) { // Begin locals int RetVal; LPSTR lpClassNameAnsi; _STACKALLOC((nMaxCount*g_mcs)+1, lpClassNameAnsi); if(lpClassNameAnsi == NULL) { return(0); } // Call the 'A' version of the API RetVal=GetClassNameA(hWnd, lpClassNameAnsi, nMaxCount); // Begin postcall if ((RetVal) && (nMaxCount > 0)) MultiByteToWideChar(g_acp, 0, lpClassNameAnsi, -1, lpClassName, nMaxCount); else { if (lpClassName && 0 < nMaxCount) *lpClassName = L'\0'; } // Finished return RetVal; } End= [EFunc] TemplateName=GetClipboardData Begin= HANDLE __stdcall GodotGetClipboardData(UINT uFormat) { HANDLE RetVal = GetClipboardData(uFormat); if(RetVal==NULL) { if((!IsClipboardFormatAvailable(uFormat)) && (GodotIsClipboardFormatAvailable(uFormat))) { // System says it is not available, but we know better! BOOL fUnicodeOnClipboard; HANDLE hMemOnClipboard; fUnicodeOnClipboard = (uFormat != CF_UNICODETEXT); hMemOnClipboard = GetClipboardData(((!fUnicodeOnClipboard) ? CF_TEXT : CF_UNICODETEXT)); if(hMemOnClipboard != 0) { // We have a handle to the data, now lets use it. PULONG pMemOnClipboard;; if(pMemOnClipboard = GlobalLock(hMemOnClipboard)) { HANDLE hLocale = GetClipboardData(CF_LOCALE); UINT cpg; UINT mcs; size_t cb; HANDLE hMemSynthetic; // Figure out the code page to use now -- this is where we care whether // the caller wanted CF_TEXT vs. CF_OEMTEXT -- since it determines // whether we want ACP or OEMCP. // If they want Unicode then we can grab either one (Win9x supports // synthetic conversions CF_TEXT <---> CF_OEMTEXT) so we choose CF_TEXT. if(fUnicodeOnClipboard && (uFormat==CF_OEMTEXT)) cpg = (hLocale ? (CpgOemFromLocale((LCID)(&hLocale))) : g_oemcp); else cpg = (hLocale ? (CpgFromLocale((LCID)(&hLocale))) : g_acp); mcs = CbPerChOfCpg(cpg); // Get the appropriate buffer size, based on the existing format and the // size of the actual data. This may be bigger than we need it to be if // the cpg is a DBCS code page. if(fUnicodeOnClipboard) cb = gwcslen((LPWSTR)pMemOnClipboard) * mcs; else cb = lstrlenA((LPSTR)pMemOnClipboard) * sizeof(WCHAR); // Allocate some memory for the converted string and then lock it if(hMemSynthetic = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, cb)) { PULONG pMemSynthetic = GlobalLock(hMemSynthetic); if(pMemSynthetic == NULL) { // Lock failed, no need to go further, lets bail. GlobalFree(hMemSynthetic); } else { if(fUnicodeOnClipboard) { WideCharToMultiByte(cpg, 0, (LPWSTR)pMemOnClipboard, -1, (LPSTR)pMemSynthetic, cb, NULL, NULL); } else { MultiByteToWideChar(cpg, 0, (LPSTR)pMemOnClipboard, -1, (LPWSTR)pMemSynthetic, (cb / sizeof(WCHAR))); } // We made it this far, we will now stick the data on the // clipboard. The function thankfully returns the handle // to the clipboard object that has just been set. Which is // just what the caller wants! // CONSIDER: Call GlobalReAlloc when FDBCS_CPG(cpg)? In that // case, the buffer may be larger than it has to be. RetVal = SetClipboardData(uFormat, pMemSynthetic); GlobalUnlock(hMemSynthetic); } } GlobalUnlock(hMemOnClipboard); } } } } return(RetVal); } End= [EFunc] TemplateName=GetClipboardFormatNameW Begin= int __stdcall GodotGetClipboardFormatNameW(UINT format, LPWSTR lpszFormatName, int cchMaxCount) { // Begin locals int RetVal; LPSTR lpszFormatNameAnsi; _STACKALLOC((cchMaxCount*g_mcs)+1, lpszFormatNameAnsi); if(lpszFormatNameAnsi==NULL) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } ZeroMemory(lpszFormatNameAnsi, (cchMaxCount*g_mcs)+1); RetVal=GetClipboardFormatNameA(format, lpszFormatNameAnsi, cchMaxCount); // Begin postcall if(RetVal) MultiByteToWideChar(g_acp, 0, lpszFormatNameAnsi, -1, lpszFormatName, cchMaxCount); else *lpszFormatName = L'\0'; // Finished return RetVal; } End= [EFunc] TemplateName=GetComputerNameW Begin= BOOL __stdcall GodotGetComputerNameW(LPWSTR lpBuffer, LPDWORD nSize) { BOOL RetVal; LPSTR lpBufferAnsi; WCHAR wzBuffer[MAX_COMPUTERNAME_LENGTH + 1]; DWORD nSizeT = MAX_COMPUTERNAME_LENGTH + 1; // We will get the full string, always. Win9x is documented as // failing if the input size is less than MAX_COMPUTERNAME_LENGTH + 1. _STACKALLOC((nSizeT * g_mcs) + 1, lpBufferAnsi); if(lpBufferAnsi==NULL) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } ZeroMemory(lpBufferAnsi, (nSizeT * g_mcs) + 1); ZeroMemory(wzBuffer, nSizeT * sizeof(WCHAR)); RetVal=GetComputerNameA(lpBufferAnsi, &nSizeT); // Begin postcall if(RetVal) { MultiByteToWideChar(g_acp, 0, lpBufferAnsi, nSizeT + 1, wzBuffer, MAX_COMPUTERNAME_LENGTH); if(*nSize >= nSizeT) { // Their buffer is big enough, so copy it over gwcscpy(lpBuffer, wzBuffer); *nSize = gwcslen(wzBuffer); } else { // The A call succeeded, but we need to make it fail // since they did not give us enough buffer. So act // like the API does and return the size plus the null *nSize = gwcslen(wzBuffer) + 1; RetVal = 0; SetLastError(ERROR_BUFFER_OVERFLOW); } } else *lpBuffer = L'0'; // Finished return RetVal; } End= [EFunc] TemplateName=GetConsoleTitleW Begin= DWORD __stdcall GodotGetConsoleTitleW(LPWSTR lpConsoleTitle, DWORD nSize) { // Begin locals DWORD RetVal; LPSTR lpConsoleTitleAnsi; _STACKALLOC((nSize*g_mcs)+1, lpConsoleTitleAnsi); if(lpConsoleTitleAnsi==NULL) { return(0); } RetVal=GetConsoleTitleA(lpConsoleTitleAnsi, nSize); // Begin postcall if(RetVal && lpConsoleTitle) MultiByteToWideChar(g_oemcp, 0, lpConsoleTitleAnsi, -1, lpConsoleTitle, nSize); // Finished return RetVal; } End= [EFunc] TemplateName=GetCPInfo Begin= // GetCPInfo is wrapped for UTF-7/UTF-8 support BOOL __stdcall GodotGetCPInfo(UINT CodePage, LPCPINFO lpCPInfo) { // See if it's a special code page value for UTF translations. if (CodePage >= NLS_CP_ALGORITHM_RANGE) return (UTFCPInfo(CodePage, lpCPInfo, FALSE)); if (CodePage == CP_GB18030) return (GB18030Helper(CodePage, NLS_CP_CPINFO, NULL, 0, NULL, 0, lpCPInfo)); return (GetCPInfo(CodePage, lpCPInfo)); } End= [EFunc] TemplateName=GetCPInfoExW Begin= CONST WCHAR szUTF7[] = L"UTF-7"; CONST WCHAR szUTF8[] = L"UTF-8"; CONST WCHAR szGB18030[] = L"GB 18030"; // GetCPInfoExW is wrapped for UTF-7/UTF-8 support, because its on not on Win95, // AND for the string containing the code page names, as well. Note that we // hardcode the UTF strings rather than make them resources since they are not // localized BOOL __stdcall GodotGetCPInfoExW(UINT CodePage, DWORD dwFlags, LPCPINFOEXW lpCPInfoEx) { // Begin locals BOOL RetVal = FALSE; CPINFOEXA CPInfoExAnsi; if (s_pfnGetCPInfoExA == NULL) { // Must allocate stuff for this API call s_pfnGetCPInfoExA = (PFNgciea)GetKernelProc("GetCPInfoExA"); } if (s_pfnGetCPInfoExA) { // // See if it's a special code page value for UTF translations. // if (CodePage >= NLS_CP_ALGORITHM_RANGE) { if (UTFCPInfo(CodePage, (LPCPINFO)lpCPInfoEx, TRUE)) { if (CodePage == CP_UTF8) memcpy(lpCPInfoEx->CodePageName, szUTF8, gwcslen(szUTF8)); else // (CodePage == CP_UTF7) memcpy(lpCPInfoEx->CodePageName, szUTF7, gwcslen(szUTF7)); return (TRUE); } return (FALSE); } if (CodePage == CP_GB18030) { if (GB18030Helper(CodePage, NLS_CP_CPINFO, NULL, 0, NULL, 0, (LPCPINFO)lpCPInfoEx)) { memcpy(lpCPInfoEx->CodePageName, szGB18030, gwcslen(szGB18030)); return(TRUE); } return(FALSE); } ZeroMemory(&CPInfoExAnsi, sizeof(CPINFOEXA)); RetVal = (s_pfnGetCPInfoExA(CodePage, dwFlags, &CPInfoExAnsi)); // Begin postcall if(RetVal != FALSE) { lpCPInfoEx->MaxCharSize = CPInfoExAnsi.MaxCharSize; lpCPInfoEx->DefaultChar[0] = CPInfoExAnsi.DefaultChar[0]; lpCPInfoEx->DefaultChar[1] = CPInfoExAnsi.DefaultChar[1]; lpCPInfoEx->LeadByte[0] = CPInfoExAnsi.LeadByte[0]; lpCPInfoEx->LeadByte[1] = CPInfoExAnsi.LeadByte[1]; lpCPInfoEx->UnicodeDefaultChar = CPInfoExAnsi.UnicodeDefaultChar; lpCPInfoEx->CodePage = CPInfoExAnsi.CodePage; MultiByteToWideChar(g_acp, 0, CPInfoExAnsi.CodePageName, -1, lpCPInfoEx->CodePageName, MAX_PATH); } } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return RetVal; } End= [EFunc] TemplateName=GetCurrentDirectoryW Begin= DWORD __stdcall GodotGetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer) { // Begin locals DWORD RetVal; LPSTR lpBufferAnsi; _STACKALLOC((nBufferLength*g_mcs)+1, lpBufferAnsi); if(lpBufferAnsi==NULL) { return(0); } // Call the 'A' version of the API RetVal=GetCurrentDirectoryA(nBufferLength, lpBufferAnsi); // Begin postcall if(RetVal) MultiByteToWideChar(g_acp, 0, lpBufferAnsi, -1, lpBuffer, nBufferLength); else if (lpBuffer && 0 < nBufferLength) *lpBuffer = L'\0'; // Finished return RetVal; } End= [EFunc] TemplateName=GetCurrencyFormatW Begin= int __stdcall GodotGetCurrencyFormatW( LCID Locale, DWORD dwFlags, LPCWSTR lpValue, CURRENCYFMTW * lpFormat, LPWSTR lpCurrencyStr, int cchCurrency ) { // Begin locals int RetVal; LPSTR lpValueAnsi; CURRENCYFMTA * lpFormatAnsi; LPSTR lpCurrencyStrAnsi; UINT cpg = CpgFromLocale(Locale); UINT mcs = CbPerChOfCpg(cpg); int cchBuff; // Begin precall GODOT_TO_CPG_STACKALLOC(lpValue, lpValueAnsi, cpg, mcs); if (lpFormat == NULL) { lpFormatAnsi = NULL; } else { _STACKALLOC(sizeof(CURRENCYFMTA), lpFormatAnsi); ZeroMemory(lpFormatAnsi, sizeof(CURRENCYFMTA)); lpFormatAnsi->NumDigits = lpFormat->NumDigits; lpFormatAnsi->LeadingZero = lpFormat->LeadingZero; lpFormatAnsi->Grouping = lpFormat->Grouping; GODOT_TO_CPG_STACKALLOC(lpFormat->lpDecimalSep, lpFormatAnsi->lpDecimalSep, cpg, mcs); GODOT_TO_CPG_STACKALLOC(lpFormat->lpThousandSep, lpFormatAnsi->lpThousandSep, cpg, mcs); lpFormatAnsi->NegativeOrder = lpFormat->NegativeOrder; lpFormatAnsi->PositiveOrder = lpFormat->PositiveOrder; GODOT_TO_CPG_STACKALLOC(lpFormat->lpCurrencySymbol, lpFormatAnsi->lpCurrencySymbol, cpg, mcs); } // Call the 'A' version of the API if ((cchCurrency > 0) && FSTRING_VALID(lpCurrencyStr == NULL)) { cchBuff = (cchCurrency*mcs)+1; _STACKALLOC(cchBuff, lpCurrencyStrAnsi); if(lpCurrencyStrAnsi==NULL) { return(0); } ZeroMemory(lpCurrencyStrAnsi, cchBuff); RetVal=GetCurrencyFormatA(Locale, dwFlags, lpValueAnsi, lpFormatAnsi, lpCurrencyStrAnsi, cchBuff); if (RetVal > 0) MultiByteToWideChar(cpg, 0, lpCurrencyStrAnsi, cchCurrency*mcs, lpCurrencyStr, cchCurrency); } else RetVal=GetCurrencyFormatA(Locale, dwFlags, lpValueAnsi, lpFormatAnsi, NULL, 0); if((RetVal==0) && lpCurrencyStr && (0 < cchCurrency)) { *lpCurrencyStr = '0'; } // Finished return RetVal; } End= [EFunc] TemplateName=GetCurrentHwProfileW Begin= BOOL __stdcall GodotGetCurrentHwProfileW(LPHW_PROFILE_INFOW lphpi) { // Begin locals BOOL RetVal = FALSE; if (s_pfnGetCurrentHwProfileA == NULL) { // Must allocate stuff for this API call s_pfnGetCurrentHwProfileA = (PFNgchpa)GetAdvapiProc("GetCurrentHwProfileA"); } if (s_pfnGetCurrentHwProfileA) { HW_PROFILE_INFOA hpia; RetVal=(s_pfnGetCurrentHwProfileA(&hpia)); // Begin postcall if(RetVal) { lphpi->dwDockInfo = hpia.dwDockInfo; MultiByteToWideChar(g_acp, 0, hpia.szHwProfileGuid, HW_PROFILE_GUIDLEN, lphpi->szHwProfileGuid, HW_PROFILE_GUIDLEN); MultiByteToWideChar(g_acp, 0, hpia.szHwProfileName, MAX_PROFILE_LEN, lphpi->szHwProfileName, MAX_PROFILE_LEN); } } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return RetVal; } End= [EFunc] TemplateName=GetCharacterPlacementW Begin= DWORD __stdcall GodotGetCharacterPlacementW( HDC hdc, LPCWSTR lpString, int nCount, int nMaxExtent, LPGCP_RESULTSW lpResults, DWORD dwFlags ) { // Since none of the in params in lpResults need conversion and only ONE out param does, // we will simply pass their structure on through and convert the one param if we need to DWORD RetVal; LPSTR lpStringAnsi; LPSTR lpOutStringAnsi; size_t lpOutStringLength; size_t lStructSizeT; BOOL fOutString = (FSTRING_VALID(lpResults->lpOutString)); UINT cpg = CpgFromHdc(hdc); UINT mcs = CbPerChOfCpg(cpg); // Begin precall if(lpResults->lStructSize < sizeof(LPGCP_RESULTSW)) { SetLastError(ERROR_INVALID_PARAMETER); return(0); } GODOT_TO_CPG_STACKALLOC(lpString, lpStringAnsi, cpg, mcs); if(lpStringAnsi==NULL) { return(0); } // Cache the struct size so we can restore it later lStructSizeT = lpResults->lStructSize; lpResults->lStructSize = sizeof(LPGCP_RESULTSA); RetVal=GetCharacterPlacementA(hdc, lpStringAnsi, nCount, nMaxExtent, (LPGCP_RESULTSA)lpResults, dwFlags); // restore the struct size lpResults->lStructSize = lStructSizeT; // We will be a little paranoid in case the API did something to the OUT string if (fOutString && (RetVal !=0)) { // If the OUT param is there, we need to make that // be a UNICODE string (it is an ANSI one right now) if (FSTRING_VALID(lpResults->lpOutString)) { lpOutStringLength = lstrlenA( (LPSTR)lpResults->lpOutString); _STACKALLOC(lpOutStringLength * mcs, lpOutStringAnsi); strcpy(lpOutStringAnsi, (LPSTR)(lpResults->lpOutString)); MultiByteToWideChar(cpg, 0, lpOutStringAnsi, -1, lpResults->lpOutString, nCount); } } else lpResults->lpOutString = NULL; // Finished return RetVal; } End= [EFunc] TemplateName=GetDateFormatW Begin= int __stdcall GodotGetDateFormatW( LCID Locale, DWORD dwFlags, const SYSTEMTIME * lpDate, LPCWSTR lpFormat, LPWSTR lpDateStr, int cchDate ) { // Begin locals int RetVal; LPSTR lpFormatAnsi; UINT cpg; UINT mcs; // Begin precall if(dwFlags & LOCALE_USE_CP_ACP) { cpg = g_acp; mcs = g_mcs; } else { cpg = CpgFromLocale(Locale); mcs = CbPerChOfCpg(cpg); } GODOT_TO_CPG_STACKALLOC(lpFormat, lpFormatAnsi, cpg, mcs); if(FSTRING_VALID(lpDateStr) && (cchDate > 0)) { LPSTR lpDateStrAnsi; _STACKALLOC((cchDate+1)*mcs, lpDateStrAnsi); if(lpDateStrAnsi==NULL) { return(0); } RetVal=GetDateFormatA(Locale, dwFlags, lpDate, lpFormatAnsi, lpDateStrAnsi, ((cchDate+1)*mcs)); if(RetVal && lpDateStr) MultiByteToWideChar(cpg, 0, lpDateStrAnsi, cchDate*mcs, lpDateStr, cchDate); } else { RetVal=GetDateFormatA(Locale, dwFlags, lpDate, lpFormatAnsi, NULL, 0); } if(RetVal==0 && lpDateStr && (0 < cchDate)) { *lpDateStr = '0'; } // Finished return RetVal; } End= [EFunc] TemplateName=GetDiskFreeSpaceExW Begin= BOOL __stdcall GodotGetDiskFreeSpaceExW( LPCWSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes ) { if (!lpFreeBytesAvailableToCaller || !lpTotalNumberOfBytes) return FALSE; if (s_pfnGetDiskFreeSpaceExA == NULL) { // Must allocate stuff for this API call s_pfnGetDiskFreeSpaceExA = (PFNgdfsea)GetKernelProc("GetDiskFreeSpaceExA"); } if (s_pfnGetDiskFreeSpaceExA) { LPSTR lpDirectoryNameAnsi; GODOT_TO_ACP_STACKALLOC(lpDirectoryName, lpDirectoryNameAnsi); if(!lpDirectoryNameAnsi && lpDirectoryName) return(FALSE); return(s_pfnGetDiskFreeSpaceExA(lpDirectoryNameAnsi, lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes, lpTotalNumberOfFreeBytes)); } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return FALSE; } End= [EFunc] TemplateName=GetDlgItemTextW Begin= UINT __stdcall GodotGetDlgItemTextW(HWND hDlg, int nIDDlgItem, LPWSTR lpString, int nMaxCount) { // Begin locals UINT RetVal; LPSTR lpStringAnsi; _STACKALLOC((nMaxCount*g_mcs)+1, lpStringAnsi); if(!lpStringAnsi) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } ZeroMemory(lpStringAnsi, (nMaxCount*g_mcs)+1); // Call the 'A' version of the API RetVal=GetDlgItemTextA(hDlg, nIDDlgItem, lpStringAnsi, nMaxCount); // Begin postcall if(RetVal) { MultiByteToWideChar(g_acp, 0, lpStringAnsi, -1, lpString, nMaxCount); } else if (lpString && 0 < nMaxCount) { *lpString = L'\0'; } // Finished return RetVal; } End= [EFunc] TemplateName=GetEnvironmentStringsW Begin= LPWSTR __stdcall GodotGetEnvironmentStringsW(void) { // Begin locals LPWSTR RetVal = NULL; LPSTR RetValAnsi; size_t cch; // Call the 'A' version of the API RetValAnsi=GetEnvironmentStringsA(); // Begin postcall if (RetValAnsi != NULL) { // Get the size then alloc some memory on the // heap; caller can only free it later by calling // FreeEnvironmentStringsW, like the docs say. cch = (lstrlenA( RetValAnsi)+1); RetVal = GodotHeapAlloc(cch*sizeof(WCHAR)); if (RetVal != NULL) { MultiByteToWideChar(g_acp, 0, RetValAnsi, -1, RetVal, cch); // On DBCS code pages, this allocation might be bigger than // it has to be; if it is, then lets shrink it a bit. if(FDBCS_CPG(g_acp)) { size_t cchActual = gwcslen(RetVal); if((cchActual + 1) < cch) RetVal = (LPWSTR)GodotHeapReAlloc(RetVal, cchActual+1); } } // free up the string from the OS, we will have // the user free our own later FreeEnvironmentStringsA(RetValAnsi); } // Finished return RetVal; } End= [EFunc] TemplateName=GetEnvironmentVariableW Begin= DWORD __stdcall GodotGetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize) { // Begin locals DWORD RetVal; LPSTR lpNameAnsi; LPSTR lpBufferAnsi; _STACKALLOC((nSize*g_mcs)+1, lpBufferAnsi); if(!lpBufferAnsi) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } GODOT_TO_ACP_STACKALLOC(lpName, lpNameAnsi); if(!lpNameAnsi && lpName) return(0); RetVal=GetEnvironmentVariableA(lpNameAnsi, lpBufferAnsi, nSize); if(RetVal) MultiByteToWideChar(g_acp, 0, lpBufferAnsi, -1, lpBuffer, nSize); // Finished return RetVal; } End= [EFunc] TemplateName=GetEnhMetaFileDescriptionW Begin= UINT __stdcall GodotGetEnhMetaFileDescriptionW(HENHMETAFILE hemf, UINT cchBuffer, LPWSTR lpszDescription) { // Begin locals UINT RetVal; LPSTR lpszDescriptionAnsi; if (lpszDescription != NULL) { _STACKALLOC((cchBuffer*g_mcs)+1, lpszDescriptionAnsi); if(lpszDescriptionAnsi==NULL) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } ZeroMemory(lpszDescriptionAnsi,(cchBuffer*g_mcs)+1); } else lpszDescriptionAnsi = NULL; // Call the 'A' version of the API RetVal=GetEnhMetaFileDescriptionA(hemf, cchBuffer, lpszDescriptionAnsi); // Begin postcall: munge the return value to what is copied to // the caller's buffer if (lpszDescription && lpszDescriptionAnsi) MultiByteToWideChar(g_acp, 0, lpszDescriptionAnsi, -1, lpszDescription, cchBuffer); // Finished return RetVal; } End= [EFunc] TemplateName=GetEnhMetaFileW Begin= HENHMETAFILE __stdcall GodotGetEnhMetaFileW(LPCWSTR lpszMetaFile) { LPSTR lpszMetaFileAnsi; // Begin precall GODOT_TO_ACP_STACKALLOC(lpszMetaFile, lpszMetaFileAnsi); if(lpszMetaFileAnsi==NULL) { return(0); } return(GetEnhMetaFileA(lpszMetaFileAnsi)); } End= [EFunc] TemplateName=GetFileAttributesExW Begin= BOOL __stdcall GodotGetFileAttributesExW(LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation) { if (s_pfnGetFileAttributesExA == NULL) { // Must allocate stuff for this API call s_pfnGetFileAttributesExA = (PFNgfnaea)GetKernelProc("GetDiskFreeSpaceExA"); } if (s_pfnGetFileAttributesExA) { LPSTR lpFileNameAnsi; GODOT_TO_ACP_STACKALLOC(lpFileName, lpFileNameAnsi); if(!lpFileNameAnsi && lpFileName) return(FALSE); return(s_pfnGetFileAttributesExA(lpFileNameAnsi, fInfoLevelId, lpFileInformation)); } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return FALSE; } End= [EFunc] TemplateName=GetFileTitleW Begin= short __stdcall GodotGetFileTitleW(LPCWSTR lpszFile, LPWSTR lpszTitle, WORD cbBuf) { // Begin locals short RetVal; LPSTR lpszFileAnsi; LPSTR lpszTitleAnsi; _STACKALLOC((cbBuf*g_mcs)+1, lpszTitleAnsi); GODOT_TO_ACP_STACKALLOC(lpszFile, lpszFileAnsi); if(lpszTitleAnsi==NULL || (lpszFileAnsi == NULL && lpszFile != NULL)) { SetLastError(ERROR_STACK_OVERFLOW); return(FALSE); } RetVal=GetFileTitleA(lpszFileAnsi, lpszTitleAnsi, cbBuf); if(RetVal == 0) MultiByteToWideChar(g_acp, 0, lpszTitleAnsi, -1, lpszTitle, cbBuf); // Finished return RetVal; } End= [EFunc] TemplateName=GetFileVersionInfoW Begin= BOOL __stdcall GodotGetFileVersionInfoW(LPWSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData) { LPSTR lptstrFilenameAnsi; BYTE* pbyt; // Make sure we are at least big enough for our special buffer if(dwLen <= VERINFO_BUFFER) return(FALSE); // Begin precall GODOT_TO_ACP_STACKALLOC(lptstrFilename, lptstrFilenameAnsi); if(lptstrFilenameAnsi==NULL && lptstrFilename != NULL) { return(FALSE); } pbyt = (BYTE*)lpData + VERINFO_BUFFER; return(GetFileVersionInfoA(lptstrFilenameAnsi, dwHandle, dwLen, (void *)pbyt)); } End= [EFunc] TemplateName=GetFileVersionInfoSizeW Begin= DWORD __stdcall GodotGetFileVersionInfoSizeW(LPWSTR lptstrFilename, LPDWORD lpdwHandle) { LPSTR lptstrFilenameAnsi; DWORD RetVal; // Begin precall GODOT_TO_ACP_STACKALLOC(lptstrFilename, lptstrFilenameAnsi); if(lptstrFilenameAnsi==NULL && lptstrFilename != NULL) { return(FALSE); } RetVal = GetFileVersionInfoSizeA(lptstrFilenameAnsi, lpdwHandle); // If the call succeeds, add our scratchpad buffer for subsequent calls if(RetVal) RetVal += VERINFO_BUFFER; return(RetVal); } End= [EFunc] TemplateName=GetFullPathNameW Begin= DWORD __stdcall GodotGetFullPathNameW(LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR * lpFilePart) { // Begin locals DWORD RetVal; LPSTR lpFileNameAnsi; LPSTR lpBufferAnsi; LPSTR * lpFilePartAnsi = NULL; WCHAR drive[_MAX_DRIVE]; WCHAR dir[_MAX_DIR]; UINT cpg = FILES_CPG; _STACKALLOC((nBufferLength*g_mcs)+1, lpBufferAnsi); GODOT_TO_CPG_STACKALLOC(lpFileName, lpFileNameAnsi, cpg, g_mcs); if((!lpBufferAnsi) || (lpFileName && !lpFileNameAnsi)) { return(0); } RetVal=GetFullPathNameA(lpFileNameAnsi, nBufferLength, lpBufferAnsi, lpFilePartAnsi); if(RetVal) { MultiByteToWideChar(cpg, 0, lpBufferAnsi, -1, lpBuffer, nBufferLength); if(lpFilePart) { // We ignore lpFilePartAnsi and just derive lpFilePart here // (even non-technical folks like CWissink can contribute now and then!) gwsplitpath(lpBuffer, drive, dir, NULL, NULL); *lpFilePart = lpBuffer + gwcslen(drive) + gwcslen(dir); } } // Finished return RetVal; } End= [EFunc] TemplateName=GetGlyphOutlineW Begin= DWORD __stdcall GodotGetGlyphOutlineW(HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm, DWORD cbBuffer, LPVOID lpvBuffer, const MAT2 * lpmat2) { UINT uCharA = 0; UINT cpg; UINT mcs; cpg = CpgFromHdc(hdc); mcs = CbPerChOfCpg(cpg); WideCharToMultiByte(cpg, 0, (WCHAR *)&uChar, 1, (CHAR *)&uCharA, mcs, NULL, NULL); return(GetGlyphOutlineA(hdc, uCharA, uFormat, lpgm, cbBuffer, lpvBuffer, lpmat2)); } End= [EFunc] TemplateName=GetICMProfileW Begin= BOOL __stdcall GodotGetICMProfileW(HDC hDC, LPDWORD lpcbName, LPWSTR lpszFilename) { // Begin locals BOOL RetVal; LPSTR lpszFilenameAnsi; _STACKALLOC((*lpcbName*g_mcs)+1, lpszFilenameAnsi); RetVal=GetICMProfileA(hDC, lpcbName, lpszFilenameAnsi); // Begin postcall - make sure to set the return buffer // to the actual size of the buffer if(RetVal && lpszFilenameAnsi && lpszFilename) MultiByteToWideChar(g_acp, 0, lpszFilenameAnsi, -1, lpszFilename, *(lpcbName)); // Finished return RetVal; } End= [EFunc] TemplateName=GetJobW Begin= BOOL __stdcall GodotGetJobW(HANDLE _noname0, DWORD _noname1, DWORD _noname2, LPBYTE _noname3, DWORD _noname4, LPDWORD _noname5) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(GetJobW(_noname0, _noname1, _noname2, _noname3, _noname4, _noname5)); } End= [EFunc] TemplateName=GetKerningPairsW Begin= DWORD __stdcall GodotGetKerningPairsW(HDC hdc, DWORD nNumPairs, LPKERNINGPAIR lpkrnpair) { DWORD RetVal; // we do not want to make them allocate more memory // than they need to, so we will do this mostly in place RetVal=GetKerningPairsA(hdc, nNumPairs, lpkrnpair); // Begin postcall if((nNumPairs > 0) && (RetVal > 0)) { UINT cpg = CpgFromHdc(hdc); UINT mcs = CbPerChOfCpg(cpg); WORD wTemp; DWORD iPair; for (iPair=0 ; iPair < RetVal ; iPair++) { wTemp = lpkrnpair[iPair].wFirst; lpkrnpair[iPair].wFirst = 0; MultiByteToWideChar(cpg, 0, &(char)wTemp, mcs, &(WCHAR)lpkrnpair[iPair].wFirst, 1); wTemp = lpkrnpair[iPair].wSecond; lpkrnpair[iPair].wSecond = 0; MultiByteToWideChar(cpg, 0, &(char)wTemp, mcs, &(WCHAR)lpkrnpair[iPair].wSecond, 1); } } return RetVal; } End= [EFunc] TemplateName=GetKeyboardLayoutNameW Begin= BOOL __stdcall GodotGetKeyboardLayoutNameW(LPWSTR pwszKLID) { // Begin locals BOOL RetVal; LPSTR pwszKLIDAnsi; _STACKALLOC((KL_NAMELENGTH *g_mcs)+1, pwszKLIDAnsi); if(pwszKLIDAnsi==NULL) { return(FALSE); } RetVal=GetKeyboardLayoutNameA(pwszKLIDAnsi); // Begin postcall if(RetVal) MultiByteToWideChar(g_acp, 0, pwszKLIDAnsi, -1, pwszKLID, gwcslen(pwszKLID)); // Finished return RetVal; } End= [EFunc] TemplateName=GetKeyNameTextW Begin= int __stdcall GodotGetKeyNameTextW(LONG lParam, LPWSTR lpString, int nSize) { int RetVal; UINT cpg = CpgFromLocale(LOWORD(GetKeyboardLayout(0))); UINT mcs = CbPerChOfCpg(cpg); LPSTR lpStringAnsi = GodotHeapAlloc((nSize*mcs) + 1); if(lpStringAnsi==NULL) { SetLastError(ERROR_OUTOFMEMORY); return(0); } RetVal=GetKeyNameTextA(lParam, lpStringAnsi, nSize); if(RetVal) MultiByteToWideChar(cpg, 0, lpStringAnsi, nSize*mcs, lpString, nSize); GodotHeapFree(lpStringAnsi); return RetVal; } End= [EFunc] TemplateName=GetLocaleInfoW Begin= #define NLS_GET_LCTYPE_VALUE(x) (x & ~(LOCALE_NOUSEROVERRIDE | \ LOCALE_USE_CP_ACP | \ LOCALE_RETURN_NUMBER)) int __stdcall GodotGetLocaleInfoW(LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cchData) { LCTYPE LCTypeT = NLS_GET_LCTYPE_VALUE(LCType); // a little validation LOCALE_RETURN_NUMBER checks if ((LCType & LOCALE_RETURN_NUMBER) & (FWIN95())) { // NT/Win2000 return this error if you ask for a number on a string LCType, // So for Win95 we will do the same if you pass this flag at all. SetLastError(ERROR_INVALID_FLAGS); return (0); } if((LCTypeT == LOCALE_RETURN_NUMBER) && (LCTypeT == LOCALE_FONTSIGNATURE)) { // Pass back the unconverted number if thats what they are asking for. // Also, do not convert font signatures since those are not really strings. return(GetLocaleInfoA(Locale, LCType, (LPSTR)lpLCData, cchData)); } else { int RetVal; LPSTR lpLCDataAnsi; UINT cpg; UINT mcs; if (LCType & LOCALE_USE_CP_ACP) { cpg = g_acp; mcs = g_mcs; } else { cpg = CpgFromLocale(Locale); mcs = CbPerChOfCpg(cpg); } _STACKALLOC((cchData+1)*mcs, lpLCDataAnsi); if(lpLCDataAnsi==NULL) { return(0); } RetVal=GetLocaleInfoA(Locale, LCType, lpLCDataAnsi, cchData); if (RetVal) { // Its a string, so lets convert it MultiByteToWideChar(cpg, 0, lpLCDataAnsi, cchData*mcs, lpLCData, cchData); } else if (lpLCData && 0 < cchData) { *lpLCData = L'\0'; } return RetVal; } } End= [EFunc] TemplateName=GetLogColorSpaceW Begin= BOOL __stdcall GodotGetLogColorSpaceW(HCOLORSPACE hColorSpace, LPLOGCOLORSPACEW lcsw, DWORD nSize) { // Begin locals BOOL RetVal; LOGCOLORSPACEA lcsa; ZeroMemory(&lcsa, sizeof(LOGCOLORSPACEA)); RetVal=GetLogColorSpaceA(hColorSpace, &lcsa, nSize); // Begin postcall if(RetVal) { memcpy(lcsw, &lcsa, 6*sizeof(DWORD)+sizeof(LCSCSTYPE)+sizeof(LCSGAMUTMATCH)+sizeof(CIEXYZTRIPLE)); if(FSTRING_VALID(lcsw->lcsFilename)) MultiByteToWideChar(g_acp, 0, lcsa.lcsFilename, -1, lcsw->lcsFilename, MAX_PATH); } // Finished return RetVal; } End= [EFunc] TemplateName=GetLogicalDriveStringsW Begin= DWORD __stdcall GodotGetLogicalDriveStringsW(DWORD nBufferLength, LPWSTR lpBuffer) { // Begin locals DWORD RetVal; LPSTR lpBufferAnsi; _STACKALLOC((nBufferLength*g_mcs)+1, lpBufferAnsi); if(lpBufferAnsi==NULL) { return(0); } RetVal=GetLogicalDriveStringsA(nBufferLength, lpBufferAnsi); // Begin postcall if(RetVal && (RetVal<=nBufferLength)) { // Do not muck with the return value. We have to hope that the // value will accurately tell the caller when their buffer was // not big enough. MultiByteToWideChar(g_acp, 0, lpBufferAnsi, -1, lpBuffer, nBufferLength); } // Finished return RetVal; } End= [EFunc] TemplateName=GetLongPathNameW Begin= DWORD __stdcall GodotGetLongPathNameW(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer) { // Begin locals DWORD RetVal = 0; if (s_pfnGetLongPathNameA == NULL) { // Must allocate stuff for this API call s_pfnGetLongPathNameA = (PFNglpna)GetKernelProc("GetLongPathNameA"); } if (s_pfnGetLongPathNameA) { LPSTR lpszShortPathAnsi; LPSTR lpszLongPathAnsi; UINT cpg = FILES_CPG; _STACKALLOC((cchBuffer*g_mcs)+1, lpszLongPathAnsi); GODOT_TO_CPG_STACKALLOC(lpszShortPath, lpszShortPathAnsi, cpg, g_mcs); if(!lpszShortPathAnsi && lpszShortPath) return(0); RetVal = (s_pfnGetLongPathNameA(lpszShortPathAnsi, lpszLongPathAnsi, cchBuffer)); if(RetVal && (RetVal<=cchBuffer)) MultiByteToWideChar(g_acp, 0, lpszLongPathAnsi, -1, lpszLongPath, cchBuffer); } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return RetVal; } End= [EFunc] TemplateName=GetMenuItemInfoW Begin= BOOL __stdcall GodotGetMenuItemInfoW(HMENU hMenu, UINT uItem, BOOL fByPosition, LPMENUITEMINFOW lpmiiw) { // Begin locals BOOL RetVal; MENUITEMINFOA miia; BOOL fAlloc = MenuItemInfoAfromW(&miia, lpmiiw); RetVal=GetMenuItemInfoA(hMenu, uItem, fByPosition, &miia); // Begin postcall if(RetVal) { memcpy(lpmiiw, &miia, (5*sizeof(UINT)+3*sizeof(HANDLE)+sizeof(ULONG_PTR))); if(fAlloc) { MultiByteToWideChar(g_acp, 0, miia.dwTypeData, miia.cch, lpmiiw->dwTypeData, lpmiiw->cch); lpmiiw->cch = gwcslen(lpmiiw->dwTypeData); } else { lpmiiw->dwTypeData = (LPWSTR)miia.dwTypeData; lpmiiw->cch = sizeof(lpmiiw->dwTypeData); } } if(fAlloc) GodotHeapFree(miia.dwTypeData); // Finished return RetVal; } End= [EFunc] TemplateName=GetMenuStringW Begin= int __stdcall GodotGetMenuStringW(HMENU hMenu, UINT uIDItem, LPWSTR lpString, int nMaxCount, UINT uFlag) { // Begin locals int RetVal; LPSTR lpStringAnsi = NULL; _STACKALLOC((nMaxCount * g_mcs) + 1, lpStringAnsi); if(lpStringAnsi==NULL) { return(0); } ZeroMemory(lpStringAnsi, (nMaxCount * g_mcs) + 1); // Call the 'A' version of the API RetVal=GetMenuStringA(hMenu, uIDItem, lpStringAnsi, nMaxCount, uFlag); // Begin postcall if(RetVal && lpStringAnsi && lpString) MultiByteToWideChar(g_acp, 0, lpStringAnsi, -1, lpString, (RetVal + 1)); // Finished return RetVal; } End= [EFunc] TemplateName=GetMessageW Begin= BOOL __stdcall GodotGetMessageW(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax) { return(GodotReceiveMessage(mtGetMessage, lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, 0)); } End= [EFunc] TemplateName=GetModuleFileNameW Begin= DWORD __stdcall GodotGetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSize) { // Begin locals DWORD RetVal; LPSTR lpFilenameAnsi; _STACKALLOC((nSize*g_mcs)+1, lpFilenameAnsi); if(!lpFilenameAnsi) { SetLastError(ERROR_STACK_OVERFLOW); return(FALSE); } // Call the 'A' version of the API RetVal=GetModuleFileNameA(hModule, lpFilenameAnsi, nSize); // Begin postcall. Per the PSDK: For the ANSI version of the function, the number // of TCHARs is the number of bytes; for the Unicode version, it is the number of // characters. // CONSIDER: Optimize the return value for the case where the buffer was not big // enough? if(RetVal) { MultiByteToWideChar(g_acp, 0, lpFilenameAnsi, -1, lpFilename, nSize); RetVal = gwcslen(lpFilename); } else if (lpFilename && 0 < nSize) *lpFilename = L'\0'; // Finished return RetVal; } End= [EFunc] TemplateName=GetMonitorInfoW Begin= BOOL __stdcall GodotGetMonitorInfoW(HMONITOR hMonitor, LPMONITORINFO lpmi) { // Begin locals BOOL RetVal = FALSE; if (s_pfnGetMonitorInfoA == NULL) { // Must allocate stuff for this API call s_pfnGetMonitorInfoA = (PFNgmia)GetUserProc("GetMonitorInfoA"); } if (s_pfnGetMonitorInfoA) { // Only need to convert anything if caller gave us an EX structure if(lpmi->cbSize == sizeof(MONITORINFOEXW)) { MONITORINFOEXA mia; ZeroMemory(&mia, sizeof(MONITORINFOEXA)); memcpy(&mia, lpmi, (2 * sizeof(DWORD)) + (2 * (sizeof(RECT)))); mia.cbSize = sizeof(MONITORINFOEXA); WideCharToMultiByte(g_acp, 0, ((LPMONITORINFOEXW)lpmi)->szDevice, CCHDEVICENAME, mia.szDevice, CCHDEVICENAME, NULL, NULL); RetVal = (s_pfnGetMonitorInfoA (hMonitor, (LPMONITORINFO)&mia)); if(RetVal) { memcpy(lpmi, &mia, (2 * sizeof(DWORD)) + (2 * (sizeof(RECT)))); MultiByteToWideChar(g_acp, 0, mia.szDevice, -1, ((LPMONITORINFOEXW)lpmi)->szDevice, CCHDEVICENAME); } } else { RetVal = (s_pfnGetMonitorInfoA (hMonitor, lpmi)); } } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return RetVal; } End= [EFunc] TemplateName=GetObjectW Begin= int __stdcall GodotGetObjectW(HGDIOBJ hgdiobj, int cbBuffer, LPVOID lpvObject) { // Begin locals int RetVal; if(GetObjectType(hgdiobj) == OBJ_FONT) { LOGFONTA lfa; RetVal=GetObjectA(hgdiobj, cbBuffer, &lfa); if(RetVal==sizeof(LOGFONTA)) { // Make sure they gave us an object and did not lie about the // size. Found this bug with the Visio Editor test integration. if(lpvObject) LogFontWfromA((LPLOGFONTW)lpvObject, &lfa); RetVal = sizeof(LOGFONTW); } } else { RetVal=GetObjectA(hgdiobj, cbBuffer, lpvObject); } // Finished return RetVal; } End= [EFunc] TemplateName=GetOpenFileNameW Begin= BOOL __stdcall GodotGetOpenFileNameW(LPOPENFILENAMEW lpofn) { return(GetOpenSaveFileHelper(lpofn, TRUE)); } End= [EFunc] TemplateName=GetOpenFileNamePreviewW Begin= BOOL __stdcall GodotGetOpenFileNamePreviewW(LPOPENFILENAMEW lpofn) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(FALSE); } End= [EFunc] TemplateName=GetNamedPipeHandleStateW Begin= BOOL __stdcall GodotGetNamedPipeHandleStateW( HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPWSTR lpUserName, DWORD nMaxUserNameSize ) { // Begin locals BOOL RetVal; LPSTR lpUserNameAnsi; if(lpUserName) { _STACKALLOC((nMaxUserNameSize*g_mcs)+1, lpUserNameAnsi); if(!lpUserNameAnsi) { SetLastError(ERROR_STACK_OVERFLOW); return(FALSE); } } else lpUserNameAnsi = NULL; RetVal=GetNamedPipeHandleStateA(hNamedPipe, lpState, lpCurInstances, lpMaxCollectionCount, lpCollectDataTimeout, lpUserNameAnsi, nMaxUserNameSize ); // Begin postcall if (RetVal && FSTRING_VALID(lpUserName) && FSTRING_VALID(lpUserNameAnsi)) MultiByteToWideChar(g_acp, 0, lpUserNameAnsi, -1, lpUserName, nMaxUserNameSize); // Finished return RetVal; } End= [EFunc] TemplateName=GetNumberFormatW Begin= int __stdcall GodotGetNumberFormatW( LCID Locale, DWORD dwFlags, LPCWSTR lpValue, const NUMBERFMTW * lpFormat, LPWSTR lpNumberStr, int cchNumber ) { // Begin locals int RetVal; LPSTR lpValueAnsi; UINT cpg = CpgFromLocale(Locale); UINT mcs = CbPerChOfCpg(cpg); NUMBERFMTA * lpFormatAnsi; NUMBERFMTA FormatAnsi; // Begin precall GODOT_TO_CPG_STACKALLOC(lpValue, lpValueAnsi, cpg, mcs); if (lpFormat == NULL) lpFormatAnsi = NULL; else { ZeroMemory(&FormatAnsi, sizeof(NUMBERFMTA)); memcpy(&FormatAnsi, lpFormat, (3*sizeof(UINT))); GODOT_TO_CPG_STACKALLOC(lpFormat->lpDecimalSep, FormatAnsi.lpDecimalSep, cpg, mcs); GODOT_TO_CPG_STACKALLOC(lpFormat->lpThousandSep, FormatAnsi.lpThousandSep, cpg, mcs); FormatAnsi.NegativeOrder = lpFormat->NegativeOrder; lpFormatAnsi = &FormatAnsi; } if ((cchNumber > 0) && FSTRING_VALID(lpNumberStr)) { size_t cchBuff = (cchNumber+1)*mcs; LPSTR lpNumberStrAnsi; _STACKALLOC(cchBuff, lpNumberStrAnsi); if(!lpNumberStrAnsi) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } RetVal=GetNumberFormatA(Locale, dwFlags, lpValueAnsi, lpFormatAnsi, lpNumberStrAnsi, cchBuff); if(RetVal > 0) MultiByteToWideChar(cpg, 0, lpNumberStrAnsi, RetVal, lpNumberStr, cchNumber); } else RetVal=GetNumberFormatA(Locale, dwFlags, lpValueAnsi, lpFormatAnsi, NULL, 0); // Finished return RetVal; } End= [EFunc] TemplateName=GetOutlineTextMetricsW Begin= UINT __stdcall GodotGetOutlineTextMetricsW(HDC hdc, UINT cbData, LPOUTLINETEXTMETRICW lpOTM) { // Begin locals UINT RetVal; int cOTM; LPOUTLINETEXTMETRICA lpOTMAnsi = NULL; OUTLINETEXTMETRICW otm; int i; // Begin precall if((lpOTM != NULL) && (cbData > 0)) { cOTM = (sizeof(OUTLINETEXTMETRICW)/cbData); _STACKALLOC(sizeof(OUTLINETEXTMETRICA)*cOTM, lpOTMAnsi); ZeroMemory(lpOTMAnsi, (sizeof(OUTLINETEXTMETRICA)*cOTM)); } else { lpOTMAnsi = NULL; cOTM = 0; } // Call the 'A' version of the API RetVal=GetOutlineTextMetricsA(hdc, cbData, lpOTMAnsi); // Begin postcall if (lpOTM == NULL) { if(RetVal > 0) // We need to return something sensible here: the size of // OUTLINETEXTMETRICW structures. RetVal = (sizeof(OUTLINETEXTMETRICW) * (RetVal / sizeof(OUTLINETEXTMETRICA))); } else { if(RetVal > 0 && lpOTMAnsi) { cOTM = (RetVal / sizeof(OUTLINETEXTMETRICA)); otm = *lpOTM; for (i=0; i < cOTM; i++) { lpOTM->otmSize = sizeof(OUTLINETEXTMETRICW); memcpy(lpOTM, lpOTMAnsi, sizeof(OUTLINETEXTMETRICW)); TextMetricWfromA(&lpOTM->otmTextMetrics, &lpOTMAnsi->otmTextMetrics); lpOTM++; lpOTMAnsi++; } lpOTM = &otm; } } // Finished return RetVal; } End= [EFunc] TemplateName=GetPrinterW Begin= BOOL __stdcall GodotGetPrinterW(HANDLE _noname0, DWORD _noname1, LPBYTE _noname2, DWORD _noname3, LPDWORD _noname4) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(GetPrinterW(_noname0, _noname1, _noname2, _noname3, _noname4)); } End= [EFunc] TemplateName=GetPrinterDataW Begin= DWORD __stdcall GodotGetPrinterDataW(HANDLE _noname0, LPWSTR _noname1, LPDWORD _noname2, LPBYTE _noname3, DWORD _noname4, LPDWORD _noname5) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(GetPrinterDataW(_noname0, _noname1, _noname2, _noname3, _noname4, _noname5)); } End= [EFunc] TemplateName=GetPrinterDriverW Begin= BOOL __stdcall GodotGetPrinterDriverW(HANDLE _noname0, LPWSTR _noname1, DWORD _noname2, LPBYTE _noname3, DWORD _noname4, LPDWORD _noname5) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(GetPrinterDriverW(_noname0, _noname1, _noname2, _noname3, _noname4, _noname5)); } End= [EFunc] TemplateName=GetPrinterDriverDirectoryW Begin= BOOL __stdcall GodotGetPrinterDriverDirectoryW( LPWSTR pName, LPWSTR pEnvironment, DWORD Level, LPBYTE pDriverDirectory, DWORD cbBuf, LPDWORD pcbNeeded ) { BOOL RetVal = FALSE; LPSTR pNameAnsi = NULL; LPSTR pEnvironmentAnsi = NULL; LPBYTE pDriverDirectoryA; ALLOCRETURN arName; ALLOCRETURN arEnvironmentName; // cbBuf is number of bytes, which is at a minimum // big enough to hold the ANSI string _STACKALLOC(cbBuf + 1, pDriverDirectoryA); if(pDriverDirectoryA == NULL) { SetLastError(ERROR_STACK_OVERFLOW); return(FALSE); } arName = GodotToAcpOnHeap(pName, &pNameAnsi); arEnvironmentName = GodotToAcpOnHeap(pEnvironment, &pEnvironmentAnsi); RetVal=GetPrinterDriverDirectoryA(pNameAnsi, pEnvironmentAnsi, Level, pDriverDirectoryA, cbBuf, pcbNeeded); if(RetVal) { MultiByteToWideChar(g_acp, 0, (LPSTR)pDriverDirectoryA, -1, (LPWSTR)pDriverDirectory, cbBuf / sizeof(WCHAR)); if(pcbNeeded) *pcbNeeded = gwcslen((LPWSTR)pDriverDirectory); } else { if(pcbNeeded) *pcbNeeded *= 2; } if(arName==arAlloc) GodotHeapFree(pNameAnsi); if(arEnvironmentName==arAlloc) GodotHeapFree(pEnvironmentAnsi); if(arName == arFailed || arEnvironmentName == arFailed) SetLastError(ERROR_OUTOFMEMORY); return RetVal; } End= [EFunc] TemplateName=GetPrintProcessorDirectoryW Begin= BOOL __stdcall GodotGetPrintProcessorDirectoryW( LPWSTR pName, LPWSTR pEnvironment, DWORD Level, LPBYTE pPrintProcessorInfo, DWORD cbBuf, LPDWORD pcbNeeded ) { BOOL RetVal = FALSE; LPSTR pNameAnsi = NULL; LPSTR pEnvironmentAnsi = NULL; LPBYTE pPrintProcessorInfoA; ALLOCRETURN arName; ALLOCRETURN arEnvironmentName; // cbBuf is number of bytes, which is at a minimum // big enough to hold the ANSI string _STACKALLOC(cbBuf + 1, pPrintProcessorInfoA); if(pPrintProcessorInfoA == NULL) { SetLastError(ERROR_STACK_OVERFLOW); return(FALSE); } arName = GodotToAcpOnHeap(pName, &pNameAnsi); arEnvironmentName = GodotToAcpOnHeap(pEnvironment, &pEnvironmentAnsi); RetVal=GetPrintProcessorDirectoryA(pNameAnsi, pEnvironmentAnsi, Level, pPrintProcessorInfoA, cbBuf, pcbNeeded); if(RetVal) { MultiByteToWideChar(g_acp, 0, (LPSTR)pPrintProcessorInfoA, -1, (LPWSTR)pPrintProcessorInfo, cbBuf / sizeof(WCHAR)); if(pcbNeeded) *pcbNeeded = gwcslen((LPWSTR)pPrintProcessorInfo); } else { if(pcbNeeded) *pcbNeeded *= sizeof(WCHAR); } if(arName==arAlloc) GodotHeapFree(pNameAnsi); if(arEnvironmentName==arAlloc) GodotHeapFree(pEnvironmentAnsi); if(arName == arFailed || arEnvironmentName == arFailed) SetLastError(ERROR_OUTOFMEMORY); return RetVal; } End= [EFunc] TemplateName=GetPrivateProfileSectionW Begin= DWORD __stdcall GodotGetPrivateProfileSectionW(LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName) { // Begin locals DWORD RetVal; LPSTR lpAppNameAnsi; char lpFileNameAnsi[MAX_PATH + 1]; LPSTR lpReturnedStringAnsi; _STACKALLOC((nSize*g_mcs)+1, lpReturnedStringAnsi); if(!lpReturnedStringAnsi) return(0); GODOT_TO_ACP_STACKALLOC(lpAppName, lpAppNameAnsi); if(!lpAppNameAnsi && lpAppName) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } WideCharToMultiByte(g_acp, 0, lpFileName, -1, lpFileNameAnsi, MAX_PATH, NULL, NULL); RetVal=GetPrivateProfileSectionA(lpAppNameAnsi, lpReturnedStringAnsi, nSize, lpFileNameAnsi); if(RetVal) RetVal = GrszToGrwz(lpReturnedStringAnsi, lpReturnedString, nSize); else if(lpReturnedString) { *lpReturnedString = '\0'; } // Finished return RetVal; } End= [EFunc] TemplateName=GetPrivateProfileSectionNamesW Begin= DWORD __stdcall GodotGetPrivateProfileSectionNamesW(LPWSTR lpszReturnBuffer, DWORD nSize, LPCWSTR lpFileName) { // Begin locals DWORD RetVal; char lpFileNameAnsi[MAX_PATH + 1]; LPSTR lpszReturnBufferAnsi; _STACKALLOC((nSize*g_mcs)+1, lpszReturnBufferAnsi); if(!lpszReturnBufferAnsi) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } ZeroMemory(lpszReturnBufferAnsi, (nSize*g_mcs)+1); WideCharToMultiByte(g_acp, 0, lpFileName, -1, lpFileNameAnsi, MAX_PATH, NULL, NULL); RetVal=GetPrivateProfileSectionNamesA(lpszReturnBufferAnsi, nSize, lpFileNameAnsi); if(RetVal) RetVal = GrszToGrwz(lpszReturnBufferAnsi, lpszReturnBuffer, nSize); else if(lpszReturnBuffer) { *lpszReturnBuffer = '\0'; } // Finished return RetVal; } End= [EFunc] TemplateName=GetPrivateProfileStringW Begin= DWORD __stdcall GodotGetPrivateProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName ) { // Begin locals DWORD RetVal; LPSTR lpAppNameAnsi, lpKeyNameAnsi, lpDefaultAnsi; LPSTR lpszRet; char lpFileNameAnsi[MAX_PATH + 1]; _STACKALLOC((nSize*g_mcs)+1, lpszRet); if(lpszRet==NULL) { return(0); } WideCharToMultiByte(g_acp, 0, lpFileName, -1, lpFileNameAnsi, MAX_PATH, NULL, NULL); GODOT_TO_ACP_STACKALLOC(lpAppName, lpAppNameAnsi); GODOT_TO_ACP_STACKALLOC(lpKeyName, lpKeyNameAnsi); GODOT_TO_ACP_STACKALLOC(lpDefault, lpDefaultAnsi); if((!lpAppNameAnsi && lpAppName) || (!lpKeyNameAnsi && lpKeyName) || (!lpDefaultAnsi && lpDefault)) return(0); RetVal=GetPrivateProfileStringA(lpAppNameAnsi, lpKeyNameAnsi, lpDefaultAnsi, lpszRet, nSize, lpFileNameAnsi); if(RetVal) MultiByteToWideChar(g_acp, 0, lpszRet, -1, lpReturnedString, nSize); else if(lpReturnedString) { *lpReturnedString = '\0'; } // Finished return RetVal; } End= [EFunc] TemplateName=GetProcAddress Begin= FARPROC __stdcall GodotGetProcAddress(HMODULE hModule, LPCSTR lpProcName) { // We do not wrap this function to convert strings; we wrap it because // we need to work around the InitMultipleMonitorStubs code in multimon.h // which has its own little delayload implementation built in. if((GetUserHandle() == hModule) && (strcmp(lpProcName, "GetMonitorInfoW") == 0)) { return((FARPROC)&GodotGetMonitorInfoW); } return(GetProcAddress(hModule, lpProcName)); } End= [EFunc] TemplateName=GetProfileSectionW Begin= DWORD __stdcall GodotGetProfileSectionW(LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize) { // Begin locals DWORD RetVal; LPSTR lpAppNameAnsi; LPSTR lpReturnedStringAnsi; _STACKALLOC((nSize*g_mcs)+1, lpReturnedStringAnsi); GODOT_TO_ACP_STACKALLOC(lpAppName, lpAppNameAnsi); if((!lpReturnedStringAnsi) || (lpAppName && !lpAppNameAnsi)) { SetLastError(ERROR_STACK_OVERFLOW); return(FALSE); } RetVal=GetProfileSectionA(lpAppNameAnsi, lpReturnedStringAnsi, nSize); if(RetVal) GrszToGrwz(lpReturnedStringAnsi, lpReturnedString, nSize); else if(lpReturnedString) { *lpReturnedString = '\0'; } // Finished return RetVal; } End= [EFunc] TemplateName=GetProfileStringW Begin= DWORD __stdcall GodotGetProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize ) { // Begin locals DWORD RetVal; LPSTR lpAppNameAnsi, lpKeyNameAnsi, lpDefaultAnsi; LPSTR lpReturnedStringAnsi; _STACKALLOC((nSize*g_mcs)+1, lpReturnedStringAnsi); if(!lpReturnedStringAnsi) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } GODOT_TO_ACP_STACKALLOC(lpAppName, lpAppNameAnsi); GODOT_TO_ACP_STACKALLOC(lpKeyName, lpKeyNameAnsi); GODOT_TO_ACP_STACKALLOC(lpDefault, lpDefaultAnsi); if((!lpAppNameAnsi && lpAppName) || (!lpKeyNameAnsi && lpKeyName) || (!lpDefaultAnsi && lpDefault)) return(0); ZeroMemory(lpReturnedStringAnsi, (nSize*g_mcs)+1); RetVal=GetProfileStringA(lpAppNameAnsi, lpKeyNameAnsi, lpDefaultAnsi, lpReturnedStringAnsi, nSize); if(RetVal) MultiByteToWideChar(g_acp, 0, lpReturnedStringAnsi, -1, lpReturnedString, nSize); else if(lpReturnedString) { *lpReturnedString = '\0'; } // Finished return RetVal; } End= [EFunc] TemplateName=GetPropA Begin= HANDLE __stdcall GodotGetPropA(HWND hWnd, LPCSTR lpString) { if(IsInternalWindowProperty((LPWSTR)lpString, FALSE)) return(FALSE); return(GetPropA(hWnd, lpString)); } End= [EFunc] TemplateName=GetPropW Begin= HANDLE __stdcall GodotGetPropW( HWND hWnd, LPCWSTR lpString) { LPSTR lpStringAnsi; if(IsInternalWindowProperty(lpString, TRUE)) return(FALSE); GODOT_TO_ACP_STACKALLOC(lpString, lpStringAnsi); if(!lpStringAnsi && lpString) return(0); return(GetPropA(hWnd, lpStringAnsi)); } End= [EFunc] TemplateName=GetRoleTextW Begin= UINT __stdcall GodotGetRoleTextW(DWORD lRole, LPWSTR lpszRole, UINT cchRoleMax) { UINT RetVal = 0; if (s_pfnGetRoleTextA == NULL) { // Must allocate stuff for this API call s_pfnGetRoleTextA = (PFNrgta)GetOleAccProc("GetRoleTextA"); } if (s_pfnGetRoleTextA) { if(lpszRole==NULL || cchRoleMax==0) { RetVal = (s_pfnGetRoleTextA(lRole, (LPSTR)NULL, 0)); } else { LPSTR lpszRoleAnsi = GodotHeapAlloc(cchRoleMax * g_mcs); if(lpszRoleAnsi==NULL) { SetLastError(ERROR_OUTOFMEMORY); return(0); } RetVal = (s_pfnGetRoleTextA(lRole, lpszRoleAnsi, cchRoleMax)); if(RetVal) { MultiByteToWideChar(g_acp, 0, lpszRoleAnsi, RetVal + 1, lpszRole, cchRoleMax); RetVal = gwcslen(lpszRole); } GodotHeapFree(lpszRoleAnsi); } } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return RetVal; } End= [EFunc] TemplateName=GetSaveFileNameW Begin= BOOL __stdcall GodotGetSaveFileNameW(LPOPENFILENAMEW lpofn) { return(GetOpenSaveFileHelper(lpofn, FALSE)); } End= [EFunc] TemplateName=GetSaveFileNamePreviewW Begin= BOOL __stdcall GodotGetSaveFileNamePreviewW(LPOPENFILENAMEW lpofn) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(FALSE); } End= [EFunc] TemplateName=GetShortPathNameW Begin= DWORD __stdcall GodotGetShortPathNameW(LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWORD cchBuffer) { // Begin locals DWORD RetVal; LPSTR lpszLongPathAnsi; LPSTR lpszShortPathAnsi; UINT cpg = FILES_CPG; _STACKALLOC((cchBuffer*g_mcs)+1, lpszShortPathAnsi); GODOT_TO_CPG_STACKALLOC(lpszLongPath, lpszLongPathAnsi, cpg, g_mcs); RetVal=GetShortPathNameA(lpszLongPathAnsi, lpszShortPathAnsi, cchBuffer); if(RetVal) MultiByteToWideChar(g_acp, 0, lpszShortPathAnsi, -1, lpszShortPath, cchBuffer); // Finished return RetVal; } End= [EFunc] TemplateName=GetStartupInfoW Begin= void __stdcall GodotGetStartupInfoW(LPSTARTUPINFOW lpsiW) { // Begin locals STARTUPINFOA siA; ZeroMemory(&siA, sizeof(STARTUPINFOA)); siA.lpReserved = 0; siA.cb = sizeof(STARTUPINFOA); // Call the 'A' version of the API GetStartupInfoA(&siA); // Begin postcall lpsiW->cb = sizeof(STARTUPINFOW); lpsiW->lpReserved = NULL; lpsiW->dwX = siA.dwX; lpsiW->dwY = siA.dwY; lpsiW->dwXSize = siA.dwXSize; lpsiW->dwYSize = siA.dwYSize; lpsiW->dwXCountChars = siA.dwXCountChars; lpsiW->dwYCountChars = siA.dwYCountChars; lpsiW->dwFillAttribute = siA.dwFillAttribute; lpsiW->dwFlags = siA.dwFlags; lpsiW->wShowWindow = siA.wShowWindow; lpsiW->cbReserved2 = siA.cbReserved2; lpsiW->lpReserved2 = siA.lpReserved2; lpsiW->hStdInput = siA.hStdInput; lpsiW->hStdOutput = siA.hStdOutput; lpsiW->hStdError = siA.hStdError; // For the strings, we have to use our static buffers. // The OS returns actual pointers to the process startup // info, which we cannot do because that info is ANSI! if(FSTRING_VALID(siA.lpDesktop)) { MultiByteToWideChar(g_acp, 0, siA.lpDesktop, -1, m_wzDesktop, 256); lpsiW->lpDesktop = m_wzDesktop; } if(FSTRING_VALID(siA.lpTitle)) { MultiByteToWideChar(g_acp, 0, siA.lpTitle, -1, m_wzTitle, 256); lpsiW->lpTitle = m_wzTitle; } return; } End= [EFunc] TemplateName=GetStateTextW Begin= UINT __stdcall GodotGetStateTextW(DWORD lStateBit, LPWSTR lpszState, UINT cchState) { UINT RetVal = 0; if (s_pfnGetStateTextA == NULL) { // Must allocate stuff for this API call s_pfnGetStateTextA = (PFNgsta)GetOleAccProc("GetStateTextA"); } if (s_pfnGetStateTextA) { if(lpszState==NULL) { RetVal = (s_pfnGetStateTextA(lStateBit, (LPSTR)lpszState, cchState)); } else { LPSTR lpszStateAnsi = GodotHeapAlloc(cchState * g_mcs); if(lpszStateAnsi==NULL) { SetLastError(ERROR_OUTOFMEMORY); return(0); } RetVal = (s_pfnGetStateTextA(lStateBit, lpszStateAnsi, cchState)); if(RetVal) { MultiByteToWideChar(g_acp, 0, lpszStateAnsi, RetVal + 1, lpszState, cchState); RetVal = gwcslen(lpszState); } GodotHeapFree(lpszStateAnsi); } } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return RetVal; } End= [EFunc] TemplateName=GetStringTypeW Begin= BOOL __stdcall GodotGetStringTypeW(DWORD dwInfoType, LPWSTR lpSrcStr, int cchSrc, LPWORD lpCharType) { // Note that we insert a LOCALE_SYSTEM_DEFAULT Locale as the "W" // version does not have the Locale param. After all, we want to // look like NT does, not have just a Unicode wrapper around // the Win9x function, which would be compatible with nothing. LCID Locale = LOCALE_SYSTEM_DEFAULT; UINT cpg = CpgFromLocale(Locale); UINT mcs = CbPerChOfCpg(cpg); LPSTR lpSrcStrAnsi; // Begin precall GODOT_TO_CPG_STACKALLOC(lpSrcStr, lpSrcStrAnsi, cpg, mcs); if(!lpSrcStrAnsi && lpSrcStr) return(FALSE); return(GetStringTypeA(Locale, dwInfoType, lpSrcStrAnsi, cchSrc, lpCharType)); } End= [EFunc] TemplateName=GetSystemDirectoryW Begin= UINT __stdcall GodotGetSystemDirectoryW(LPWSTR lpBuffer, UINT uSize) { // Begin locals UINT RetVal; LPSTR lpBufferAnsi; _STACKALLOC((uSize*g_mcs)+1, lpBufferAnsi); if(lpBufferAnsi==NULL) { return(0); } // Call the 'A' version of the API RetVal=GetSystemDirectoryA(lpBufferAnsi, uSize); // Begin postcall if(RetVal) MultiByteToWideChar(g_acp, 0, lpBufferAnsi, -1, lpBuffer, uSize); // Finished return RetVal; } End= [EFunc] TemplateName=GetSystemWindowsDirectoryW Begin= UINT __stdcall GodotGetSystemWindowsDirectoryW(LPWSTR lpBuffer, UINT uSize) { // Begin locals UINT RetVal; LPSTR lpBufferAnsi; _STACKALLOC((uSize*g_mcs)+1, lpBufferAnsi); if(lpBufferAnsi==NULL) { return(0); } // Call the 'A' version of the API. Note that there IS no // GetSystemWindowsDirectory on Win9x. But since on a // single user system it is the same as the old // GetWindowsDirectory call, we can cheat very effectively. RetVal=GetWindowsDirectoryA(lpBufferAnsi, uSize); // Begin postcall if(RetVal) MultiByteToWideChar(g_acp, 0, lpBufferAnsi, -1, lpBuffer, uSize); // Finished return RetVal; } End= [EFunc] TemplateName=GetTempFileNameW Begin= UINT __stdcall GodotGetTempFileNameW(LPCWSTR lpPathName, LPCWSTR lpPrefixString, UINT uUnique, LPWSTR lpTempFileName) { // Begin locals UINT RetVal; LPSTR lpPathNameAnsi; LPSTR lpPrefixStringAnsi; char lpTempFileNameAnsi[MAX_PATH + 1]; UINT cpg = FILES_CPG; // Begin precall GODOT_TO_CPG_STACKALLOC(lpPathName, lpPathNameAnsi, cpg, g_mcs); GODOT_TO_CPG_STACKALLOC(lpPrefixString, lpPrefixStringAnsi, cpg, g_mcs); RetVal=GetTempFileNameA(lpPathNameAnsi, lpPrefixStringAnsi, uUnique, lpTempFileNameAnsi); if(RetVal) MultiByteToWideChar(cpg, 0, lpTempFileNameAnsi, MAX_PATH, lpTempFileName, MAX_PATH); // Finished return RetVal; } End= [EFunc] TemplateName=GetTempPathW Begin= DWORD __stdcall GodotGetTempPathW(DWORD nBufferLength, LPWSTR lpBuffer) { DWORD RetVal; if(nBufferLength > MAX_PATH || !FSTRING_VALID(lpBuffer)) { SetLastError(ERROR_INVALID_PARAMETER); RetVal = 0; } else { char lpBufferAnsi[MAX_PATH + 1]; // Call the 'A' version of the API RetVal=GetTempPathA(nBufferLength, lpBufferAnsi); // Begin postcall if(RetVal) MultiByteToWideChar(FILES_CPG, 0, lpBufferAnsi, MAX_PATH, lpBuffer, MAX_PATH); } // Finished return RetVal; } End= [EFunc] TemplateName=GetTextExtentExPointW Begin= BOOL __stdcall GodotGetTextExtentExPointW(HDC hdc, LPCWSTR lpString, int cchString, int nMaxExtent, LPINT lpnFit, LPINT alpDx, LPSIZE lpSize) { LPSTR lpStringAnsi; UINT cpg = CpgFromHdc(hdc); UINT mcs = CbPerChOfCpg(cpg); GODOT_TO_CPG_STACKALLOC(lpString, lpStringAnsi, cpg, mcs); if(lpStringAnsi==NULL) { return(FALSE); } return(GetTextExtentExPointA(hdc, lpStringAnsi, cchString, nMaxExtent, lpnFit, alpDx, lpSize)); } End= [EFunc] TemplateName=GetTextExtentPoint32W Begin= BOOL __stdcall GodotGetTextExtentPoint32W(HDC hdc, LPCWSTR lpString, int cbString, LPSIZE lpSize) { // Begin locals BOOL RetVal; LPSTR lpStringAnsi; size_t lpStringLength; UINT cpg = CpgFromHdc(hdc); UINT mcs = CbPerChOfCpg(cpg); LPWSTR lpStringCopy; LPWSTR lpwchT; LPWSTR lpwchEnd; BOOL fDefault; lpStringCopy = GodotHeapAlloc((cbString + 1) * sizeof(WCHAR)); if(lpStringCopy==NULL) { SetLastError(ERROR_OUTOFMEMORY); return(FALSE); } lpwchT = lpStringCopy; lpwchEnd = lpStringCopy + cbString; // make a copy so we can muck with it memcpy(lpStringCopy, lpString, cbString * sizeof(WCHAR)); lpStringCopy[cbString] = L'\0'; // This is a workaround for Win95 bug which causes U+00B7 character to // be rendered improperly when using the wide API (substituting U+2219 // achieves the desired effect for some reason!) // Note: nobuyah suggested in an MSO code review that this might be a // perf issue? while (lpwchT < lpwchEnd) { if (*lpwchT == 0x00b7) *lpwchT = 0x2219; lpwchT++; } if (FDBCS_CPG(cpg)) { fDefault = FALSE; if (FSTRING_VALID(lpStringCopy)) { lpStringLength = gwcslen(lpStringCopy)+1; _STACKALLOC(lpStringLength*mcs, lpStringAnsi); if(lpStringAnsi==NULL) { GodotHeapFree(lpStringCopy); return(FALSE); } WideCharToMultiByte(cpg, WC_DEFAULTCHAR|WC_COMPOSITECHECK, // default char handling lpStringCopy, lpStringLength, lpStringAnsi, lpStringLength*mcs, NULL, &fDefault); } else lpStringAnsi = (LPSTR)lpStringCopy; if (fDefault) { // GetTextExtentPoint32W() GPFs on Win 95 FE for chars above U+00FF // Instead use a sum of GetCharWidthW() calls, plus the difference // between GetCharWidthW() of 'X' and GetTextExtentPoint32W of 'X' // when we detect this case. (Stole this logic from MSO). WCHAR wchX = L'X'; int dxp; int dxpX; int dxpT; RetVal = GetTextExtentPoint32W(hdc, &wchX, 1, lpSize); if (RetVal) { GodotGetCharWidthW(hdc, 'X', 'X', &dxpX); for (dxp = 0, lpwchT = lpStringCopy; lpwchT < lpwchEnd; ++lpwchT) { GodotGetCharWidthW(hdc, *lpwchT, *lpwchT, &dxpT); dxp += dxpT; } lpSize->cx = lpSize->cx - dxpX + dxp; } } else { // Call the 'A' version of the API RetVal=GetTextExtentPoint32A(hdc, lpStringAnsi, cbString, lpSize); } } else { // Call the 'W' version of the API RetVal=GetTextExtentPoint32W(hdc, lpStringCopy, cbString, lpSize); } // Finished GodotHeapFree(lpStringCopy); return RetVal; } End= [EFunc] TemplateName=GetTextExtentPointW Begin= BOOL __stdcall GodotGetTextExtentPointW(HDC hdc, LPCWSTR lpString, int cbString, LPSIZE lpSize) { LPSTR lpStringAnsi; UINT cpg; UINT mcs; cpg = CpgFromHdc(hdc); mcs = CbPerChOfCpg(cpg); GODOT_TO_CPG_STACKALLOC(lpString, lpStringAnsi, cpg, mcs); if(lpStringAnsi==NULL) { return(FALSE); } return(GetTextExtentPointA(hdc, lpStringAnsi, cbString, lpSize)); } End= [EFunc] TemplateName=GetTextFaceW Begin= int __stdcall GodotGetTextFaceW(HDC hdc, int nCount, LPWSTR lpFaceName) { // Begin locals int RetVal; LPSTR lpFaceNameAnsi; _STACKALLOC((nCount*g_mcs)+1, lpFaceNameAnsi); if(lpFaceNameAnsi==NULL) { return(0); } // Call the 'A' version of the API RetVal=GetTextFaceA(hdc, nCount, lpFaceNameAnsi); // Begin postcall if(RetVal) MultiByteToWideChar(g_acp, 0, lpFaceNameAnsi, -1, lpFaceName, nCount); // Finished return RetVal; } End= [EFunc] TemplateName=GetTextMetricsW Begin= BOOL __stdcall GodotGetTextMetricsW(HDC hdc, LPTEXTMETRICW lptm) { // Begin locals BOOL RetVal; TEXTMETRICA tma; ZeroMemory(&tma, sizeof(TEXTMETRICA)); RetVal=GetTextMetricsA(hdc, &tma); // Begin postcall if(RetVal) TextMetricWfromA(lptm, &tma); // Finished return RetVal; } End= [EFunc] TemplateName=GetTimeFormatW Begin= int __stdcall GodotGetTimeFormatW( LCID Locale, DWORD dwFlags, const SYSTEMTIME * lpTime, LPCWSTR lpFormat, LPWSTR lpTimeStr, int cchTime ) { // Begin locals int RetVal; LPSTR lpFormatAnsi; UINT cpg; UINT mcs; // Begin precall if(dwFlags & LOCALE_USE_CP_ACP) { cpg = g_acp; mcs = g_mcs; } else { cpg = CpgFromLocale(Locale); mcs = CbPerChOfCpg(cpg); } GODOT_TO_CPG_STACKALLOC(lpFormat, lpFormatAnsi, cpg, mcs); if (FSTRING_VALID(lpTimeStr) && (cchTime > 0)) { LPSTR lpTimeStrAnsi; _STACKALLOC((cchTime*mcs)+1, lpTimeStrAnsi); ZeroMemory(lpTimeStrAnsi, (cchTime*mcs)+1); RetVal=GetTimeFormatA(Locale, dwFlags, lpTime, lpFormatAnsi, lpTimeStrAnsi, ((cchTime+1)*mcs)); if(RetVal) MultiByteToWideChar(cpg, 0, lpTimeStrAnsi, cchTime*mcs, lpTimeStr, cchTime); } else RetVal=GetTimeFormatA(Locale, dwFlags, lpTime, lpFormatAnsi, NULL, cchTime); if ((RetVal == 0) && lpTimeStr && 0 < cchTime) *lpTimeStr = L'\0'; return RetVal; } End= [EFunc] TemplateName=GetUserNameW Begin= BOOL __stdcall GodotGetUserNameW(LPWSTR lpBuffer, LPDWORD nSize) { // Begin locals BOOL RetVal; LPSTR lpBufferAnsi; if(!nSize) { SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } _STACKALLOC((*nSize * g_mcs) + 1, lpBufferAnsi); if(lpBufferAnsi==NULL) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } ZeroMemory(lpBufferAnsi, (*nSize * g_mcs) + 1); // Call the 'A' version of the API RetVal=GetUserNameA(lpBufferAnsi, nSize); // Begin postcall if(RetVal && lpBuffer && nSize) MultiByteToWideChar(g_acp, 0, lpBufferAnsi, -1, lpBuffer, *(nSize)); // nSize has TCHARs, which should be okay for the buffer here // Finished return RetVal; } End= [EFunc] TemplateName=GetVersionExW Begin= BOOL __stdcall GodotGetVersionExW(LPOSVERSIONINFOW lpVersionInformation) { // Begin locals BOOL RetVal; // Note that even if they pass a OSVERSIONINFOEXW structure, we are // only going with the the old OSVERSIONINFO part, since the other // stuff is not supported on Win9x if(lpVersionInformation->dwOSVersionInfoSize < sizeof(OSVERSIONINFOW)) { SetLastError(ERROR_INSUFFICIENT_BUFFER); return(FALSE); } else { OSVERSIONINFOA osvia; ZeroMemory(&osvia, sizeof(OSVERSIONINFOA)); osvia.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA); RetVal=GetVersionExA(&osvia); // Begin postcall if(RetVal) { memcpy(lpVersionInformation, &osvia, (5*sizeof(DWORD))); MultiByteToWideChar(g_acp, 0, osvia.szCSDVersion, -1, lpVersionInformation->szCSDVersion, 128); } // Finished return RetVal; } } End= [EFunc] TemplateName=GetVolumeInformationW Begin= BOOL __stdcall GodotGetVolumeInformationW( LPCWSTR lpRootPathName, LPWSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPWSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize ) { // Begin locals BOOL RetVal; LPSTR lpRootPathNameAnsi; LPSTR lpVolumeNameBufferAnsi; DWORD cbVolumeNameBuffer; LPSTR lpFileSystemNameBufferAnsi; DWORD cbFileSystemNameBuffer; // Begin precall GODOT_TO_ACP_STACKALLOC(lpRootPathName, lpRootPathNameAnsi); if((lpVolumeNameBuffer && (nVolumeNameSize > 0))) { cbVolumeNameBuffer = (nVolumeNameSize*g_mcs)+1; _STACKALLOC(cbVolumeNameBuffer, lpVolumeNameBufferAnsi); } else { cbVolumeNameBuffer = 0; lpVolumeNameBufferAnsi = NULL; } if((lpFileSystemNameBuffer && (nFileSystemNameSize > 0))) { cbFileSystemNameBuffer = (nFileSystemNameSize*g_mcs)+1; _STACKALLOC(cbFileSystemNameBuffer, lpFileSystemNameBufferAnsi); } else { cbFileSystemNameBuffer = 0; lpFileSystemNameBufferAnsi = NULL; } // Call the 'A' version of the API RetVal=GetVolumeInformationA( lpRootPathNameAnsi, lpVolumeNameBufferAnsi, cbVolumeNameBuffer, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, lpFileSystemNameBufferAnsi, cbFileSystemNameBuffer ); // Begin postcall if(RetVal) { if(lpVolumeNameBufferAnsi && lpVolumeNameBuffer && nVolumeNameSize) MultiByteToWideChar(g_acp, 0, lpVolumeNameBufferAnsi, -1, lpVolumeNameBuffer, nVolumeNameSize); if(lpFileSystemNameBufferAnsi && lpFileSystemNameBuffer && nFileSystemNameSize) MultiByteToWideChar(g_acp, 0, lpFileSystemNameBufferAnsi, -1, lpFileSystemNameBuffer, nFileSystemNameSize); } else { if (lpVolumeNameBuffer && (0 < nVolumeNameSize)) *lpVolumeNameBuffer = L'\0'; if (lpFileSystemNameBuffer && (0 < nFileSystemNameSize)) *lpFileSystemNameBuffer = L'\0'; } // Finished return RetVal; } End= [EFunc] TemplateName=GetWindowLongA Begin= LONG __stdcall GodotGetWindowLongA(HWND hWnd, int nIndex) { return(GetWindowLongInternal(hWnd, nIndex, FALSE)); } End= [EFunc] TemplateName=GetWindowLongW Begin= LONG __stdcall GodotGetWindowLongW(HWND hWnd, int nIndex) { return(GetWindowLongInternal(hWnd, nIndex, TRUE)); } End= [EFunc] TemplateName=GetWindowModuleFileNameW Begin= UINT __stdcall GodotGetWindowModuleFileNameW(HWND hwnd, LPWSTR pszFileName, UINT cchFileNameMax) { // Begin locals UINT RetVal = 0; if (s_pfnGetWindowModuleFileNameA == NULL) { // Must allocate stuff for this API call s_pfnGetWindowModuleFileNameA = (PFNgwmfna)GetUserProc("GetWindowModuleFileNameA"); } if (s_pfnGetWindowModuleFileNameA) { LPSTR pszFileNameAnsi; _STACKALLOC((cchFileNameMax*g_mcs)+1, pszFileNameAnsi); if(pszFileNameAnsi==NULL) { return(0); } RetVal = (s_pfnGetWindowModuleFileNameA(hwnd, pszFileNameAnsi, cchFileNameMax)); // Begin postcall if(RetVal) MultiByteToWideChar(g_acp, 0, pszFileNameAnsi, -1, pszFileName, cchFileNameMax); } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return RetVal; } End= [EFunc] TemplateName=GetWindowsDirectoryW Begin= UINT __stdcall GodotGetWindowsDirectoryW(LPWSTR lpBuffer, UINT uSize) { // Begin locals UINT RetVal; LPSTR lpBufferAnsi; _STACKALLOC((uSize*g_mcs)+1, lpBufferAnsi); if(lpBufferAnsi==NULL) { return(0); } // Call the 'A' version of the API RetVal=GetWindowsDirectoryA(lpBufferAnsi, uSize); // Begin postcall if(RetVal && lpBuffer && uSize) MultiByteToWideChar(g_acp, 0, lpBufferAnsi, -1, lpBuffer, uSize); // Finished return RetVal; } End= [EFunc] TemplateName=GetWindowTextW Begin= int __stdcall GodotGetWindowTextW(HWND hWnd, LPWSTR lpString, int nMaxCount) { /******* Blackbox Testing results for GetWindowText Win32 API ****** (information taken from VSANSI layer comments) TestCase lpString nMaxCount Return Value *lpString modified ====================================================================== Testing GetWindowTextW on WinNT :- A !NULL 0 0 No B NULL 0 0 No C NULL !0 0 No D !NULL !0 cch w/o \0 Yes Testing GetWindowTextA on Win95 :- A !NULL 0 0 Yes B NULL 0 GPF!! C NULL !0 GPF!! D !NULL !0 cch w/o \0 Yes *********************************************************************/ if(!(lpString && nMaxCount > 0)) { // If they did not pass a buffer, then we take no chances. SetLastError(ERROR_INSUFFICIENT_BUFFER); return(0); } else { int RetVal; LPSTR lpStringAnsi; lpStringAnsi = GodotHeapAlloc((nMaxCount*g_mcs)+1); if(lpStringAnsi==NULL) { return(0); } ZeroMemory(lpStringAnsi, (nMaxCount*g_mcs)+1); RetVal=GetWindowTextA(hWnd, lpStringAnsi, nMaxCount); if(RetVal) { MultiByteToWideChar(g_acp, 0, lpStringAnsi, -1, lpString, nMaxCount); RetVal = gwcslen(lpString); lpString[nMaxCount - 1] = L'\0'; } else { // On some Win9x platforms (i.e. Millenium) they will still return 0 // if the buffer is not large enough, even though PSDK docs claim // they will just truncate. Lets mimic the NT behavior. if((GetLastError() == ERROR_INSUFFICIENT_BUFFER) && (lpStringAnsi) && (*lpStringAnsi)) { MultiByteToWideChar(g_acp, 0, lpStringAnsi, -1, lpString, nMaxCount); RetVal = gwcslen(lpString); } else if(lpString) { // GetWindowText() returns 0 when you call it on a window which // has no text (e.g. edit control without any text). It also initializes // the buffer passed in to receive the text to "\0". So we should initialize // the buffer passed in before returning. *lpString = L'\0'; } } GodotHeapFree(lpStringAnsi); return RetVal; } } End= [EFunc] TemplateName=GetWindowTextLengthW Begin= int __stdcall GodotGetWindowTextLengthW(HWND hWnd) { int RetVal; RetVal=GetWindowTextLengthA(hWnd); // Note that on DBCS Win9x, this number can be up // to twice what the window actually contains. if((RetVal != 0) && FDBCS_CPG(g_acp)) { __try { int nMaxCountAnsi = RetVal + 1; LPSTR lpStringAnsi; // They might have a whole MB of text here, so lets call the // safe version of the macro lpStringAnsi = _alloca(nMaxCountAnsi); // Note that we do *not* call GodotGetWindowTextW, as // this would force an additional stack alloc on us. if(GetWindowTextA(hWnd, lpStringAnsi, nMaxCountAnsi) > 0) { int nMaxCount = (RetVal + 1) * sizeof(WCHAR); LPWSTR lpString; lpString = _alloca(nMaxCount); return(MultiByteToWideChar(g_acp, 0, lpStringAnsi, -1, lpString, nMaxCount)); } } __except( EXCEPTION_EXECUTE_HANDLER ) { gresetstkoflw(); // We failed here; no biggee, we already picked up an // answer from the original call. } // If GetWindowTextA failed we will let the retval // stand, as we are no worse off than before. return(RetVal); } return(RetVal); } End= [EFunc] TemplateName=GlobalGetAtomNameW Begin= UINT __stdcall GodotGlobalGetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize) { // Begin locals UINT RetVal; LPSTR lpBufferAnsi; _STACKALLOC((nSize*g_mcs)+1, lpBufferAnsi); if(lpBufferAnsi==NULL) { return(0); } // Call the 'A' version of the API RetVal=GlobalGetAtomNameA(nAtom, lpBufferAnsi, nSize); // Begin postcall if(RetVal) MultiByteToWideChar(g_acp, 0, lpBufferAnsi, -1, lpBuffer, nSize); // Finished return RetVal; } End= [EFunc] TemplateName=GrayStringW Begin= BOOL __stdcall GodotGrayStringW( HDC hDC, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc, LPARAM lpData, int nCount, int X, int Y, int nWidth, int nHeight ) { LPGODOTTLSINFO lpgti; LPARAM lpDataAnsi; BOOL RetVal; UINT cpg = CpgFromHdc(hDC); UINT mcs = CbPerChOfCpg(cpg); if((lpOutputFunc == NULL) && ((void *)lpData == NULL)) { // We must have at least one of these! SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } else if(lpOutputFunc == NULL) { // No callback, so this is easy: one convert and off to the "A" version. GODOT_TO_CPG_STACKALLOC(lpData, lpDataAnsi, cpg, mcs); return(GrayStringA(hDC, hBrush, lpOutputFunc, lpDataAnsi, nCount, X, Y, nWidth, nHeight)); } else { // They have a callback, so we have to use it. if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(FALSE); } if((lpgti->pfnGrayString && (lpgti->pfnGrayString != lpOutputFunc)) || lpgti->cGrayString >= GODOTMAXREFCOUNT) { // A hook is already defined SetLastError(ERROR_INVALID_FILTER_PROC); return(FALSE); } lpgti->pfnGrayString = lpOutputFunc; lpgti->cpgGrayString = cpg; lpgti->cGrayString++; RetVal = GrayStringA(hDC, hBrush, &GrayStringProc, lpData, nCount, X, Y, nWidth, nHeight); lpgti->cGrayString--; lpgti->pfnGrayString = NULL; return(RetVal); } } End= [EFunc] TemplateName=InitializeSecurityContextW Begin= SECURITY_STATUS __stdcall GodotInitializeSecurityContextW( PCredHandle phCredential, PCtxtHandle phContext, SEC_WCHAR SEC_FAR * pTargetName, unsigned long int fContextReq, unsigned long int Reserved1, unsigned long int TargetDataRep, PSecBufferDesc pInput, unsigned long int Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput, unsigned long int * pfContextAttr, PTimeStamp ptsExpiry ) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(SEC_E_UNSUPPORTED_FUNCTION); } End= [EFunc] TemplateName=InitSecurityInterfaceW Begin= PSecurityFunctionTableW __stdcall GodotInitSecurityInterfaceW(void) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(NULL); } End= [EFunc] TemplateName=InsertMenuItemW Begin= BOOL __stdcall GodotInsertMenuItemW(HMENU hMenu, UINT uItem, BOOL fByPosition, LPCMENUITEMINFOW lpmiiw) { // Begin locals BOOL RetVal; MENUITEMINFOA miia; BOOL fAlloc = MenuItemInfoAfromW(&miia, lpmiiw); RetVal=InsertMenuItemA(hMenu, uItem, fByPosition, &miia); if(fAlloc) GodotHeapFree(miia.dwTypeData); // Finished return RetVal; } End= [EFunc] TemplateName=IsBadStringPtrW Begin= BOOL __stdcall GodotIsBadStringPtrW(LPCWSTR lpwz, UINT_PTR cchMax) { if(cchMax > 0) { if(lpwz == NULL) return(TRUE); else { // The function is documented as checking the smaller of the number // of bytes covered by the specified NULL terminated UNICODE string, // or the number of WCHARs specified by cchMax. Note that cchMax may // be -1 (meaning "go to the string's end") but that's ok because // the loop down below will look for the terminator. LPCWSTR lpwzStart = lpwz; LPCWSTR lpwzEnd = &lpwzStart[cchMax - 1]; WCHAR wch = L'\0'; _try { do { wch = *(volatile WCHAR *)lpwzStart; lpwzStart++; } // back up one for the string check since we have // already advanced. while(wch && ((lpwzStart - 1) != lpwzEnd)); } _except(EXCEPTION_EXECUTE_HANDLER) { //if(GetExceptionCode == EXCEPTION_ACCESS_VIOLATION) return(TRUE); } } } // if we made it here, then the string is good return(FALSE); } End= [EFunc] TemplateName=IsCharAlphaW Begin= BOOL __stdcall GodotIsCharAlphaW(WCHAR ch) { CHAR chAnsi[] = "\0\0"; BOOL fUsedDefault = FALSE; if (&ch != NULL) WideCharToMultiByte(g_acp, 0, (LPWSTR)&ch, 1, (LPSTR)&chAnsi, g_mcs, NULL, &fUsedDefault); else return(FALSE); if(!fUsedDefault) return(IsCharAlphaA(*chAnsi)); SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } End= [EFunc] TemplateName=IsCharAlphaNumericW Begin= BOOL __stdcall GodotIsCharAlphaNumericW(WCHAR ch) { CHAR chAnsi[] = "\0\0"; BOOL fUsedDefault = FALSE; if (&ch != NULL) WideCharToMultiByte(g_acp, 0, (LPWSTR)&ch, 1, (LPSTR)&chAnsi, 1, NULL, &fUsedDefault); else return(FALSE); if(!fUsedDefault) return(IsCharAlphaNumericA(*chAnsi)); SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } End= [EFunc] TemplateName=IsCharLowerW Begin= BOOL __stdcall GodotIsCharLowerW(WCHAR ch) { CHAR chAnsi[] = "\0\0"; BOOL fUsedDefault = FALSE; if (&ch != NULL) WideCharToMultiByte(g_acp, 0, (LPWSTR)&ch, 1, (LPSTR)&chAnsi, g_mcs, NULL, &fUsedDefault); else return(FALSE); if(!fUsedDefault) return(IsCharLowerA(*chAnsi)); SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } End= [EFunc] TemplateName=IsCharUpperW Begin= BOOL __stdcall GodotIsCharUpperW(WCHAR ch) { CHAR chAnsi[] = "\0\0"; BOOL fUsedDefault = FALSE; if (&ch != NULL) WideCharToMultiByte(g_acp, 0, (LPWSTR)&ch, 1, (LPSTR)&chAnsi, g_mcs, NULL, &fUsedDefault); else return(FALSE); if(!fUsedDefault) return(IsCharUpperA(*chAnsi)); SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } End= [EFunc] TemplateName=IsClipboardFormatAvailable Begin= BOOL __stdcall GodotIsClipboardFormatAvailable(UINT format) { BOOL RetVal = IsClipboardFormatAvailable(format); if(!RetVal) { // The API failed, lets find out if our more // intelligent opinion differs from theirs. if(format==CF_UNICODETEXT) { // CF_UNICODETEXT is legal if it will take CF_TEXT RetVal = IsClipboardFormatAvailable(CF_TEXT); } else if((format==CF_TEXT) || (format==CF_OEMTEXT)) { // CF_TEXT is legal if it will take CF_UNICODETEXT RetVal = IsClipboardFormatAvailable(CF_UNICODETEXT); } } return(RetVal); } End= [EFunc] TemplateName=IsDestinationReachableW Begin= BOOL __stdcall GodotIsDestinationReachableW(LPCWSTR lpszDestination, LPQOCINFO lpQOCInfo) { if (s_pfnIsDestinationReachableA == NULL) { // Must allocate stuff for this API call s_pfnIsDestinationReachableA = (pfnIDRA)GetSensApiProc("IsDestinationReachableA"); } if (s_pfnIsDestinationReachableA) { LPSTR lpszDestinationAnsi; GODOT_TO_ACP_STACKALLOC(lpszDestination, lpszDestinationAnsi); if(!lpszDestinationAnsi && lpszDestination) return(FALSE); return(s_pfnIsDestinationReachableA(lpszDestinationAnsi, lpQOCInfo)); } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(FALSE); } End= [EFunc] TemplateName=IsTextUnicode Begin= BOOL __stdcall GodotIsTextUnicode(void * lpBuffer, int cb, LPINT lpi) { // We need this API for our own usage, so we may as // well give it to users as well. return(RtlIsTextUnicode(lpBuffer, cb, (PULONG)lpi)); } End= [EFunc] TemplateName=IsValidCodePage Begin= // IsValidCodePage is wrapped for UTF-7/UTF-8 support BOOL __stdcall GodotIsValidCodePage(UINT CodePage) { // Return success for these code pages if ((CodePage == CP_UTF7) || (CodePage == CP_UTF8)) return (TRUE); // Return TRUE if the DLL is there if (CodePage == CP_GB18030) return(0 != GetGB18030Handle()); return(IsValidCodePage(CodePage)); } End= [EFunc] TemplateName=IsWindowUnicode Begin= // IsWindowUnicode wrapped since the windows we create are kinda Unicode, right? :-) BOOL __stdcall GodotIsWindowUnicode(HWND hWnd) { if (IsWindow(hWnd)) return(GetUnicodeWindowProp(hWnd)); // Not a valid window. We cannot live with the GetLastError set by // IsWindow (ERROR_INVALID_ADDRESS) since IsWindowUnicode does // something different SetLastError(ERROR_INVALID_WINDOW_HANDLE); return FALSE; // IsWindowUnicode(hWnd); } End= [EFunc] TemplateName=IsDialogMessageW Begin= BOOL __stdcall GodotIsDialogMessageW(HWND hDlg, LPMSG lpMsg) { return((BOOL)GodotDispatchMessage(mtIsDialogMessage, hDlg, 0, lpMsg)); } End= [EFunc] TemplateName=joyGetDevCapsW Begin= MMRESULT __stdcall GodotjoyGetDevCapsW(UINT_PTR uJoyID, LPJOYCAPSW pjc, UINT cbjc) { // UNSUPPORTED FUNCTION: Documented as a failure stub if(cbjc < sizeof(JOYCAPSW)) { return(MMSYSERR_INVALPARAM); } else { JOYCAPSA jcA; MMRESULT RetVal; ZeroMemory(&jcA, sizeof(JOYCAPSA)); RetVal = joyGetDevCapsA(uJoyID, &jcA, sizeof(JOYCAPSA)); if(RetVal == MMSYSERR_NOERROR) { pjc->wMid = jcA.wMid; pjc->wPid = jcA.wPid; pjc->wXmin = jcA.wXmin; pjc->wXmax = jcA.wXmax; pjc->wYmin = jcA.wYmin; pjc->wYmax = jcA.wYmax; pjc->wZmin = jcA.wZmin; pjc->wZmax = jcA.wZmax; pjc->wNumButtons = jcA.wNumButtons; pjc->wPeriodMin = jcA.wPeriodMin; pjc->wPeriodMax = jcA.wPeriodMax; pjc->wRmin = jcA.wRmin; pjc->wRmax = jcA.wRmax; pjc->wRmin = jcA.wRmin; pjc->wUmin = jcA.wUmin; pjc->wUmax = jcA.wUmax; pjc->wVmin = jcA.wVmin; pjc->wVmax = jcA.wVmax; pjc->wCaps = jcA.wCaps; pjc->wMaxAxes = jcA.wMaxAxes; pjc->wNumAxes = jcA.wNumAxes; pjc->wMaxButtons = jcA.wMaxButtons; MultiByteToWideChar(g_acp, 0, jcA.szPname, MAXPNAMELEN, pjc->szPname, MAXPNAMELEN); MultiByteToWideChar(g_acp, 0, jcA.szRegKey, MAXPNAMELEN, pjc->szRegKey, MAXPNAMELEN); MultiByteToWideChar(g_acp, 0, jcA.szOEMVxD, MAX_JOYSTICKOEMVXDNAME, pjc->szOEMVxD, MAX_JOYSTICKOEMVXDNAME); } return(RetVal); } } End= [EFunc] TemplateName=LCMapStringW Begin= int __stdcall GodotLCMapStringW( LCID Locale, DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest ) { // Begin locals int RetVal; LPSTR lpSrcStrAnsi; UINT cpg; UINT mcs; // a small head check for flags that are not supported if (dwMapFlags & (LCMAP_SIMPLIFIED_CHINESE | LCMAP_TRADITIONAL_CHINESE | LCMAP_BYTEREV)) { SetLastError(ERROR_INVALID_PARAMETER); return(0); } // Begin precall: LOCALE_USE_CP_ACP is *not* adding a feature! if (dwMapFlags & LOCALE_USE_CP_ACP) cpg = g_acp; else cpg = CpgFromLocale(Locale); mcs = CbPerChOfCpg(cpg); if (FSTRING_VALID(lpSrcStr)) { if(cchSrc==-1) { _STACKALLOC(gwcslen(lpSrcStr) * mcs, lpSrcStrAnsi); } else { _STACKALLOC(cchSrc * mcs, lpSrcStrAnsi); } if(lpSrcStr && lpSrcStrAnsi) WideCharToMultiByte(cpg, 0, lpSrcStr, cchSrc, lpSrcStrAnsi, cchSrc*mcs, NULL, NULL); } else lpSrcStrAnsi = (LPSTR)lpSrcStr; if (!(dwMapFlags & LCMAP_SORTKEY)) { if((cchDest > 0) && (lpDestStr != NULL)) { // Ok, we have a buffer, so lets alloc and convert int lpDestStrLength = cchDest*mcs; LPSTR lpDestStrAnsi; _STACKALLOC(lpDestStrLength, lpDestStrAnsi); if((!lpDestStrAnsi) || (lpSrcStr && !lpSrcStrAnsi)) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } RetVal=LCMapStringA(Locale, dwMapFlags, lpSrcStrAnsi, cchSrc, lpDestStrAnsi, lpDestStrLength); if((RetVal !=0) && (lpDestStr != NULL)) MultiByteToWideChar(cpg, 0, lpDestStrAnsi, cchDest*mcs, lpDestStr, cchDest); } else // no buffer, so just get the size. Comes back in TCHARs so this should be okay RetVal=LCMapStringA(Locale, dwMapFlags, lpSrcStrAnsi, cchSrc, NULL, 0); } else { // Sort keys, we can go into the Unicode return buffer directly RetVal=LCMapStringA(Locale, dwMapFlags, lpSrcStrAnsi, cchSrc, (LPSTR)lpDestStr, cchDest); } return RetVal; } End= [EFunc] TemplateName=LoadAcceleratorsW Begin= HACCEL __stdcall GodotLoadAcceleratorsW(HINSTANCE hInstance, LPCWSTR lpTableName) { LPSTR lpTableNameAnsi; GODOT_TO_ACP_STACKALLOC(lpTableName, lpTableNameAnsi); if(!lpTableNameAnsi && lpTableName) return(FALSE); return(LoadAcceleratorsA(hInstance, lpTableNameAnsi)); } End= [EFunc] TemplateName=LoadMenuIndirectW Begin= HMENU __stdcall GodotLoadMenuIndirectW(const MENUTEMPLATEW * lpMenuTemplate) { return(LoadMenuIndirectA(lpMenuTemplate)); } End= [EFunc] TemplateName=LoadStringW Begin= int __stdcall GodotLoadStringW(HINSTANCE hInstance, UINT uID, LPWSTR lpBuffer, int nBufferMax) { // Code cribbed from module.c (same in NT and Win9x) HANDLE hResInfo; LPWSTR lpsz; int cch; cch = 0; // Make sure the parms are valid. if (!lpBuffer || (nBufferMax-- == 0)) return 0; // String Tables are broken up into 16 string resources. Find the resource // containing the string we are interested in. if(hResInfo = FindResourceA(hInstance, (LPSTR)((LONG)(((USHORT)uID >> 4) + 1)), RT_STRING)) { // Load the resource. Note LoadResource returns an address. if(lpsz = LoadResource(hInstance, hResInfo)) { _try { // Move past the other strings in this resource. // (16 strings in a segment -> & 0x0F) uID &= 0x0F; while(TRUE) { cch = *(lpsz++); // PASCAL like string count // first WCHAR is count of WCHARs if (uID-- == 0) break; lpsz += cch; // Step to start of next string } // Don't copy more than the max allowed. if (cch > nBufferMax) cch = nBufferMax; gwcsncpy(lpBuffer, lpsz, cch); } _except(EXCEPTION_EXECUTE_HANDLER) { SetLastError( ERROR_BAD_FORMAT); cch = 0; } } } // Append a NULL. lpBuffer[cch] = 0; return cch; } End= [EFunc] TemplateName=lstrcatW Begin= LPWSTR __stdcall GodotlstrcatW(LPWSTR lpString1, LPCWSTR lpString2) { if (FWIN95()) return gwcscat(lpString1, lpString2); else return(lstrcatW(lpString1, lpString2)); } End= [EFunc] TemplateName=lstrcmpW Begin= int __stdcall GodotlstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2) { return(CompareHelper(lpString1, lpString2, FALSE)); } End= [EFunc] TemplateName=lstrcmpiW Begin= int __stdcall GodotlstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2) { return(CompareHelper(lpString1, lpString2, TRUE)); } End= [EFunc] TemplateName=lstrcpyW Begin= LPWSTR __stdcall GodotlstrcpyW(LPWSTR lpString1, LPCWSTR lpString2) { if (FWIN95()) return gwcscpy(lpString1, lpString2); else return(lstrcpyW(lpString1, lpString2)); } End= [EFunc] TemplateName=lstrcpynW Begin= LPWSTR __stdcall GodotlstrcpynW(LPWSTR lpString1, LPCWSTR lpString2, int iMaxLength) { LPWSTR pszReturn = gwcsncpy(lpString1, lpString2, iMaxLength); // gwcsncpy and lstrcpy behave differently about terminating NULL // characters. The last char in the lstrcpyn buffer always gets // a TEXT('\0'), whereas gwcsncpy doesn't do this. Thus we must // NULL the last char before returning (gleaned from VSANSI) lpString1[iMaxLength-1] = TEXT('\0'); return pszReturn; } End= [EFunc] TemplateName=lstrlenW Begin= int __stdcall GodotlstrlenW(LPCWSTR lpString) { // CONSIDER: Maybe we do not need this function? Isn't it supported // in the Unicode version on all platforms? return gwcslen(lpString); } End= [EFunc] TemplateName=MapVirtualKeyW Begin= UINT __stdcall GodotMapVirtualKeyW(UINT uCode, UINT uMapType) { UINT RetVal; RetVal=MapVirtualKeyA(uCode, uMapType); if((uMapType == 2) && (RetVal != 0)) { // RetVal is an unshifted character in the loword, as // well as a possible diacritic in the hiword UINT cpg = CpgFromLocale(LOWORD(GetKeyboardLayout(0))); UINT mcs = CbPerChOfCpg(cpg); UINT RetValT; RetValT = RetVal; if(!FDBCS_CPG(cpg)) { MultiByteToWideChar(cpg, 0, (LPSTR)RetVal, 1, (LPWSTR)(LOWORD(RetValT)), 1); if(HIWORD(RetVal)) RetValT |= (UINT)0x80000000; } else { MultiByteToWideChar(cpg, 0, (LPSTR)RetVal, 1, (LPWSTR)RetValT, 1); } RetVal = RetValT; } return(RetVal); } End= [EFunc] TemplateName=MapVirtualKeyExW Begin= UINT __stdcall GodotMapVirtualKeyExW(UINT uCode, UINT uMapType, HKL dwhkl) { UINT RetVal; RetVal=MapVirtualKeyExA(uCode, uMapType, dwhkl); if((uMapType == 2) && (RetVal != 0)) { // RetVal is an unshifted character in the loword, as // well as a possible diacritic in the hiword UINT cpg = CpgFromLocale(LOWORD(dwhkl)); UINT mcs = CbPerChOfCpg(cpg); UINT RetValT; RetValT = RetVal; if(!FDBCS_CPG(cpg)) { MultiByteToWideChar(cpg, 0, (LPSTR)RetVal, 1, (LPWSTR)(LOWORD(RetValT)), 1); if(HIWORD(RetVal)) RetValT |= (UINT)0x80000000; } else { MultiByteToWideChar(cpg, 0, (LPSTR)RetVal, 1, (LPWSTR)RetValT, 1); } RetVal = RetValT; } return(RetVal); } End= [EFunc] TemplateName=mciGetDeviceIDW Begin= MCIDEVICEID __stdcall GodotmciGetDeviceIDW(LPCWSTR pszDevice) { LPSTR pszDeviceAnsi; GODOT_TO_ACP_STACKALLOC(pszDevice, pszDeviceAnsi); if(!pszDeviceAnsi && pszDevice) return(0); return(mciGetDeviceIDA(pszDeviceAnsi)); } End= [EFunc] TemplateName=mciGetErrorStringW Begin= BOOL __stdcall GodotmciGetErrorStringW(MCIERROR mcierr, LPWSTR pszText, UINT cchText) { BOOL RetVal; if(pszText==NULL || cchText == 0) return(midiInGetErrorTextA(mcierr, (LPSTR)pszText, cchText)); else { if(MAXERRORLENGTH < cchText) { return(MMSYSERR_INVALPARAM); } else { char pszTextAnsi[MAXERRORLENGTH]; ZeroMemory(pszTextAnsi, MAXERRORLENGTH); RetVal = mciGetErrorStringA(mcierr, pszTextAnsi, cchText); if(RetVal) MultiByteToWideChar(g_acp, 0, pszTextAnsi, -1, pszText, cchText); return(RetVal); } } } End= [EFunc] TemplateName=mciSendCommandW Begin= MCIERROR __stdcall GodotmciSendCommandW(MCIDEVICEID mciId, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(MCIERR_UNSUPPORTED_FUNCTION); } End= [EFunc] TemplateName=mciSendStringW Begin= MCIERROR __stdcall GodotmciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrReturnString, UINT uReturnLength, HWND hwndCallback) { // UNSUPPORTED FUNCTION: Documented as a failure stub LPSTR lpstrCommandAnsi; MCIERROR RetVal; GODOT_TO_ACP_STACKALLOC(lpstrCommand, lpstrCommandAnsi); if(!lpstrCommandAnsi && lpstrCommand) return(MCIERR_OUT_OF_MEMORY); if(lpstrReturnString && (uReturnLength > 0)) { LPSTR lpstrReturnStringAnsi; _STACKALLOC(uReturnLength * g_mcs, lpstrReturnStringAnsi); if(lpstrReturnStringAnsi==NULL) return(MCIERR_OUT_OF_MEMORY); ZeroMemory(lpstrReturnStringAnsi, uReturnLength * g_mcs); RetVal = mciSendStringA(lpstrCommandAnsi, lpstrReturnStringAnsi, uReturnLength, hwndCallback); if(RetVal == MMSYSERR_NOERROR) MultiByteToWideChar(g_acp, 0, lpstrReturnStringAnsi, -1, lpstrReturnString, uReturnLength); else *lpstrReturnString = L'\0'; return(RetVal); } else return(mciSendStringA(lpstrCommandAnsi, NULL, 0, hwndCallback)); } End= [EFunc] TemplateName=MCIWndCreateW Begin= HWND _cdecl GodotMCIWndCreateW(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCWSTR szFile) { HWND RetVal; LPSTR szFileAnsi; LPGODOTTLSINFO lpgti = GetThreadInfoSafe(TRUE); if(!lpgti) return(0); GODOT_TO_ACP_STACKALLOC(szFile, szFileAnsi); if(!szFileAnsi && szFile) return(0); INIT_WINDOW_SNIFF(lpgti->hHook); RetVal=MCIWndCreateWA(hwndParent, hInstance, dwStyle, szFileAnsi); TERM_WINDOW_SNIFF(lpgti->hHook); return RetVal; } End= [EFunc] TemplateName=MessageBoxW Begin= int __stdcall GodotMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType) { // Code taken from the BASE depot size_t cbAnsiText, cbAnsiCaption; int RetVal; LPSTR pAnsiText = NULL; LPSTR pAnsiCaption = NULL; if(cbAnsiText = WideCharToMultiByte(g_acp, 0, lpText, -1, 0, 0, NULL, NULL)) { if(pAnsiText = GlobalAlloc(GMEM_FIXED, cbAnsiText)) WideCharToMultiByte(g_acp, 0, lpText, -1, pAnsiText, cbAnsiText, NULL, NULL); else { SetLastError(ERROR_OUTOFMEMORY); return(0); } } if(cbAnsiCaption = WideCharToMultiByte(g_acp, 0, lpCaption, -1, 0, 0, NULL, NULL)) { if(pAnsiCaption = GlobalAlloc( GMEM_FIXED, cbAnsiCaption)) WideCharToMultiByte(g_acp, 0, lpCaption, -1, pAnsiCaption, cbAnsiCaption, NULL, NULL); else { if(pAnsiText) GlobalFree(pAnsiText); SetLastError(ERROR_OUTOFMEMORY); return(0); } } RetVal=MessageBoxA(hWnd, pAnsiText, pAnsiCaption, uType); if(pAnsiText) GlobalFree(pAnsiText); if(pAnsiCaption) GlobalFree(pAnsiCaption); return(RetVal); } End= [EFunc] TemplateName=MessageBoxExW Begin= int __stdcall GodotMessageBoxExW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType, WORD wLanguageId) { // Code taken from the BASE depot size_t cbAnsiText, cbAnsiCaption; int RetVal; LPSTR pAnsiText = NULL; LPSTR pAnsiCaption = NULL; if(cbAnsiText = WideCharToMultiByte(g_acp, 0, lpText, -1, 0, 0, NULL, NULL)) { if(pAnsiText = GlobalAlloc(GMEM_FIXED, cbAnsiText)) WideCharToMultiByte(g_acp, 0, lpText, -1, pAnsiText, cbAnsiText, NULL, NULL); else { SetLastError(ERROR_OUTOFMEMORY); return(0); } } if(cbAnsiCaption = WideCharToMultiByte(g_acp, 0, lpCaption, -1, 0, 0, NULL, NULL)) { if(pAnsiCaption = GlobalAlloc(GMEM_FIXED, cbAnsiCaption)) WideCharToMultiByte(g_acp, 0, lpCaption, -1, pAnsiCaption, cbAnsiCaption, NULL, NULL); else { if(pAnsiText) GlobalFree(pAnsiText); SetLastError(ERROR_OUTOFMEMORY); return(0); } } RetVal=MessageBoxExA(hWnd, pAnsiText, pAnsiCaption, uType, wLanguageId); if(pAnsiText) GlobalFree(pAnsiText); if(pAnsiCaption) GlobalFree(pAnsiCaption); return(RetVal); } End= [EFunc] TemplateName=MessageBoxIndirectW Begin= int __stdcall GodotMessageBoxIndirectW(const MSGBOXPARAMSW * lpMsgBoxParams) { // Begin locals int RetVal; MSGBOXPARAMSA mpa; // Begin precall ZeroMemory(&mpa, sizeof(MSGBOXPARAMSA)); mpa.cbSize = lpMsgBoxParams->cbSize; mpa.hwndOwner = lpMsgBoxParams->hwndOwner; mpa.hInstance = lpMsgBoxParams->hInstance; mpa.dwStyle = lpMsgBoxParams->dwStyle; mpa.dwContextHelpId = lpMsgBoxParams->dwContextHelpId; mpa.dwLanguageId = lpMsgBoxParams->dwLanguageId; mpa.lpfnMsgBoxCallback = lpMsgBoxParams->lpfnMsgBoxCallback; GODOT_TO_ACP_STACKALLOC(lpMsgBoxParams->lpszText, mpa.lpszText); GODOT_TO_ACP_STACKALLOC(lpMsgBoxParams->lpszCaption, mpa.lpszCaption); GODOT_TO_ACP_STACKALLOC(lpMsgBoxParams->lpszIcon, mpa.lpszIcon); if((!mpa.lpszText && lpMsgBoxParams->lpszText) || (!mpa.lpszCaption && lpMsgBoxParams->lpszCaption) || (!mpa.lpszIcon && lpMsgBoxParams->lpszIcon)) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } // Call the 'A' version of the API RetVal=MessageBoxIndirectA(&mpa); // Finished return RetVal; } End= [EFunc] TemplateName=midiInGetDevCapsW Begin= MMRESULT __stdcall GodotmidiInGetDevCapsW(UINT_PTR uDeviceID, LPMIDIINCAPSW pmic, UINT cbmic) { // UNSUPPORTED FUNCTION: Documented as a failure stub if(cbmic < sizeof(MIDIINCAPSW)) { return(MMSYSERR_INVALPARAM); } else { MIDIINCAPSA micA; MMRESULT RetVal; ZeroMemory(&micA, sizeof(MIDIINCAPSA)); RetVal = midiInGetDevCapsA(uDeviceID, &micA, sizeof(MIDIINCAPSA)); if(RetVal == MMSYSERR_NOERROR) { pmic->wMid = micA.wMid; pmic->wPid = micA.wPid; pmic->vDriverVersion = micA.vDriverVersion; pmic->dwSupport = micA.dwSupport; MultiByteToWideChar(g_acp, 0, micA.szPname, MAXPNAMELEN, pmic->szPname, MAXPNAMELEN); } return(RetVal); } } End= [EFunc] TemplateName=midiInGetErrorTextW Begin= MMRESULT __stdcall GodotmidiInGetErrorTextW(MMRESULT mmrError, LPWSTR pszText, UINT cchText) { // UNSUPPORTED FUNCTION: Documented as a failure stub if(pszText==NULL || cchText == 0) return(midiInGetErrorTextA(mmrError, (LPSTR)pszText, cchText)); else { if(MAXERRORLENGTH < cchText) { return(MMSYSERR_INVALPARAM); } else { char pszTextA[MAXERRORLENGTH]; MMRESULT RetVal; ZeroMemory(pszTextA, MAXERRORLENGTH); RetVal = midiInGetErrorTextA(mmrError, pszTextA, cchText); if(RetVal == MMSYSERR_NOERROR) MultiByteToWideChar(g_acp, 0, pszTextA, -1, pszText, cchText); return(RetVal); } } } End= [EFunc] TemplateName=midiOutGetDevCapsW Begin= MMRESULT __stdcall GodotmidiOutGetDevCapsW(UINT_PTR uDeviceID, LPMIDIOUTCAPSW pmoc, UINT cbmoc) { // UNSUPPORTED FUNCTION: Documented as a failure stub if(cbmoc < sizeof(MIDIOUTCAPSW)) { return(MMSYSERR_INVALPARAM); } else { MIDIOUTCAPSA mocA; MMRESULT RetVal; ZeroMemory(&mocA, sizeof(MIDIOUTCAPSA)); RetVal = midiOutGetDevCapsA(uDeviceID, &mocA, sizeof(MIDIOUTCAPSA)); if(RetVal == MMSYSERR_NOERROR) { pmoc->wMid = mocA.wMid; pmoc->wPid = mocA.wPid; pmoc->vDriverVersion = mocA.vDriverVersion; pmoc->wTechnology = mocA.wTechnology; pmoc->wVoices = mocA.wVoices; pmoc->wNotes = mocA.wNotes; pmoc->wChannelMask = mocA.wChannelMask; pmoc->dwSupport = mocA.dwSupport; MultiByteToWideChar(g_acp, 0, mocA.szPname, MAXPNAMELEN, pmoc->szPname, MAXPNAMELEN); } return(RetVal); } } End= [EFunc] TemplateName=midiOutGetErrorTextW Begin= MMRESULT __stdcall GodotmidiOutGetErrorTextW(MMRESULT mmrError, LPWSTR pszText, UINT cchText) { // UNSUPPORTED FUNCTION: Documented as a failure stub if(pszText==NULL || cchText == 0) return(midiOutGetErrorTextA(mmrError, (LPSTR)pszText, cchText)); else { if(MAXERRORLENGTH < cchText) { return(MMSYSERR_INVALPARAM); } else { char pszTextA[MAXERRORLENGTH]; MMRESULT RetVal; ZeroMemory(pszTextA, MAXERRORLENGTH); RetVal = midiOutGetErrorTextA(mmrError, pszTextA, cchText); if(RetVal == MMSYSERR_NOERROR) MultiByteToWideChar(g_acp, 0, pszTextA, -1, pszText, cchText); return(RetVal); } } } End= [EFunc] TemplateName=mixerGetControlDetailsW Begin= MMRESULT __stdcall GodotmixerGetControlDetailsW(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(MMSYSERR_NOTSUPPORTED); } End= [EFunc] TemplateName=mixerGetDevCapsW Begin= MMRESULT __stdcall GodotmixerGetDevCapsW(UINT_PTR uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps) { // UNSUPPORTED FUNCTION: Documented as a failure stub if(uMxId < sizeof(MIXERCAPSW)) { return(MMSYSERR_INVALPARAM); } else { MIXERCAPSA mxcapsA; MMRESULT RetVal; ZeroMemory(&mxcapsA, sizeof(MIXERCAPSA)); RetVal = mixerGetDevCapsA(uMxId, &mxcapsA, sizeof(MIXERCAPSA)); if(RetVal == MMSYSERR_NOERROR) { pmxcaps->wMid = mxcapsA.wMid; pmxcaps->wPid = mxcapsA.wPid; pmxcaps->vDriverVersion = mxcapsA.vDriverVersion; pmxcaps->fdwSupport = mxcapsA.fdwSupport; pmxcaps->cDestinations = mxcapsA.cDestinations; MultiByteToWideChar(g_acp, 0, mxcapsA.szPname, MAXPNAMELEN, pmxcaps->szPname, MAXPNAMELEN); } return(RetVal); } } End= [EFunc] TemplateName=mixerGetLineControlsW Begin= MMRESULT __stdcall GodotmixerGetLineControlsW(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSW pmxlc, DWORD fdwControls) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(MMSYSERR_NOTSUPPORTED); } End= [EFunc] TemplateName=mixerGetLineInfoW Begin= MMRESULT __stdcall GodotmixerGetLineInfoW(HMIXEROBJ hmxobj, LPMIXERLINEW pmxl, DWORD fdwInfo) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(MMSYSERR_NOTSUPPORTED); } End= [EFunc] TemplateName=mmioInstallIOProcW Begin= LPMMIOPROC __stdcall GodotmmioInstallIOProcW(FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(NULL); } End= [EFunc] TemplateName=mmioRenameW Begin= MMRESULT __stdcall GodotmmioRenameW(LPCWSTR pszFileName, LPCWSTR pszNewFileName, LPCMMIOINFO pmmioinfo, DWORD fdwRename) { // UNSUPPORTED FUNCTION: Documented as a failure stub if((MAX_PATH < gwcslen(pszFileName)) || (MAX_PATH < gwcslen(pszNewFileName))) { SetLastError(ERROR_INVALID_PARAMETER); return(0); } else { char pszFileNameAnsi[MAX_PATH + 1]; char pszNewFileNameAnsi[MAX_PATH + 1]; WideCharToMultiByte(g_acp, 0, pszFileName, -1, pszFileNameAnsi, MAX_PATH, NULL, NULL); WideCharToMultiByte(g_acp, 0, pszNewFileName, -1, pszNewFileNameAnsi, MAX_PATH, NULL, NULL); return(mmioRenameA(pszFileNameAnsi, pszNewFileNameAnsi, pmmioinfo, fdwRename)); } } End= [EFunc] TemplateName=mmioOpenW Begin= HMMIO __stdcall GodotmmioOpenW(LPWSTR pszFileName, LPMMIOINFO pmmioinfo, DWORD fdwOpen) { // UNSUPPORTED FUNCTION: Documented as a failure stub if(MAX_PATH < gwcslen(pszFileName)) { SetLastError(ERROR_INVALID_PARAMETER); if(pmmioinfo) pmmioinfo->wErrorRet = MMIOERR_PATHNOTFOUND; return(0); } else { char pszFileNameAnsi[MAX_PATH + 1]; WideCharToMultiByte(g_acp, 0, pszFileName, -1, pszFileNameAnsi, MAX_PATH, NULL, NULL); return(mmioOpenA(pszFileNameAnsi, pmmioinfo, fdwOpen)); } } End= [EFunc] TemplateName=mmioStringToFOURCCW Begin= FOURCC __stdcall GodotmmioStringToFOURCCW(LPCWSTR sz, UINT uFlags) { // UNSUPPORTED FUNCTION: Documented as a failure stub LPSTR szAnsi; GODOT_TO_ACP_STACKALLOC(sz, szAnsi); return(mmioStringToFOURCCA(szAnsi, uFlags)); } End= [EFunc] TemplateName=MoveFileW Begin= BOOL __stdcall GodotMoveFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName) { if((MAX_PATH < gwcslen(lpExistingFileName)) || (MAX_PATH < gwcslen(lpExistingFileName))) { SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } else { UINT cpg = FILES_CPG; char lpEfnA[MAX_PATH + 1]; char lpNfnA[MAX_PATH + 1]; WideCharToMultiByte(cpg, 0, lpExistingFileName, -1, lpEfnA, MAX_PATH, NULL, NULL); WideCharToMultiByte(cpg, 0, lpNewFileName, -1, lpNfnA, MAX_PATH, NULL, NULL); return(MoveFileA(lpEfnA, lpNfnA)); } } End= [EFunc] TemplateName=MultiByteToWideChar Begin= // MultiByteToWideChar is wrapped for UTF-7/UTF-8 support int __stdcall GodotMultiByteToWideChar( UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar ) { UINT cpg = ((CodePage == CP_THREAD_ACP) ? g_acp : CodePage); // See if it's a special code page value for UTF translations. if (cpg >= NLS_CP_ALGORITHM_RANGE) return (UTFToUnicode(cpg, dwFlags, lpMultiByteStr, cbMultiByte, lpWideCharStr, cchWideChar)); // GB 18030 specified? if (cpg == CP_GB18030) return(GB18030Helper(cpg, dwFlags | NLS_CP_MBTOWC, (LPSTR)lpMultiByteStr, cbMultiByte, lpWideCharStr, cchWideChar, NULL)); return(MultiByteToWideChar(cpg, dwFlags, lpMultiByteStr, cbMultiByte, lpWideCharStr, cchWideChar)); } End= [EFunc] TemplateName=MultinetGetConnectionPerformanceW Begin= DWORD __stdcall GodotMultinetGetConnectionPerformanceW( LPNETRESOURCEW lpnrw, LPNETCONNECTINFOSTRUCT lpNetConnectInfoStruct ) { NETRESOURCEA nra; ZeroMemory(&nra, sizeof(NETRESOURCEA)); memcpy(&nra, lpnrw, (4*sizeof(DWORD))); GODOT_TO_ACP_STACKALLOC(lpnrw->lpLocalName, nra.lpLocalName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpRemoteName, nra.lpRemoteName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpComment, nra.lpComment); GODOT_TO_ACP_STACKALLOC(lpnrw->lpProvider, nra.lpProvider); return(MultinetGetConnectionPerformanceA(&nra, lpNetConnectInfoStruct)); } End= [EFunc] TemplateName=OemToCharW Begin= BOOL __stdcall GodotOemToCharW(LPCSTR lpszSrc, LPWSTR lpszDst) { size_t cchSrc; // MSDN claims this function never returns FALSE. It lies (in the // case where the buffers are identical, for example). if ((void *)lpszSrc == (void *)lpszDst) { SetLastError(ERROR_INVALID_ADDRESS); return(FALSE); } // Why thunk? This function is just a CP_OEM->WCHAR converter, anyway! // Get the number of bytes in the OEM string, Unicode string should // never be more than that cchSrc = lstrlenA(lpszSrc); MultiByteToWideChar(g_oemcp, MB_PRECOMPOSED | MB_USEGLYPHCHARS, lpszSrc, cchSrc, lpszDst, cchSrc); return(TRUE); } End= [EFunc] TemplateName=OemToCharBuffW Begin= BOOL __stdcall GodotOemToCharBuffW(LPCSTR lpszSrc, LPWSTR lpszDst, DWORD cchDstLength) { LPSTR pTemp; // MSDN claims this function never returns FALSE. It lies (in the // case where the buffers are identical, for example). if ((void *)lpszSrc == (void *)lpszDst) { SetLastError(ERROR_INVALID_ADDRESS); return(FALSE); } // Validate the input and output pointers (taken from the actual API) if(IsBadReadPtr(pTemp = (LPSTR)lpszSrc, cchDstLength) || IsBadWritePtr(pTemp = (LPSTR)lpszDst, cchDstLength)) { SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); } // Why thunk? This function is just a CP_OEM->WCHAR converter, anyway! MultiByteToWideChar(g_oemcp, 0, lpszSrc, cchDstLength, lpszDst, cchDstLength); return(TRUE); } End= [EFunc] TemplateName=OleUIAddVerbMenuW Begin= BOOL __stdcall GodotOleUIAddVerbMenuW( LPOLEOBJECT lpOleObj, LPCWSTR lpszShortType, HMENU hMenu, UINT uPos, UINT uIDVerbMin, UINT uIDVerbMax, BOOL bAddConvert, UINT idConvert, HMENU * lphMenu ) { // UNSUPPORTED FUNCTION: Documented as a failure stub LPCSTR lpszShortTypeAnsi; GODOT_TO_ACP_STACKALLOC(lpszShortType, (LPSTR)lpszShortTypeAnsi); if(!lpszShortTypeAnsi && lpszShortType) { return(FALSE); } return(OleUIAddVerbMenuA(lpOleObj, lpszShortTypeAnsi, hMenu, uPos, uIDVerbMin, uIDVerbMax, bAddConvert, idConvert, lphMenu)); } End= [EFunc] TemplateName=OleUIBusyW Begin= UINT __stdcall GodotOleUIBusyW(LPOLEUIBUSYW lpoubw) { // UNSUPPORTED FUNCTION: Documented as a failure stub OLEUIBUSYA ouba; memcpy(&ouba, lpoubw, sizeof(OLEUIBUSYA)); GODOT_TO_ACP_STACKALLOC(lpoubw->lpszCaption, ouba.lpszCaption); GODOT_TO_ACP_STACKALLOC(lpoubw->lpszTemplate, ouba.lpszTemplate); if((!ouba.lpszCaption && lpoubw->lpszCaption) || (!ouba.lpszTemplate && lpoubw->lpszTemplate)) { SetLastError(ERROR_STACK_OVERFLOW); return(FALSE); } return(OleUIBusyA(&ouba)); } End= [EFunc] TemplateName=OleUIChangeIconW Begin= UINT __stdcall GodotOleUIChangeIconW(LPOLEUICHANGEICONW lpouciw) { // UNSUPPORTED FUNCTION: Documented as a failure stub OLEUICHANGEICONA oucia; UINT RetVal = 0; ALLOCRETURN arCaption; ALLOCRETURN arTemplate; memcpy(&oucia, lpouciw, sizeof(OLEUIBUSYA)); arCaption = GodotToAcpOnHeap(lpouciw->lpszCaption, &(LPSTR)oucia.lpszCaption); arTemplate = GodotToAcpOnHeap(lpouciw->lpszTemplate, &(LPSTR)oucia.lpszTemplate); if(arCaption != arFailed && arTemplate != arFailed) { if(oucia.dwFlags & CIF_USEICONEXE) WideCharToMultiByte(g_acp, 0, lpouciw->szIconExe, MAX_PATH, oucia.szIconExe, MAX_PATH, NULL, NULL); RetVal = OleUIChangeIconA(&oucia); } else SetLastError(ERROR_OUTOFMEMORY); if(arCaption==arAlloc) GodotHeapFree((LPSTR)oucia.lpszCaption); if(arTemplate==arAlloc) GodotHeapFree((LPSTR)oucia.lpszTemplate); return(RetVal); } End= [EFunc] TemplateName=OleUIChangeSourceW Begin= UINT __stdcall GodotOleUIChangeSourceW(LPOLEUICHANGESOURCEW _noname0) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(OleUIChangeSourceW(_noname0)); } End= [EFunc] TemplateName=OleUIConvertW Begin= UINT __stdcall GodotOleUIConvertW(LPOLEUICONVERTW _noname0) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(OleUIConvertW(_noname0)); } End= [EFunc] TemplateName=OleUIEditLinksW Begin= UINT __stdcall GodotOleUIEditLinksW(LPOLEUIEDITLINKSW _noname0) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(OleUIEditLinksW(_noname0)); } End= [EFunc] TemplateName=OleUIInsertObjectW Begin= UINT __stdcall GodotOleUIInsertObjectW(LPOLEUIINSERTOBJECTW _noname0) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(OleUIInsertObjectW(_noname0)); } End= [EFunc] TemplateName=OleUIObjectPropertiesW Begin= UINT __stdcall GodotOleUIObjectPropertiesW(LPOLEUIOBJECTPROPSW _noname0) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(OleUIObjectPropertiesW(_noname0)); } End= [EFunc] TemplateName=OleUIPasteSpecialW Begin= UINT __stdcall GodotOleUIPasteSpecialW(LPOLEUIPASTESPECIALW _noname0) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(OleUIPasteSpecialW(_noname0)); } End= [EFunc] TemplateName=OleUIPromptUserW Begin= int _cdecl GodotOleUIPromptUserW(int nTemplate, HWND hwndParent, ... ) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(OLEUI_FALSE); } End= [EFunc] TemplateName=OleUIUpdateLinksW Begin= BOOL __stdcall GodotOleUIUpdateLinksW(LPOLEUILINKCONTAINERW lpOleUILinkCntr, HWND hwnd, LPWSTR lpszTitle, int cLinks) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(OleUIUpdateLinksW(lpOleUILinkCntr, hwnd, lpszTitle, cLinks)); } End= [EFunc] TemplateName=OpenPrinterW Begin= BOOL __stdcall GodotOpenPrinterW(LPWSTR pPrinterName, LPHANDLE phPrinter, LPPRINTER_DEFAULTSW pDefault) { // Begin locals BOOL RetVal = FALSE; LPSTR pPrinterNameAnsi = NULL; ALLOCRETURN ar = GodotToAcpOnHeap(pPrinterName, &pPrinterNameAnsi); if(ar==arFailed) { SetLastError(ERROR_OUTOFMEMORY); return(FALSE); } if(pDefault) { PRINTER_DEFAULTSA pda; ZeroMemory(&pda, sizeof(PRINTER_DEFAULTSA)); pda.pDevMode = GodotHeapAlloc(sizeof(DEVMODEA) + pDefault->pDevMode->dmDriverExtra); if(pda.pDevMode!=NULL) { ZeroMemory(pda.pDevMode, sizeof(DEVMODEA) + pDefault->pDevMode->dmDriverExtra); DevModeAfromW(pda.pDevMode, pDefault->pDevMode); GODOT_TO_ACP_STACKALLOC(pDefault->pDatatype, pda.pDatatype); RetVal=OpenPrinterA(pPrinterNameAnsi, phPrinter, &pda); GodotHeapFree(pda.pDevMode); } else SetLastError(ERROR_OUTOFMEMORY); } else { RetVal=OpenPrinterA(pPrinterNameAnsi, phPrinter, NULL); } if(ar==arAlloc) GodotHeapFree(pPrinterNameAnsi); return RetVal; } End= [EFunc] TemplateName=OpenWaitableTimerW Begin= HANDLE __stdcall GodotOpenWaitableTimerW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpTimerName) { if (s_pfnOpenWaitableTimerA == NULL) { // Must allocate stuff for this API call s_pfnOpenWaitableTimerA = (PFNowta)GetKernelProc("OpenWaitableTimerA"); } if (s_pfnOpenWaitableTimerA) { LPSTR lpTimerNameAnsi; GODOT_TO_ACP_STACKALLOC(lpTimerName, lpTimerNameAnsi); if(!lpTimerNameAnsi && lpTimerName) return(NULL); return(s_pfnOpenWaitableTimerA(dwDesiredAccess, bInheritHandle, lpTimerNameAnsi)); } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return(NULL); } End= [EFunc] TemplateName=PageSetupDlgW Begin= BOOL __stdcall GodotPageSetupDlgW(LPPAGESETUPDLGW lppsd) { // Begin locals BOOL RetVal; PAGESETUPDLGA psdA; LPGODOTTLSINFO lpgti; // If we cannot get out TLS info, then we cannot proceed if(!(lpgti = GetThreadInfoSafe(TRUE))) { SetLastError(ERROR_OUTOFMEMORY); return(0); } // Do the hooks now, if the user has them if(((lpgti->pfnPagePaint) && (lppsd->Flags & PSD_ENABLEPAGEPAINTHOOK) && (lppsd->lpfnPagePaintHook)) || ((lpgti->pfnPageSetup) && (lppsd->Flags & PSD_ENABLEPAGESETUPHOOK) && (lppsd->lpfnPageSetupHook))) { SetLastError(ERROR_INVALID_FILTER_PROC); return(0); } ZeroMemory(&psdA, sizeof(PAGESETUPDLGA)); psdA.lStructSize = sizeof(PAGESETUPDLGA); if((lppsd->Flags & PSD_RETURNDEFAULT) == 0) { if ((lppsd->Flags & PSD_ENABLEPAGEPAINTHOOK) && (lppsd->lpfnPagePaintHook)) lpgti->pfnPagePaint = lppsd->lpfnPagePaintHook; psdA.lpfnPagePaintHook = &PagePaintHook; if ((lppsd->Flags & PSD_ENABLEPAGESETUPHOOK) && (lppsd->lpfnPageSetupHook)) lpgti->pfnPageSetup = lppsd->lpfnPageSetupHook; psdA.lpfnPageSetupHook = &PageSetupHook; } psdA.hwndOwner = lppsd->hwndOwner; psdA.hDevMode = HDevModeAfromW(&(lppsd->hDevMode), TRUE); psdA.hDevNames = HDevNamesAfromW(&(lppsd->hDevNames), TRUE); psdA.Flags = lppsd->Flags; psdA.ptPaperSize = lppsd->ptPaperSize; psdA.rtMinMargin = lppsd->rtMinMargin; psdA.rtMargin = lppsd->rtMargin; psdA.hInstance = lppsd->hInstance; psdA.lCustData = lppsd->lCustData; if(lppsd->Flags & PSD_ENABLEPAGESETUPTEMPLATE) { GODOT_TO_ACP_STACKALLOC(lppsd->lpPageSetupTemplateName, psdA.lpPageSetupTemplateName); } if(lppsd->Flags & PSD_ENABLEPAGESETUPTEMPLATEHANDLE) psdA.hPageSetupTemplate = lppsd->hPageSetupTemplate; INIT_WINDOW_SNIFF(lpgti->hHook); RetVal=PageSetupDlgA(&psdA); TERM_WINDOW_SNIFF(lpgti->hHook); if((lppsd->Flags & PSD_RETURNDEFAULT) == 0) { if ((lppsd->Flags & PSD_ENABLEPAGEPAINTHOOK) && (lppsd->lpfnPagePaintHook)) lpgti->pfnPagePaint = NULL; if ((lppsd->Flags & PSD_ENABLEPAGESETUPHOOK) && (lppsd->lpfnPageSetupHook)) lpgti->pfnPageSetup = NULL; } // Begin postcall if(RetVal) { if(lppsd->hDevMode) GlobalFree(lppsd->hDevMode); if(lppsd->hDevNames) GlobalFree(lppsd->hDevNames); lppsd->hDevMode = HDevModeWfromA(&(psdA.hDevMode), TRUE); lppsd->hDevNames = HDevNamesWfromA(&(psdA.hDevNames), TRUE); lppsd->Flags = psdA.Flags; lppsd->ptPaperSize = psdA.ptPaperSize; lppsd->rtMinMargin = psdA.rtMinMargin; lppsd->rtMargin = psdA.rtMargin; lppsd->lCustData = psdA.lCustData; } // Finished return RetVal; } End= [EFunc] TemplateName=PeekMessageW Begin= BOOL __stdcall GodotPeekMessageW(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg) { return(GodotReceiveMessage(mtPeekMessage, lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg)); } End= [EFunc] TemplateName=PlaySoundW Begin= BOOL __stdcall GodotPlaySoundW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound) { BOOL RetVal; LPSTR pszSoundAnsi; GODOT_TO_ACP_STACKALLOC(pszSound, pszSoundAnsi); RetVal=PlaySoundA(pszSoundAnsi, hmod, fdwSound); return RetVal; } End= [EFunc] TemplateName=PolyTextOutW Begin= BOOL __stdcall GodotPolyTextOutW(HDC hdc, const POLYTEXTW * pptxt, int cStrings) { POLYTEXTA * pptxta; int i; size_t cchMax = 0; size_t cchT; UINT cpg = CpgFromHdc(hdc); UINT mcs = CbPerChOfCpg(cpg); LPSTR lpszBuf; BOOL RetVal; _STACKALLOC(sizeof(POLYTEXTA)*cStrings, pptxta); if(pptxta==NULL) { return(FALSE); } for (i = 0; ipfnPrintDlg) && (lppd->Flags & PD_ENABLEPRINTHOOK) && (lppd->lpfnPrintHook)) || ((lpgti->pfnPrintDlgSetup) && (lppd->Flags & PD_ENABLESETUPHOOK) && (lppd->lpfnSetupHook))) { SetLastError(ERROR_INVALID_FILTER_PROC); return(0); } ZeroMemory(&pdA, sizeof(PRINTDLGA)); pdA.lStructSize = sizeof(PRINTDLGA); pdA.Flags = lppd->Flags; if((lppd->Flags & PD_RETURNDEFAULT) == 0) { if ((lppd->Flags & PD_ENABLEPRINTHOOK) && (lppd->lpfnPrintHook)) lpgti->pfnPrintDlg = lppd->lpfnPrintHook; pdA.lpfnPrintHook = &PrintHookProc; pdA.Flags |= PD_ENABLEPRINTHOOK; if ((lppd->Flags & PD_ENABLESETUPHOOK) && (lppd->lpfnSetupHook)) lpgti->pfnPrintDlgSetup = lppd->lpfnSetupHook; pdA.lpfnSetupHook = &SetupHookProc; pdA.Flags |= PD_ENABLESETUPHOOK; } pdA.hwndOwner = lppd->hwndOwner; pdA.hDevMode = HDevModeAfromW(&(lppd->hDevMode), FALSE); pdA.hDevNames = HDevNamesAfromW(&(lppd->hDevNames), FALSE); pdA.hDC = lppd->hDC; pdA.nFromPage = lppd->nFromPage; pdA.nToPage = lppd->nToPage; pdA.nMinPage = lppd->nMinPage; pdA.nMaxPage = lppd->nMaxPage; pdA.nCopies = lppd->nCopies; pdA.hInstance = lppd->hInstance; pdA.lCustData = lppd->lCustData; if(lppd->Flags & PD_ENABLEPRINTTEMPLATE) { GODOT_TO_ACP_STACKALLOC(lppd->lpPrintTemplateName, pdA.lpPrintTemplateName); } if(lppd->Flags & PD_ENABLESETUPTEMPLATE) { GODOT_TO_ACP_STACKALLOC(lppd->lpSetupTemplateName, pdA.lpSetupTemplateName); } if(lppd->Flags & PD_ENABLEPRINTTEMPLATEHANDLE) pdA.hPrintTemplate = lppd->hPrintTemplate; if(lppd->Flags & PD_ENABLESETUPTEMPLATEHANDLE) pdA.hSetupTemplate = lppd->hSetupTemplate; INIT_WINDOW_SNIFF(lpgti->hHook); RetVal=PrintDlgA(&pdA); TERM_WINDOW_SNIFF(lpgti->hHook); if((lppd->Flags & PD_RETURNDEFAULT) == 0) { if ((lppd->Flags & PD_ENABLEPRINTHOOK) && (lppd->lpfnPrintHook)) lpgti->pfnPrintDlg = NULL; if ((lppd->Flags & PD_ENABLESETUPHOOK) && (lppd->lpfnSetupHook)) lpgti->pfnPrintDlgSetup = NULL; } // Begin postcall if(RetVal) { if(lppd->hDevMode) GlobalFree(lppd->hDevMode); if(lppd->hDevNames) GlobalFree(lppd->hDevNames); lppd->hDevMode = HDevModeWfromA(&(pdA.hDevMode), TRUE); lppd->hDevNames = HDevNamesWfromA(&(pdA.hDevNames), TRUE); 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; lppd->lCustData = pdA.lCustData; } // Finished return RetVal; } End= [EFunc] TemplateName=QueryContextAttributesW Begin= SECURITY_STATUS __stdcall GodotQueryContextAttributesW(PCtxtHandle phContext, unsigned long int ulAttribute, void * pBuffer) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(SEC_E_UNSUPPORTED_FUNCTION); } End= [EFunc] TemplateName=QueryCredentialsAttributesW Begin= SECURITY_STATUS __stdcall GodotQueryCredentialsAttributesW(PCredHandle phCredential, unsigned long int ulAttribute, void * pBuffer) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(SEC_E_UNSUPPORTED_FUNCTION); } End= [EFunc] TemplateName=QueryDosDeviceW Begin= DWORD __stdcall GodotQueryDosDeviceW(LPCWSTR lpDeviceName, LPWSTR lpTargetPath, DWORD ucchMax) { DWORD RetVal; LPSTR lpDeviceNameAnsi; LPSTR lpTargetPathAnsi; UINT cpg = FILES_CPG; _STACKALLOC((ucchMax*g_mcs)+1, lpTargetPathAnsi); GODOT_TO_CPG_STACKALLOC(lpDeviceName, lpDeviceNameAnsi, cpg, g_mcs); RetVal=QueryDosDeviceA(lpDeviceNameAnsi, lpTargetPathAnsi, ucchMax); if(RetVal) MultiByteToWideChar(g_acp, 0, lpTargetPathAnsi, -1, lpTargetPath, ucchMax); return RetVal; } End= [EFunc] TemplateName=QuerySecurityPackageInfoW Begin= SECURITY_STATUS __stdcall GodotQuerySecurityPackageInfoW(SEC_WCHAR SEC_FAR * pPackageName, PSecPkgInfoW * ppPackageInfo) { // ACTUAL FAILURE STUB; USER CAN OVERRIDE IF THEY WANT TO return(SEC_E_UNSUPPORTED_FUNCTION); } End= [EFunc] TemplateName=RasConnectionNotificationW Begin= DWORD __stdcall GodotRasConnectionNotificationW(HRASCONN hrasconn, HANDLE hEvent, DWORD dwFlags) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasConnectionNotificationA == NULL) s_pfnRasConnectionNotificationA = (pfnRCN)GetRasProc("RasConnectionNotificationA"); if (s_pfnRasConnectionNotificationA) { // Why the heck is this function A/W decorated, anyway? // Its not like there are any strings here! RetVal=(s_pfnRasConnectionNotificationA(hrasconn, hEvent, dwFlags)); } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); // Finished return RetVal; } End= [EFunc] TemplateName=RasCreatePhonebookEntryW Begin= DWORD __stdcall GodotRasCreatePhonebookEntryW(HWND hwnd, LPCWSTR lpszPhonebook) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasCreatePhonebookEntryA == NULL) s_pfnRasCreatePhonebookEntryA = (pfnRCPE)GetRasProc("RasCreatePhonebookEntryA"); if (s_pfnRasCreatePhonebookEntryA) { if(MAX_PATH < gwcslen(lpszPhonebook)) RetVal = ERROR_INVALID_PARAMETER; else { char lpszPhonebookAnsi[MAX_PATH + 1]; WideCharToMultiByte(g_acp, 0, lpszPhonebook, -1, lpszPhonebookAnsi, MAX_PATH, NULL, NULL); RetVal=(s_pfnRasCreatePhonebookEntryA(hwnd, lpszPhonebookAnsi)); } } // Finished return(RetVal); UNREFERENCED_PARAMETER(lpszPhonebook); } End= [EFunc] TemplateName=RasDeleteEntryW Begin= DWORD __stdcall GodotRasDeleteEntryW(LPCWSTR lpszPhonebook, LPCWSTR lpszEntry) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasDeleteEntryA == NULL) s_pfnRasDeleteEntryA = (pfnRDE)GetRasProc("RasDeleteEntryA"); if (s_pfnRasDeleteEntryA) { if(RAS_MaxEntryName < gwcslen(lpszEntry)) RetVal = ERROR_INVALID_PARAMETER; else { char lpszEntryAnsi[RAS_MaxEntryName + 1]; WideCharToMultiByte(g_acp, 0, lpszEntry, -1, lpszEntryAnsi, RAS_MaxEntryName, NULL, NULL); RetVal=(s_pfnRasDeleteEntryA(NULL, lpszEntryAnsi)); } } // Finished return RetVal; UNREFERENCED_PARAMETER(lpszPhonebook); } End= [EFunc] TemplateName=RasDeleteSubEntryW Begin= DWORD __stdcall GodotRasDeleteSubEntryW(LPCWSTR pszPhonebook, LPCWSTR pszEntry, DWORD dwSubEntryId) { // if the call fails due to it not being on the OS (say like on // win95 or Win98), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasDeleteSubEntryA == NULL) s_pfnRasDeleteSubEntryA = (pfnRDSE)GetRasProc("RasDeleteSubEntryA"); if (s_pfnRasDeleteSubEntryA) { CHAR pszEntryAnsi[RAS_MaxEntryName + 1]; int cch = WideCharToMultiByte(g_acp, 0, pszEntry, -1, pszEntryAnsi, RAS_MaxEntryName, NULL, NULL); if(cch && (RAS_MaxEntryName >= cch)) RetVal=(s_pfnRasDeleteSubEntryA(NULL, pszEntryAnsi, dwSubEntryId)); else RetVal = ERROR_INVALID_PARAMETER; } // Finished return RetVal; UNREFERENCED_PARAMETER(pszPhonebook); } End= [EFunc] TemplateName=RasDialW Begin= DWORD __stdcall GodotRasDialW( LPRASDIALEXTENSIONS lpRasDialExtensions, LPCWSTR lpszPhonebook, LPRASDIALPARAMSW lpRasDialParams, DWORD dwNotifierType, LPVOID lpvNotifier, LPHRASCONN lphRasConn ) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasDialA == NULL) s_pfnRasDialA = (pfnRD)GetRasProc("RasDialA"); if (s_pfnRasDialA) { // Per the PSDK, lpRasDialExtensions and // lpszPhonebook are ignored on Win9x RASDIALPARAMSA rdpa; ZeroMemory(&rdpa, sizeof(RASDIALPARAMSA)); rdpa.dwSize = sizeof(RASDIALPARAMSA); WideCharToMultiByte(g_acp, 0, lpRasDialParams->szEntryName, RAS_MaxEntryName, rdpa.szEntryName, RAS_MaxEntryName, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasDialParams->szPhoneNumber, RAS_MaxPhoneNumber, rdpa.szPhoneNumber, RAS_MaxPhoneNumber, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasDialParams->szCallbackNumber, RAS_MaxCallbackNumber, rdpa.szCallbackNumber, RAS_MaxCallbackNumber, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasDialParams->szUserName, UNLEN, rdpa.szUserName, UNLEN, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasDialParams->szPassword, PWLEN, rdpa.szPassword, PWLEN, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasDialParams->szDomain, DNLEN, rdpa.szDomain, RAS_MaxEntryName, NULL, NULL); // Do not copy lprdpa->dwSubEntry or dwCallbackId, even if they are // present, as they are Win2000 only members RetVal=(s_pfnRasDialA(NULL, NULL, &rdpa, dwNotifierType, lpvNotifier, lphRasConn)); } // Finished return RetVal; UNREFERENCED_PARAMETER(lpszPhonebook); } End= [EFunc] TemplateName=RasEditPhonebookEntryW Begin= DWORD __stdcall GodotRasEditPhonebookEntryW(HWND hwnd, LPCWSTR lpszPhonebook, LPCWSTR lpszEntryName) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasEditPhonebookEntryA == NULL) s_pfnRasEditPhonebookEntryA = (pfnREPE)GetRasProc("RasEditPhonebookEntryA"); if (s_pfnRasEditPhonebookEntryA) { if(RAS_MaxEntryName < gwcslen(lpszEntryName)) RetVal = ERROR_INVALID_PARAMETER; else { char lpszEntryNameAnsi[RAS_MaxEntryName]; WideCharToMultiByte(g_acp, 0, lpszEntryName, -1, lpszEntryNameAnsi, RAS_MaxEntryName, NULL, NULL); RetVal=(s_pfnRasEditPhonebookEntryA(hwnd, NULL, lpszEntryNameAnsi)); } } // Finished return RetVal; UNREFERENCED_PARAMETER(lpszPhonebook); } End= [EFunc] TemplateName=RasEnumConnectionsW Begin= DWORD __stdcall GodotRasEnumConnectionsW(struct tagRASCONNW * lprasconn, LPDWORD lpcb, LPDWORD lpcConnections) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasEnumConnectionsA == NULL) s_pfnRasEnumConnectionsA = (pfnREC)GetRasProc("RasEnumConnectionsA"); if (s_pfnRasEnumConnectionsA) { BOOL fNew; DWORD cbConnections; LPRASCONNA lprasconnA; // Check parameters. if (!lprasconn || (lprasconn->dwSize < CBRASCONNOLDW)) return ERROR_INVALID_SIZE; if (lpcb == NULL || lpcConnections == NULL) return ERROR_INVALID_PARAMETER; if(fNew = (lprasconn->dwSize == CBRASCONNOLDW)) { cbConnections = CBRASCONNOLDA * (*lpcb / CBRASCONNOLDW); _STACKALLOC(cbConnections, lprasconnA); ZeroMemory(lprasconnA, cbConnections); lprasconnA->dwSize = CBRASCONNOLDA; } else { cbConnections = CBRASCONNNEWA * (*lpcb / CBRASCONNNEWW); _STACKALLOC(cbConnections, lprasconnA); ZeroMemory(lprasconnA, cbConnections); lprasconnA->dwSize = CBRASCONNNEWA; } RetVal=(s_pfnRasEnumConnectionsA(lprasconnA, &cbConnections, lpcConnections)); // If the call succeeded, copy data back to the caller's buffer if(RetVal==0) { DWORD iCon; for(iCon = 0 ; iCon < *lpcConnections ; iCon++) { LPRASCONNW lprcw = &lprasconn[iCon]; LPRASCONNA lprca = &lprasconnA[iCon]; lprcw->hrasconn = lprca->hrasconn; MultiByteToWideChar(g_acp, 0, lprca->szEntryName, RAS_MaxEntryName, lprcw->szEntryName, RAS_MaxEntryName); MultiByteToWideChar(g_acp, 0, lprca->szDeviceType, RAS_MaxDeviceType, lprcw->szDeviceType, RAS_MaxDeviceType); MultiByteToWideChar(g_acp, 0, lprca->szDeviceName, RAS_MaxDeviceName, lprcw->szDeviceName, RAS_MaxDeviceName); if(!fNew) { lprcw->dwSize = CBRASCONNOLDW; } else { lprcw->dwSize = CBRASCONNNEWW; lprcw->dwSubEntry = lprca->dwSubEntry; MultiByteToWideChar(g_acp, 0, lprca->szPhonebook, MAX_PATH, lprcw->szPhonebook, MAX_PATH); } } } // In all cases, *lpcb should be updated // with the correct size. *lpcb = (*lpcConnections * lprasconn->dwSize); } return RetVal; } End= [EFunc] TemplateName=RasEnumDevicesW Begin= DWORD __stdcall GodotRasEnumDevicesW(LPRASDEVINFOW lpRasDevInfo, LPDWORD lpcb, LPDWORD lpcDevices) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasEnumDevicesA == NULL) s_pfnRasEnumDevicesA = (pfnRED)GetRasProc("RasEnumDevicesA"); if (s_pfnRasEnumDevicesA) { UINT i; DWORD cbAnsi = *lpcb; if (lpRasDevInfo == NULL || cbAnsi == 0) RetVal=(s_pfnRasEnumDevicesA(NULL, &cbAnsi, lpcDevices)); else { LPRASDEVINFOA lprdia; _STACKALLOC(*lpcDevices * sizeof(RASDEVINFOA), lprdia); if(lprdia==NULL) return(ERROR_STACK_OVERFLOW); lprdia->dwSize = sizeof(RASDEVINFOA); RetVal=(s_pfnRasEnumDevicesA(lprdia, &cbAnsi, lpcDevices)); if(RetVal == 0) { for (i=0; i < *(lpcDevices); i++) { MultiByteToWideChar(g_acp, 0, lprdia[i].szDeviceType, RAS_MaxDeviceType, lpRasDevInfo[i].szDeviceType, RAS_MaxDeviceType); MultiByteToWideChar(g_acp, 0, lprdia[i].szDeviceName, RAS_MaxDeviceName, lpRasDevInfo[i].szDeviceName, RAS_MaxDeviceName); } } } *lpcb = ((cbAnsi)/sizeof(RASDEVINFOA))*sizeof(RASDEVINFOW); } // Finished return RetVal; } End= [EFunc] TemplateName=RasEnumEntriesW Begin= DWORD __stdcall GodotRasEnumEntriesW( LPCWSTR reserved, LPCWSTR lpszPhonebook, LPRASENTRYNAMEW lprasentryname, LPDWORD lpcb, LPDWORD lpcEntries ) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasEnumEntriesA == NULL) s_pfnRasEnumEntriesA = (pfnREE)GetRasProc("RasEnumEntriesA"); if (s_pfnRasEnumEntriesA) { DWORD cbAnsi = *lpcb; LPRASENTRYNAMEA lprena; UINT i; _STACKALLOC(cbAnsi * sizeof(RASENTRYNAMEA), lprena); if(lprena==NULL) return(ERROR_STACK_OVERFLOW); lprena->dwSize = sizeof(RASENTRYNAMEA); // Calling RasEnumEntries to enumerate the phone-book entries RetVal = (s_pfnRasEnumEntriesA(NULL, NULL, lprena, &cbAnsi, lpcEntries)); if(RetVal == 0) { for (i=0; i < *(lpcEntries); i++) { MultiByteToWideChar(g_acp, 0, lprena[i].szEntryName, RAS_MaxEntryName, lprasentryname[i].szEntryName, RAS_MaxEntryName); lprena++; lprasentryname++; } } else { *lpcb = cbAnsi*sizeof(WCHAR); } } // Finished return RetVal; UNREFERENCED_PARAMETER(lpszPhonebook); } End= [EFunc] TemplateName=RasGetConnectStatusW Begin= DWORD __stdcall GodotRasGetConnectStatusW(HRASCONN hrasconn, LPRASCONNSTATUSW lprasconnstatus) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasGetConnectStatusA == NULL) s_pfnRasGetConnectStatusA = (pfnRGCS)GetRasProc("RasGetConnectStatusA"); if (s_pfnRasGetConnectStatusA) { RASCONNSTATUSA rcsa; ZeroMemory(&rcsa, sizeof(RASCONNSTATUSA)); rcsa.dwSize = sizeof(RASCONNSTATUSA); RetVal=(s_pfnRasGetConnectStatusA(hrasconn, &rcsa)); if(RetVal==0) { MultiByteToWideChar(g_acp, 0, rcsa.szDeviceType, RAS_MaxDeviceType, lprasconnstatus->szDeviceType, RAS_MaxDeviceType); MultiByteToWideChar(g_acp, 0, rcsa.szDeviceName, RAS_MaxDeviceName, lprasconnstatus->szDeviceName, RAS_MaxDeviceName); } } // Finished return RetVal; } End= [EFunc] TemplateName=RasGetEntryDialParamsW Begin= DWORD __stdcall GodotRasGetEntryDialParamsW(LPCWSTR lpszPhonebook, LPRASDIALPARAMSW lprasdialparams, LPBOOL lpfPassword) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasGetEntryDialParamsA == NULL) s_pfnRasGetEntryDialParamsA = (pfnRGEDP)GetRasProc("RasGetEntryDialParamsA"); if (s_pfnRasGetEntryDialParamsA) { LPRASDIALPARAMSA lprdpa; BOOL fOldStruct = (lprasdialparams->dwSize == CBRASDIALPARAMSOLDW); if(fOldStruct) { _STACKALLOC(CBRASDIALPARAMSOLDA, lprdpa); if(lprdpa==NULL) return(ERROR_STACK_OVERFLOW); ZeroMemory(lprdpa, CBRASDIALPARAMSOLDA); lprdpa->dwSize = CBRASDIALPARAMSOLDA; } else { _STACKALLOC(CBRASDIALPARAMSNEWA, lprdpa); if(lprdpa==NULL) return(ERROR_STACK_OVERFLOW); ZeroMemory(lprdpa, CBRASDIALPARAMSNEWA); lprdpa->dwSize = CBRASDIALPARAMSNEWA; } RetVal=(s_pfnRasGetEntryDialParamsA(NULL, lprdpa, lpfPassword)); if(RetVal==0) { MultiByteToWideChar(g_acp, 0, lprdpa->szEntryName, RAS_MaxEntryName, lprasdialparams->szEntryName, RAS_MaxEntryName); MultiByteToWideChar(g_acp, 0, lprdpa->szPhoneNumber, RAS_MaxPhoneNumber, lprasdialparams->szPhoneNumber, RAS_MaxPhoneNumber); MultiByteToWideChar(g_acp, 0, lprdpa->szCallbackNumber, RAS_MaxCallbackNumber, lprasdialparams->szCallbackNumber, RAS_MaxCallbackNumber); MultiByteToWideChar(g_acp, 0, lprdpa->szUserName, UNLEN, lprasdialparams->szUserName, UNLEN); MultiByteToWideChar(g_acp, 0, lprdpa->szPassword, PWLEN, lprasdialparams->szPassword, PWLEN); MultiByteToWideChar(g_acp, 0, lprdpa->szDomain, DNLEN, lprasdialparams->szDomain, DNLEN); if(!fOldStruct) { lprasdialparams->dwSubEntry = lprdpa->dwSubEntry ; lprasdialparams->dwCallbackId = lprdpa->dwCallbackId; } } } // Finished return RetVal; UNREFERENCED_PARAMETER(lpszPhonebook); } End= [EFunc] TemplateName=RasGetEntryPropertiesW Begin= DWORD __stdcall GodotRasGetEntryPropertiesW( LPCWSTR lpszPhonebook, LPCWSTR lpszEntry, LPRASENTRYW lpRasEntry, DWORD * lpdwEntryInfoSize, LPBYTE lpbDeviceInfo, LPDWORD lpdwDeviceInfoSize ) { // We do not support dwAlternateOffset presently. Neither does QuintinB in // the RAS Connection Manager. If this was needed then someone would have // to do the work. For now its a known limitation of Godot. // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasGetEntryPropertiesA == NULL) s_pfnRasGetEntryPropertiesA = (pfnRGEP)GetRasProc("RasGetEntryPropertiesA"); if (s_pfnRasGetEntryPropertiesA) { if(RAS_MaxEntryName < gwcslen(lpszEntry)) RetVal = ERROR_INVALID_PARAMETER; else { char lpszEntryAnsi[RAS_MaxEntryName + 1]; LPRASENTRYA lprea; DWORD dweisa; BOOL f401Struct; WideCharToMultiByte(g_acp, 0, lpszEntry, -1, lpszEntryAnsi, RAS_MaxEntryName, NULL, NULL); if (lpRasEntry->dwSize > CBRASENTRYOLDW) { f401Struct = TRUE; _STACKALLOC(CBRASENTRYOLDA, lprea); if(lprea) { ZeroMemory(lprea, CBRASENTRYOLDA); lprea->dwSize = CBRASENTRYOLDA; dweisa = (DWORD)CBRASENTRYOLDA; } } else { f401Struct = FALSE; _STACKALLOC(CBRASENTRYNEWA, lprea); if(lprea) { ZeroMemory(lprea, CBRASENTRYNEWA); lprea->dwSize = CBRASENTRYNEWA; dweisa = (DWORD)CBRASENTRYNEWA; } } if(lprea==NULL) { return(ERROR_STACK_OVERFLOW); } RetVal=(s_pfnRasGetEntryPropertiesA(NULL, lpszEntryAnsi, lprea, &dweisa, lpbDeviceInfo, lpdwDeviceInfoSize)); if((RetVal==ERROR_SUCCESS) && lpRasEntry) { lpRasEntry->dwfOptions = lprea->dwfOptions; // Location/phone number. lpRasEntry->dwCountryID = lprea->dwCountryID; lpRasEntry->dwCountryCode = lprea->dwCountryCode; MultiByteToWideChar(g_acp, 0, lprea->szAreaCode, RAS_MaxAreaCode, lpRasEntry->szAreaCode, RAS_MaxAreaCode); MultiByteToWideChar(g_acp, 0, lprea->szLocalPhoneNumber, RAS_MaxPhoneNumber, lpRasEntry->szLocalPhoneNumber, RAS_MaxPhoneNumber); lpRasEntry->dwAlternateOffset = lprea->dwAlternateOffset; // PPP/Ip memcpy(&(lpRasEntry->ipaddr), &(lprea->ipaddr), sizeof(RASIPADDR)); memcpy(&(lpRasEntry->ipaddrDns), &(lprea->ipaddrDns), sizeof(RASIPADDR)); memcpy(&(lpRasEntry->ipaddrDnsAlt), &(lprea->ipaddrDnsAlt), sizeof(RASIPADDR)); memcpy(&(lpRasEntry->ipaddrWins), &(lprea->ipaddrWins), sizeof(RASIPADDR)); memcpy(&(lpRasEntry->ipaddrWinsAlt), &(lprea->ipaddrWinsAlt), sizeof(RASIPADDR)); // Framing lpRasEntry->dwFrameSize = lprea->dwFrameSize; lpRasEntry->dwfNetProtocols = lprea->dwfNetProtocols; lpRasEntry->dwFramingProtocol = lprea->dwFramingProtocol; // Scripting MultiByteToWideChar(g_acp, 0, lprea->szScript, MAX_PATH, lpRasEntry->szScript, MAX_PATH); // AutoDial MultiByteToWideChar(g_acp, 0, lprea->szAutodialDll, MAX_PATH, lpRasEntry->szAutodialDll, MAX_PATH); MultiByteToWideChar(g_acp, 0, lprea->szAutodialFunc, MAX_PATH, lpRasEntry->szAutodialFunc, MAX_PATH); // Device MultiByteToWideChar(g_acp, 0, lprea->szDeviceType, RAS_MaxDeviceType, lpRasEntry->szDeviceType, RAS_MaxDeviceType); MultiByteToWideChar(g_acp, 0, lprea->szDeviceName, RAS_MaxDeviceName, lpRasEntry->szDeviceName, RAS_MaxDeviceName); // X.25 MultiByteToWideChar(g_acp, 0, lprea->szX25PadType, RAS_MaxPadType, lpRasEntry->szX25PadType, RAS_MaxPadType); MultiByteToWideChar(g_acp, 0, lprea->szX25Address, RAS_MaxX25Address, lpRasEntry->szX25Address, RAS_MaxX25Address); MultiByteToWideChar(g_acp, 0, lprea->szX25Facilities, RAS_MaxFacilities, lpRasEntry->szX25Facilities, RAS_MaxFacilities); MultiByteToWideChar(g_acp, 0, lprea->szX25UserData, RAS_MaxUserData, lpRasEntry->szX25UserData, RAS_MaxUserData); lpRasEntry->dwChannels = lprea->dwChannels; // Reserved - no need to copy but no reason not to lpRasEntry->dwReserved1 = lprea->dwReserved1; lpRasEntry->dwReserved2 = lprea->dwReserved2; if(f401Struct) { lpRasEntry->dwSubEntries = lprea->dwSubEntries; lpRasEntry->dwDialMode = lprea->dwDialMode; lpRasEntry->dwDialExtraPercent = lprea->dwDialExtraPercent; lpRasEntry->dwDialExtraSampleSeconds = lprea->dwDialExtraSampleSeconds; lpRasEntry->dwHangUpExtraPercent = lprea->dwHangUpExtraPercent; lpRasEntry->dwHangUpExtraSampleSeconds = lprea->dwHangUpExtraSampleSeconds; lpRasEntry->dwIdleDisconnectSeconds = lprea->dwIdleDisconnectSeconds; } } else if ((ERROR_BUFFER_TOO_SMALL == RetVal) || !lpRasEntry) { // We don't know the actual size since we are passing a RASENTRYA, but // the user only knows about RASENTRYW. Thus double the returned size // and we will call it a day. *lpdwEntryInfoSize = dweisa*sizeof(WCHAR); } } } // Finished return RetVal; UNREFERENCED_PARAMETER(lpszPhonebook); } End= [EFunc] TemplateName=RasGetErrorStringW Begin= DWORD __stdcall GodotRasGetErrorStringW(UINT uErrorValue, LPWSTR lpszErrorString, DWORD cBufSize) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasGetErrorStringA == NULL) s_pfnRasGetErrorStringA = (pfnRGES)GetRasProc("RasGetErrorStringA"); if (s_pfnRasGetErrorStringA) { char lpszErrorStringAnsi[256 + 1]; RetVal=(s_pfnRasGetErrorStringA(uErrorValue, lpszErrorStringAnsi, cBufSize)); if (RetVal==ERROR_SUCCESS) MultiByteToWideChar(g_acp, 0, lpszErrorStringAnsi, -1, lpszErrorString, cBufSize); } // Finished return RetVal; } End= [EFunc] TemplateName=RasHangUpW Begin= DWORD __stdcall GodotRasHangUpW(HRASCONN hrasconn) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasHangUpA == NULL) s_pfnRasHangUpA = (pfnRHU)GetRasProc("RasHangUpA"); if (s_pfnRasHangUpA) { // Why the heck is this function A/W decorated, anyway? // Its not like there are any strings here! RetVal=(s_pfnRasHangUpA(hrasconn)); } return(RetVal); } End= [EFunc] TemplateName=RasRenameEntryW Begin= DWORD __stdcall GodotRasRenameEntryW(LPCWSTR lpszPhonebook, LPCWSTR lpszOldEntry, LPCWSTR lpszNewEntry) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasRenameEntryA == NULL) s_pfnRasRenameEntryA = (pfnRRE)GetRasProc("RasRenameEntryA"); if (s_pfnRasRenameEntryA) { if((RAS_MaxEntryName < gwcslen(lpszOldEntry)) || (RAS_MaxEntryName < gwcslen(lpszNewEntry))) RetVal = ERROR_INVALID_PARAMETER; else { char lpszOldEntryAnsi[RAS_MaxEntryName + 1]; char lpszNewEntryAnsi[RAS_MaxEntryName + 1]; WideCharToMultiByte(g_acp, 0, lpszOldEntry, -1, lpszOldEntryAnsi, RAS_MaxEntryName, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpszNewEntry, -1, lpszNewEntryAnsi, RAS_MaxEntryName, NULL, NULL); RetVal=(s_pfnRasRenameEntryA(NULL, lpszOldEntryAnsi, lpszNewEntryAnsi)); } } // Finished return RetVal; UNREFERENCED_PARAMETER(lpszPhonebook); } End= [EFunc] TemplateName=RasSetEntryDialParamsW Begin= DWORD __stdcall GodotRasSetEntryDialParamsW(LPCWSTR lpszPhonebook, LPRASDIALPARAMSW lprasdialparams, BOOL fRemovePassword) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error // code, rather than using SetLastError. Godot will do both. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasSetEntryDialParamsA == NULL) s_pfnRasSetEntryDialParamsA = (pfnRSEDP)GetRasProc("RasSetEntryDialParamsA"); if (s_pfnRasSetEntryDialParamsA) { LPRASDIALPARAMSA lprdpa; if (lprasdialparams->dwSize == CBRASDIALPARAMSOLDW) { _STACKALLOC(CBRASDIALPARAMSOLDA, lprdpa); if(lprdpa) lprdpa->dwSize = CBRASDIALPARAMSOLDA; } else { _STACKALLOC(CBRASDIALPARAMSNEWA, lprdpa); if(lprdpa) { lprdpa->dwSize = CBRASDIALPARAMSNEWA; lprdpa->dwSubEntry = lprasdialparams->dwSubEntry; lprdpa->dwCallbackId = lprasdialparams->dwCallbackId; } } if(lprdpa) { WideCharToMultiByte(g_acp, 0, lprasdialparams->szEntryName, RAS_MaxEntryName, lprdpa->szEntryName, RAS_MaxEntryName, NULL, NULL); WideCharToMultiByte(g_acp, 0, lprasdialparams->szPhoneNumber, RAS_MaxPhoneNumber, lprdpa->szPhoneNumber, RAS_MaxPhoneNumber, NULL, NULL); WideCharToMultiByte(g_acp, 0, lprasdialparams->szCallbackNumber, RAS_MaxCallbackNumber, lprdpa->szCallbackNumber, RAS_MaxCallbackNumber, NULL, NULL); WideCharToMultiByte(g_acp, 0, lprasdialparams->szUserName, UNLEN, lprdpa->szUserName, UNLEN, NULL, NULL); WideCharToMultiByte(g_acp, 0, lprasdialparams->szPassword, PWLEN, lprdpa->szPassword, PWLEN, NULL, NULL); WideCharToMultiByte(g_acp, 0, lprasdialparams->szDomain, DNLEN, lprdpa->szDomain, DNLEN, NULL, NULL); RetVal = (s_pfnRasSetEntryDialParamsA(NULL, lprdpa, fRemovePassword)); } else RetVal = ERROR_STACK_OVERFLOW; } return(RetVal); UNREFERENCED_PARAMETER(lpszPhonebook); } End= [EFunc] TemplateName=RasSetEntryPropertiesW Begin= DWORD __stdcall GodotRasSetEntryPropertiesW( LPCWSTR lpszPhonebook, LPCWSTR lpszEntry, LPRASENTRYW lpRasEntry, DWORD dwEntryInfoSize, LPBYTE lpbDeviceInfo, DWORD dwDeviceInfoSize ) { // We do not support dwAlternateOffset presently. Neither does QuintinB // in the RAS Connection Manager. If this was needed then someone would // have to do the work. For now its a limitation of Godot. // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error code DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasSetEntryPropertiesA == NULL) s_pfnRasSetEntryPropertiesA = (pfnRSEP)GetRasProc("RasSetEntryPropertiesA"); if (s_pfnRasSetEntryPropertiesA) { if(RAS_MaxEntryName < gwcslen(lpszEntry)) RetVal = ERROR_INVALID_PARAMETER; else { LPRASENTRYA lprea; char lpszEntryAnsi[RAS_MaxEntryName]; _STACKALLOC(CBRASENTRYNEWA, lprea); if(lprea==NULL) { return(ERROR_STACK_OVERFLOW); } WideCharToMultiByte(g_acp, 0, lpszEntry, -1, lpszEntryAnsi, RAS_MaxEntryName, NULL, NULL); ZeroMemory(lprea, CBRASENTRYNEWA); lprea->dwfOptions = lpRasEntry->dwfOptions; lprea->dwCountryID = lpRasEntry->dwCountryID; lprea->dwCountryCode = lpRasEntry->dwCountryCode; WideCharToMultiByte(g_acp, 0, lpRasEntry->szAreaCode, RAS_MaxAreaCode, lprea->szAreaCode, RAS_MaxAreaCode, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasEntry->szLocalPhoneNumber, RAS_MaxPhoneNumber, lprea->szLocalPhoneNumber, RAS_MaxPhoneNumber, NULL, NULL); lprea->dwAlternateOffset = lpRasEntry->dwAlternateOffset; memcpy(&(lprea->ipaddr), &(lpRasEntry->ipaddr), sizeof(RASIPADDR)); memcpy(&(lprea->ipaddrDns), &(lpRasEntry->ipaddrDns), sizeof(RASIPADDR)); memcpy(&(lprea->ipaddrDnsAlt), &(lpRasEntry->ipaddrDnsAlt), sizeof(RASIPADDR)); memcpy(&(lprea->ipaddrWins), &(lpRasEntry->ipaddrWins), sizeof(RASIPADDR)); memcpy(&(lprea->ipaddrWinsAlt), &(lpRasEntry->ipaddrWinsAlt), sizeof(RASIPADDR)); lprea->dwFrameSize = lpRasEntry->dwFrameSize; lprea->dwfNetProtocols = lpRasEntry->dwfNetProtocols; lprea->dwFramingProtocol = lpRasEntry->dwFramingProtocol; WideCharToMultiByte(g_acp, 0, lpRasEntry->szScript, MAX_PATH, lprea->szScript, MAX_PATH, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasEntry->szAutodialDll, MAX_PATH, lprea->szAutodialDll, MAX_PATH, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasEntry->szAutodialFunc, MAX_PATH, lprea->szAutodialFunc, MAX_PATH, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasEntry->szDeviceType, RAS_MaxDeviceType, lprea->szDeviceType, RAS_MaxDeviceType, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasEntry->szDeviceName, RAS_MaxDeviceName, lprea->szDeviceName, RAS_MaxDeviceName, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasEntry->szX25PadType, RAS_MaxPadType, lprea->szX25PadType, RAS_MaxPadType, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasEntry->szX25Address, RAS_MaxX25Address, lprea->szX25Address, RAS_MaxX25Address, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasEntry->szX25Facilities, RAS_MaxFacilities, lprea->szX25Facilities, RAS_MaxFacilities, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasEntry->szX25UserData, RAS_MaxUserData, lprea->szX25UserData, RAS_MaxUserData, NULL, NULL); lprea->dwChannels = lpRasEntry->dwChannels; lprea->dwReserved1 = lpRasEntry->dwReserved1; lprea->dwReserved2 = lpRasEntry->dwReserved2; if (lpRasEntry->dwSize > CBRASENTRYOLDW) lprea->dwSize = CBRASENTRYOLDA; else { lprea->dwSize = CBRASENTRYNEWA; lprea->dwSubEntries = lpRasEntry->dwSubEntries; lprea->dwDialMode = lpRasEntry->dwDialMode; lprea->dwDialExtraPercent = lpRasEntry->dwDialExtraPercent; lprea->dwDialExtraSampleSeconds = lpRasEntry->dwDialExtraSampleSeconds; lprea->dwHangUpExtraPercent = lpRasEntry->dwHangUpExtraPercent; lprea->dwHangUpExtraSampleSeconds = lpRasEntry->dwHangUpExtraSampleSeconds; lprea->dwIdleDisconnectSeconds = lpRasEntry->dwIdleDisconnectSeconds; } RetVal=(s_pfnRasSetEntryPropertiesA(NULL, lpszEntryAnsi, lprea, dwEntryInfoSize, lpbDeviceInfo, dwDeviceInfoSize)); } } // Finished return RetVal; UNREFERENCED_PARAMETER(lpszPhonebook); } End= [EFunc] TemplateName=RasSetSubEntryPropertiesW Begin= DWORD __stdcall GodotRasSetSubEntryPropertiesW(LPCWSTR lpszPhonebook, LPCWSTR lpszEntry, DWORD dwSubEntry, struct tagRASSUBENTRYW * lpRasSubEntry, DWORD dwcbRasSubEntry, LPBYTE lpbDeviceConfig, DWORD dwcbDeviceConfig) { // if the call fails due to it not being on the OS (say like on // win95/win98), then it might return a "non-zero" error code. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasSetSubEntryPropertiesA == NULL) s_pfnRasSetSubEntryPropertiesA = (pfnRSSEP)GetRasProc("RasSetSubEntryPropertiesA"); if (s_pfnRasSetSubEntryPropertiesA) { CHAR lpszEntryAnsi[RAS_MaxEntryName + 1]; int cch = WideCharToMultiByte(g_acp, 0, lpszEntry, -1, lpszEntryAnsi, RAS_MaxEntryName, NULL, NULL); if(cch && (RAS_MaxEntryName >= cch)) { LPRASSUBENTRYA lpRasSubEntryA; DWORD dwcbRasSubEntryA; size_t cchSub; if(lpRasSubEntry->dwAlternateOffset) cchSub = cchUnicodeMultiSz((LPWSTR)lpRasSubEntry + lpRasSubEntry->dwAlternateOffset); else cchSub = 0; dwcbRasSubEntryA = sizeof(RASENTRYA) + (cchSub * g_mcs); _STACKALLOC(dwcbRasSubEntryA, lpRasSubEntryA); if(lpRasSubEntryA==NULL) return(ERROR_STACK_OVERFLOW); ZeroMemory(lpRasSubEntryA, dwcbRasSubEntryA); lpRasSubEntryA->dwSize = sizeof(RASSUBENTRYA); lpRasSubEntryA->dwfFlags = lpRasSubEntry->dwfFlags; // // Device // WideCharToMultiByte(g_acp, 0, lpRasSubEntry->szDeviceType, RAS_MaxDeviceType, lpRasSubEntryA->szDeviceType, RAS_MaxDeviceType, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpRasSubEntry->szDeviceName, RAS_MaxDeviceName, lpRasSubEntryA->szDeviceName, RAS_MaxDeviceName, NULL, NULL); // // Location/phone number. // WideCharToMultiByte(g_acp, 0, lpRasSubEntry->szLocalPhoneNumber, RAS_MaxPhoneNumber, lpRasSubEntryA->szLocalPhoneNumber, RAS_MaxPhoneNumber, NULL, NULL); WideCharToMultiByte(g_acp, 0, (LPWSTR)lpRasSubEntry + lpRasSubEntry->dwAlternateOffset, cchSub, (LPSTR)lpRasSubEntry + lpRasSubEntry->dwAlternateOffset, cchSub * g_mcs, NULL, NULL); RetVal=(s_pfnRasSetSubEntryPropertiesA(NULL, lpszEntryAnsi, dwSubEntry, lpRasSubEntryA, dwcbRasSubEntryA, lpbDeviceConfig, dwcbDeviceConfig)); } else RetVal = ERROR_INVALID_PARAMETER; } // Finished return RetVal; UNREFERENCED_PARAMETER(lpszPhonebook); } End= [EFunc] TemplateName=RasValidateEntryNameW Begin= DWORD __stdcall GodotRasValidateEntryNameW(LPCWSTR lpszPhonebook, LPCWSTR lpszEntry) { // if the call fails due to it not being on the OS (say like on // win95), then it might return a "non-zero" error code. DWORD RetVal = ERROR_CALL_NOT_IMPLEMENTED; if (s_pfnRasValidateEntryNameA == NULL) s_pfnRasValidateEntryNameA = (pfnRVEN)GetRasProc("RasValidateEntryNameA"); if (s_pfnRasValidateEntryNameA) { if(RAS_MaxEntryName < gwcslen(lpszEntry)) RetVal = ERROR_INVALID_PARAMETER; else { char lpszEntryAnsi[RAS_MaxEntryName]; WideCharToMultiByte(g_acp, 0, lpszEntry, -1, lpszEntryAnsi, RAS_MaxEntryName, NULL, NULL); RetVal=(s_pfnRasValidateEntryNameA(NULL, lpszEntryAnsi)); } } // Finished return RetVal; UNREFERENCED_PARAMETER(lpszPhonebook); } End= [EFunc] TemplateName=RealGetWindowClassW Begin= UINT __stdcall GodotRealGetWindowClassW(HWND hwnd, LPWSTR pszType, UINT cchType) { // Begin locals UINT RetVal; LPSTR pszTypeAnsi; _STACKALLOC((cchType*g_mcs)+1, pszTypeAnsi); // Call the 'A' version of the API RetVal=RealGetWindowClassA(hwnd, pszTypeAnsi, cchType); // Begin postcall if(RetVal) { MultiByteToWideChar(g_acp, 0, pszTypeAnsi, -1, pszType, cchType); } else if(pszType) { *pszType = 0; } // Finished return RetVal; } End= [EFunc] TemplateName=ReadConsoleOutputCharacterW Begin= BOOL __stdcall GodotReadConsoleOutputCharacterW( HANDLE hConsoleOutput, LPWSTR lpCharacter, DWORD nLength, COORD dwReadCoord, LPDWORD lpcchRead ) { // Begin locals BOOL RetVal; LPSTR lpCharacterAnsi; _STACKALLOC((nLength*g_mcs)+1, lpCharacterAnsi); if(lpCharacterAnsi==NULL && lpCharacter != NULL) { SetLastError(ERROR_STACK_OVERFLOW); return(FALSE); } // Call the 'A' version of the API RetVal=ReadConsoleOutputCharacterA(hConsoleOutput, lpCharacterAnsi, nLength, dwReadCoord, lpcchRead); // Begin postcall if(RetVal && lpCharacter && lpCharacterAnsi) MultiByteToWideChar(g_oemcp, 0, lpCharacterAnsi, -1, lpCharacter, *(lpcchRead)); // Finished return RetVal; } End= [EFunc] TemplateName=RegEnumKeyW Begin= LONG __stdcall GodotRegEnumKeyW(HKEY hKey, DWORD dwIndex, LPWSTR lpName, DWORD cbName) { // Begin locals LONG RetVal; LPSTR lpNameAnsi; // Copied from the OS API's param validation if (IsBadWritePtr(lpName, cbName)) return ERROR_INVALID_PARAMETER; // Alloc a string of like size. _STACKALLOC((cbName*g_mcs)+1, lpNameAnsi); if(lpNameAnsi==NULL) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } // Call the 'A' version of the API RetVal=RegEnumKeyA(hKey, dwIndex, lpNameAnsi, cbName); // Begin postcall if(RetVal == ERROR_SUCCESS) MultiByteToWideChar(g_acp, 0, lpNameAnsi, -1, lpName, cbName); // Finished return RetVal; } End= [EFunc] TemplateName=RegEnumKeyExW Begin= LONG __stdcall GodotRegEnumKeyExW( HKEY hKey, DWORD dwIndex, LPWSTR lpName, LPDWORD lpcbName, LPDWORD lpReserved, LPWSTR lpClass, LPDWORD lpcbClass, PFILETIME lpftLWT ) { // Begin locals LONG RetVal; LPSTR lpNameAnsi, lpClassAnsi; DWORD cbName, cbClass; if (lpcbName) { cbName = sizeof(WCHAR) * *lpcbName; _STACKALLOC(cbName, lpNameAnsi); } else { cbName = 0; lpNameAnsi = NULL; } if (lpcbClass) { cbClass = sizeof(WCHAR) * (*lpcbClass); _STACKALLOC(cbClass, lpClassAnsi); } else { cbClass = 0; lpClassAnsi = NULL; } // Call the 'A' version of the API RetVal=RegEnumKeyExA(hKey, dwIndex, lpNameAnsi, &cbName, lpReserved, lpClassAnsi, &cbClass, lpftLWT); // Begin postcall if(RetVal == ERROR_SUCCESS) { DWORD cch; if(lpName && lpcbName) { cch = MultiByteToWideChar(g_acp, 0, lpNameAnsi, cbName, lpName, *lpcbName); if(cbName && !cch) RetVal = ERROR_BUFFER_OVERFLOW; *lpcbName = cch; } else if (lpcbName) { *lpcbName = 0; } if(lpClass && lpcbClass) { cch = MultiByteToWideChar(g_acp, 0, lpClassAnsi, cbClass, lpClass, *lpcbClass); if(cbName && !cch) RetVal = ERROR_BUFFER_OVERFLOW; *lpcbClass = cch; } else if (lpcbClass) { *lpcbClass = 0; } } // Finished return RetVal; } End= [EFunc] TemplateName=RegEnumValueW Begin= LONG __stdcall GodotRegEnumValueW( HKEY hKey, DWORD dwIndex, LPWSTR lpValueName, LPDWORD lpcbValueName, // this is cch, not cb, in the W case!!! LPDWORD lpReserved, LPDWORD lpType, // may be NULL LPBYTE lpData, // may be NULL LPDWORD lpcbData) // may be NULL -- but only if lpData is NULL { // Begin locals LONG RetVal; LPSTR szValue; DWORD dwType; DWORD cbValueName; DWORD cbData; // Required pointers: if (!lpValueName || !lpcbValueName || (!lpcbData && lpData)) { return ERROR_INVALID_PARAMETER; } cbValueName = *lpcbValueName; _STACKALLOC((cbValueName)*g_mcs, szValue); if(szValue==NULL) { return(ERROR_STACK_OVERFLOW); } if(lpcbData) cbData = *lpcbData; else cbData = 0; // First call for informational purposes: type, etc. We // do get the name, here (since we always get the name). RetVal = RegEnumValueA(hKey, dwIndex, szValue, &cbValueName, lpReserved, &dwType, NULL, &cbData); // Always copy the type info if the caller asked for it if(lpType) *lpType = dwType; if(RetVal != ERROR_SUCCESS) { if(lpcbData) *lpcbData = cbData; if(lpcbValueName) *lpcbValueName = cbValueName; } else { // We should always make it here unless they did something *really* awful *lpcbValueName = MultiByteToWideChar(g_acp, 0, szValue, cbValueName, lpValueName, *lpcbValueName); if(*lpcbValueName == 0) { // They did not give us enough of a buffer: this can happen on // DBCS platforms with single-byte data (the *g_mcs buffer we // allocated was big enough, but theirs is not). RetVal = ERROR_INSUFFICIENT_BUFFER; lpValueName[0] = L'\0'; // Note that the buffer we will ask for (below) // can be bigger than necessary for the DBCS case. *lpcbValueName = cbValueName * sizeof(WCHAR); } else if(lpData && lpcbData) { switch(dwType) { case REG_SZ: case REG_EXPAND_SZ: case REG_MULTI_SZ: { // we got the size already, so lets use it LPSTR lpDataAnsi = GodotHeapAlloc(cbData); if(lpDataAnsi==NULL) { return(ERROR_OUTOFMEMORY); } RetVal = RegEnumValueA(hKey, dwIndex, szValue, &cbValueName, lpReserved, &dwType, (LPBYTE)lpDataAnsi, &cbData); if(dwType==REG_MULTI_SZ) { DWORD cchData = GrszToGrwz(lpDataAnsi, (LPWSTR)lpData, *lpcbData/sizeof(WCHAR)); // If they did not give us enough buffer, tell them! if ((*lpcbData > 0) && (cchData > *lpcbData/sizeof(WCHAR))) RetVal = ERROR_MORE_DATA; *lpcbData = cchData * sizeof(WCHAR); } else { LPWSTR lpDataT; _STACKALLOC(cbData * sizeof(WCHAR), lpDataT); MultiByteToWideChar(g_acp, 0, lpDataAnsi, cbData, lpDataT, cbData); cbData = gwcslen(lpDataT) * sizeof(WCHAR); if (cbData > *lpcbData) { // If they did not give us enough buffer, tell them! if(*lpcbData > 0) RetVal = ERROR_MORE_DATA; } else { RetVal = ERROR_SUCCESS; memcpy(lpData, lpDataT, cbData); } *lpcbData = cbData; } GodotHeapFree(lpDataAnsi); break; } default: { // some non-string type of data: the name has // been done, let the API do all of the rest now. RetVal = RegEnumValueA(hKey, dwIndex, szValue, &cbValueName, lpReserved, lpType, lpData, lpcbData); break; } } } } // Finished return RetVal; } End= [EFunc] TemplateName=RegisterDeviceNotificationW Begin= HDEVNOTIFY __stdcall GodotRegisterDeviceNotificationW(HANDLE hRecipient, LPVOID NotificationFilter, DWORD Flags) { // Begin locals HDEVNOTIFY RetVal = NULL; __try { if (s_pfnRegisterDeviceNotificationA == NULL) { // Must allocate stuff for this API call s_pfnRegisterDeviceNotificationA = (PFNrdna)GetUserProc("RegisterDeviceNotificationA"); } if (s_pfnRegisterDeviceNotificationA) { size_t NameLength; PDEV_BROADCAST_HDR dbh = NotificationFilter; if (dbh->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) { PDEV_BROADCAST_DEVICEINTERFACE_A dbdia; PDEV_BROADCAST_DEVICEINTERFACE_W dbdiw = NotificationFilter; _STACKALLOC(sizeof(DEV_BROADCAST_DEVICEINTERFACE_A), dbdia); if(dbdia==NULL) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } ZeroMemory(dbdia, sizeof(DEV_BROADCAST_DEVICEINTERFACE_A)); dbdia->dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE_A); dbdia->dbcc_devicetype = dbdiw->dbcc_devicetype; dbdia->dbcc_reserved = dbdiw->dbcc_reserved; dbdia->dbcc_classguid = dbdiw->dbcc_classguid; NameLength = gwcslen(dbdiw->dbcc_name); *(char **)(dbdia->dbcc_name) = _alloca(NameLength); WideCharToMultiByte(g_acp, 0, dbdiw->dbcc_name, NameLength, dbdia->dbcc_name, NameLength, NULL, NULL); RetVal = (s_pfnRegisterDeviceNotificationA (hRecipient, dbdia, Flags)); } else if(dbh->dbch_devicetype == DBT_DEVTYP_PORT) { PDEV_BROADCAST_PORT_A dbpa; PDEV_BROADCAST_PORT_W dbpw = NotificationFilter; _STACKALLOC(sizeof(DEV_BROADCAST_PORT_A), dbpa); if(dbpa==NULL) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } ZeroMemory(dbpa, sizeof(DEV_BROADCAST_PORT_A)); dbpa->dbcp_size = sizeof(DEV_BROADCAST_PORT_A); dbpa->dbcp_devicetype = dbpw->dbcp_devicetype; dbpa->dbcp_reserved = dbpw->dbcp_reserved; NameLength = gwcslen(dbpw->dbcp_name); *(char **)(dbpa->dbcp_name) = _alloca(NameLength); WideCharToMultiByte(g_acp, 0, dbpw->dbcp_name, NameLength, dbpa->dbcp_name, NameLength, NULL, NULL); RetVal = (s_pfnRegisterDeviceNotificationA (hRecipient, dbpa, Flags)); } else { // No changes needed! There are no strings in the other structures. RetVal = (s_pfnRegisterDeviceNotificationA (hRecipient, NotificationFilter, Flags)); } } else SetLastError(ERROR_CALL_NOT_IMPLEMENTED); } __except( EXCEPTION_EXECUTE_HANDLER ) { gresetstkoflw(); SetLastError(ERROR_STACK_OVERFLOW); RetVal = 0; } // Finished return RetVal; } End= [EFunc] TemplateName=RegQueryInfoKeyW Begin= LONG __stdcall GodotRegQueryInfoKeyW( HKEY hKey, LPWSTR lpClass, LPDWORD lpcbClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcbMaxSubKeyLen, LPDWORD lpcbMaxClassLen, LPDWORD lpcValues, LPDWORD lpcbMaxValueNameLen, LPDWORD lpcbMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime ) { // Call the 'A' version of the API: Since there are no defined classess, we will // conveniently ignore the param, thus giving us nothing to convert! // We will pass the class and cbClass as is so that the API can validate for us. return(RegQueryInfoKeyA(hKey, (LPSTR)lpClass, lpcbClass, lpReserved, lpcSubKeys, lpcbMaxSubKeyLen, lpcbMaxClassLen, lpcValues, lpcbMaxValueNameLen, lpcbMaxValueLen, lpcbSecurityDescriptor, lpftLastWriteTime )); } End= [EFunc] TemplateName=RegQueryMultipleValuesW Begin= // Max size for reg keys and values on Win9x #define MAXREGKEYVALUESIZE 256 LONG __stdcall GodotRegQueryMultipleValuesW( HKEY hKey, PVALENTW val_list, DWORD num_vals, LPWSTR lpValueBuf, LPDWORD ldwTotsize ) { LPSTR lpValueBufA = NULL; PVALENTA val_listA = NULL; LPSTR rgszNames = NULL; LPSTR szName; DWORD cchValue; DWORD cbName; LPDWORD pdwTotsize; DWORD dwTotsize; DWORD dwOffset; UINT i; LONG RetVal; // Begin precall: we alloc on the heap here because NT does and // because people can ask for a whole lot of memory! // Alloc the space for the registry value information val_listA = GodotHeapAlloc(sizeof(VALENTA) * num_vals); if(val_listA == NULL) { RetVal = ERROR_OUTOFMEMORY; goto Cleanup; } // Alloc the space for the registry names rgszNames = GodotHeapAlloc(MAXREGKEYVALUESIZE * num_vals); if(rgszNames == NULL) { RetVal = ERROR_OUTOFMEMORY; goto Cleanup; } // Copy over their VALENTW info into our VALENTA, grabbing memory // for the value names as needed. szName = rgszNames; dwOffset = 0; for (i=0; i *lpcbData) { // If they passed a NULL buffer size, then we simply // tell them we succeeded, otherwise we have to tell // them there is more data if(*lpcbData != 0) RetVal = ERROR_MORE_DATA; } else if(lpData) { MultiByteToWideChar(g_acp, 0, lpDataA, cbData*g_mcs, (LPWSTR)lpData, cbData); } *lpcbData = cbNeeded; break; } default: // some non-string type of data, see if there is enough room; // if there is, go for it (copy the length either way) if(*lpcbData < cbData) RetVal = ERROR_MORE_DATA; else if(lpData) RetVal = RegQueryValueExA(hKey, lpValueNameAnsi, lpReserved, lpType, lpData, lpcbData); *lpcbData = cbData; break; } } // Finished return RetVal; } End= [EFunc] TemplateName=RegisterClassW Begin= ATOM __stdcall GodotRegisterClassW(const WNDCLASSW * lpWndClass) { // Begin locals WNDCLASSA wca; // Begin precall ZeroMemory(&wca, sizeof(WNDCLASSA)); memcpy(&wca, lpWndClass, sizeof(UINT)+sizeof(WNDPROC)+2*sizeof(int)+4*sizeof(HANDLE)); GODOT_TO_ACP_STACKALLOC(lpWndClass->lpszMenuName, wca.lpszMenuName); GODOT_TO_ACP_STACKALLOC(lpWndClass->lpszClassName, wca.lpszClassName); // Call the 'A' version of the API return(RegisterClassA(&wca)); } End= [EFunc] TemplateName=RegisterClassExW Begin= ATOM __stdcall GodotRegisterClassExW(const WNDCLASSEXW * lpwcx) { // Begin locals WNDCLASSEXA wcxa; // Begin precall ZeroMemory(&wcxa, sizeof(WNDCLASSEXA)); memcpy(&wcxa, lpwcx, 2*sizeof(UINT)+sizeof(WNDPROC)+2*sizeof(int)+4*sizeof(HANDLE)); GODOT_TO_ACP_STACKALLOC(lpwcx->lpszMenuName, wcxa.lpszMenuName); GODOT_TO_ACP_STACKALLOC(lpwcx->lpszClassName, wcxa.lpszClassName); wcxa.hIconSm = lpwcx->hIconSm; // Call the 'A' version of the API return(RegisterClassExA(&wcxa)); } End= [EFunc] TemplateName=RegSetValueExW Begin= LONG __stdcall GodotRegSetValueExW( HKEY hKey, LPCWSTR lpValueName, DWORD Reserved, DWORD dwType, const BYTE * lpData, DWORD cbData ) { // Begin locals LONG RetVal; LPSTR lpValueNameAnsi; BYTE * lpDataAnsi = NULL; size_t cchData; // Begin precall GODOT_TO_ACP_STACKALLOC(lpValueName, lpValueNameAnsi); if(!lpValueNameAnsi && lpValueName) return(ERROR_STACK_OVERFLOW); switch (dwType) { case REG_MULTI_SZ: case REG_SZ: case REG_EXPAND_SZ: { size_t cbDataAnsi; if (FSTRING_VALID((LPWSTR)lpData)) { // Lets go for the minimal buffer we can reasonably get away with if(dwType == REG_MULTI_SZ) cchData = cchUnicodeMultiSz((LPWSTR)lpData) +1; else cchData = gwcslen((LPWSTR)lpData) + 1; // Convert the information to ANSI and call the API with it _STACKALLOC((cchData * g_mcs) + 1, lpDataAnsi); if(lpDataAnsi==NULL) { return(ERROR_STACK_OVERFLOW); } ZeroMemory(lpDataAnsi, (cchData * g_mcs) + 1); WideCharToMultiByte(g_acp, 0, (LPWSTR)lpData, cchData, (LPSTR)lpDataAnsi, (cchData * g_mcs), NULL, NULL); if(dwType == REG_MULTI_SZ) cbDataAnsi = cbAnsiMultiSz((LPSTR)lpDataAnsi); else cbDataAnsi = lstrlenA((LPSTR)lpDataAnsi); RetVal=RegSetValueExA(hKey, lpValueNameAnsi, Reserved, dwType, lpDataAnsi, cbDataAnsi); } else RetVal = ERROR_INVALID_PARAMETER; break; } default: { // Unknown data, just call straight through. RetVal=RegSetValueExA(hKey, lpValueNameAnsi, Reserved, dwType, lpData, cbData); break; } } // Finished return RetVal; } End= [EFunc] TemplateName=RemoveDirectoryW Begin= BOOL __stdcall GodotRemoveDirectoryW(LPCWSTR lpPathName) { LPSTR lpPathNameAnsi; // Begin precall GODOT_TO_CPG_STACKALLOC(lpPathName, lpPathNameAnsi, FILES_CPG, g_mcs); if(lpPathNameAnsi==NULL) { return(FALSE); } return(RemoveDirectoryA(lpPathNameAnsi)); } End= [EFunc] TemplateName=RemovePropA Begin= HANDLE __stdcall GodotRemovePropA(HWND hWnd, LPCSTR lpString) { if(IsInternalWindowProperty((LPWSTR)lpString, FALSE)) return(0); return(RemovePropA(hWnd, lpString)); } End= [EFunc] TemplateName=RemovePropW Begin= HANDLE __stdcall GodotRemovePropW(HWND hWnd, LPCWSTR lpString) { LPSTR lpStringAnsi; if(IsInternalWindowProperty(lpString, TRUE)) return(0); GODOT_TO_ACP_STACKALLOC(lpString, lpStringAnsi); if(!lpStringAnsi && lpString) return(0); return(RemovePropA(hWnd, lpStringAnsi)); } End= [EFunc] TemplateName=ReplaceTextW Begin= HWND __stdcall GodotReplaceTextW(LPFINDREPLACEW lpfr) { return(FindReplaceTextHelper(lpfr, FALSE)); } End= [EFunc] TemplateName=ResetDCW Begin= HDC __stdcall GodotResetDCW(HDC hdc, DEVMODEW * lpInitData) { LPDEVMODEA lpdma; _STACKALLOC(sizeof(DEVMODEA) + (lpInitData ? lpInitData->dmDriverExtra : 0), lpdma); if(lpdma==NULL) { return(0); } ZeroMemory(lpdma, sizeof(DEVMODEA) + (lpInitData ? lpInitData->dmDriverExtra : 0)); if(lpInitData) DevModeAfromW(lpdma, lpInitData); return(ResetDCA(hdc, lpdma)); } End= [EFunc] TemplateName=ResetPrinterW Begin= BOOL __stdcall GodotResetPrinterW(HANDLE hPrinter, LPPRINTER_DEFAULTSW pDefault) { PRINTER_DEFAULTSA pda; LPDEVMODEW lpdmW; BOOL RetVal = FALSE; // Begin precall ZeroMemory(&pda, sizeof(PRINTER_DEFAULTSA)); lpdmW = pDefault->pDevMode; pda.pDevMode = GodotHeapAlloc(sizeof(DEVMODEA) + lpdmW->dmDriverExtra); if(pda.pDevMode) { ZeroMemory(pda.pDevMode, sizeof(DEVMODEA) + lpdmW->dmDriverExtra); DevModeAfromW(pda.pDevMode, lpdmW); GODOT_TO_ACP_STACKALLOC(pDefault->pDatatype, pda.pDatatype); RetVal = ResetPrinterA(hPrinter, &pda); GodotHeapFree(pda.pDevMode); } else SetLastError(ERROR_OUTOFMEMORY); return(RetVal); } End= [EFunc] TemplateName=SearchPathW Begin= DWORD __stdcall GodotSearchPathW(LPCWSTR lpPath, LPCWSTR lpFileName, LPCWSTR lpExtension, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR * lpFilePart) { // Begin locals DWORD RetVal; LPSTR lpPathAnsi; LPSTR lpFileNameAnsi; LPSTR lpExtensionAnsi; LPSTR lpBufferAnsi; UINT cpg = FILES_CPG; // Begin precall GODOT_TO_CPG_STACKALLOC(lpPath, lpPathAnsi, cpg, g_mcs); GODOT_TO_CPG_STACKALLOC(lpFileName, lpFileNameAnsi, cpg, g_mcs); GODOT_TO_CPG_STACKALLOC(lpExtension, lpExtensionAnsi, cpg, g_mcs); _STACKALLOC((nBufferLength*g_mcs)+1, lpBufferAnsi); RetVal=SearchPathA(lpPathAnsi, lpFileNameAnsi, lpExtensionAnsi, nBufferLength*g_mcs, lpBufferAnsi, NULL); if(RetVal) { MultiByteToWideChar(cpg, 0, lpBufferAnsi, nBufferLength*g_mcs, lpBuffer, nBufferLength); if(lpFilePart) { WCHAR drive[_MAX_DRIVE]; WCHAR dir[_MAX_DIR]; // We do not bother with an ANSI version of lpFilePart and just derive it here // (even non-technical folks like CWissink can contribute now and then!) gwsplitpath(lpBuffer, drive, dir, NULL, NULL); *lpFilePart = lpBuffer + gwcslen(drive) + gwcslen(dir); } } // Finished return RetVal; } End= [EFunc] TemplateName=SendDlgItemMessageW Begin= LRESULT __stdcall GodotSendDlgItemMessageW(HWND hDlg, int nIDDlgItem, UINT Msg, WPARAM wParam, LPARAM lParam) { HWND hWnd = GetDlgItem(hDlg, nIDDlgItem); // if the GetDlgItem fails, we will leave SetLastError alone (it // will probably be ERROR_CONTROL_ID_NOT_FOUND anyway). if (hWnd) { // Rather than going through SendDlgItemMessageA, we just // do what the system does, and pretend we are SendMessage. // Saves us some special casing in GodotTransmitMessage return(GodotTransmitMessage(mtSendMessage, hWnd, Msg, wParam, lParam, 0, 0, 0, 0, 0, 0)); } return(0); } End= [EFunc] TemplateName=SendMessageW Begin= LRESULT __stdcall GodotSendMessageW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) { return(GodotTransmitMessage(mtSendMessage, hWnd, Msg, wParam, lParam, 0, 0, 0, 0, 0, 0)); } End= [EFunc] TemplateName=SendMessageCallbackW Begin= BOOL __stdcall GodotSendMessageCallbackW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, SENDASYNCPROC lpResultCallBack, ULONG_PTR dwData) { return(GodotTransmitMessage(mtSendMessageCallback, hWnd, Msg, wParam, lParam, 0, lpResultCallBack, dwData, 0, 0, 0)); } End= [EFunc] TemplateName=SendMessageTimeoutW Begin= LRESULT __stdcall GodotSendMessageTimeoutW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT fuFlags, UINT uTimeout, PDWORD_PTR lpdwResult) { return(GodotTransmitMessage(mtSendMessageTimeout, hWnd, Msg, wParam, lParam, 0, 0, 0, fuFlags, uTimeout, lpdwResult)); } End= [EFunc] TemplateName=SendNotifyMessageW Begin= BOOL __stdcall GodotSendNotifyMessageW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) { return(GodotTransmitMessage(mtSendNotifyMessage, hWnd, Msg, wParam, lParam, 0, 0, 0, 0, 0, 0)); } End= [EFunc] TemplateName=SetCalendarInfoW Begin= BOOL __stdcall GodotSetCalendarInfoW(LCID Locale, CALID Calendar, CALTYPE CalType, LPCWSTR lpCalData) { if (s_pfnSetCalendarInfoA == NULL) { // Must allocate stuff for this API call s_pfnSetCalendarInfoA = (PFNscia)GetKernelProc("SetCalendarInfoA"); } if (s_pfnSetCalendarInfoA) { LPSTR lpCalDataAnsi; UINT cpg; UINT mcs; if(CalType & CAL_USE_CP_ACP) { cpg = g_acp; mcs = g_mcs; } else { cpg = CpgFromLocale(Locale); mcs = CbPerChOfCpg(cpg); } GODOT_TO_CPG_STACKALLOC(lpCalData, lpCalDataAnsi, cpg, mcs); return((s_pfnSetCalendarInfoA (Locale, Calendar, CalType, lpCalDataAnsi))); } SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return FALSE; } End= [EFunc] TemplateName=SetClassLongW Begin= DWORD __stdcall GodotSetClassLongW(HWND hWnd, int nIndex, LONG dwNewLong) { DWORD RetVal; if(nIndex != GCL_MENUNAME) RetVal=SetClassLongA(hWnd, nIndex, dwNewLong); else { LPSTR szNewLong; GODOT_TO_ACP_STACKALLOC(dwNewLong, szNewLong); RetVal=SetClassLongA(hWnd, nIndex, (DWORD)szNewLong); if(RetVal) { // We need to convert this string to Unicode and stick it in // our global buffer, then return the pointer to that buffer. // See comments at the dec. of m_wzMenuName for why things // have to be done this way. MultiByteToWideChar(g_acp, 0, (LPSTR)RetVal, -1, m_wzMenuName, 256); RetVal = (DWORD)m_wzMenuName; } } return RetVal; } End= [EFunc] TemplateName=SetConsoleTitleW Begin= BOOL __stdcall GodotSetConsoleTitleW(LPCWSTR lpConsoleTitle) { LPSTR lpConsoleTitleAnsi; GODOT_TO_CPG_STACKALLOC(lpConsoleTitle, lpConsoleTitleAnsi, g_oemcp, g_mcs); return(SetConsoleTitleA(lpConsoleTitleAnsi)); } End= [EFunc] TemplateName=SetCurrentDirectoryW Begin= BOOL __stdcall GodotSetCurrentDirectoryW(LPCWSTR lpPathName) { LPSTR lpPathNameAnsi; // Begin precall GODOT_TO_CPG_STACKALLOC(lpPathName, lpPathNameAnsi, FILES_CPG, g_mcs); return(SetCurrentDirectoryA(lpPathNameAnsi)); } End= [EFunc] TemplateName=SetJobW Begin= BOOL __stdcall GodotSetJobW(HANDLE hPrinter, DWORD JobId, DWORD Level, LPBYTE pJob, DWORD Command) { switch(Level) { case 0: return(SetJobA(hPrinter, JobId, Level, pJob, Command)); break; case 1: { JOB_INFO_1A ji1a; LPJOB_INFO_1W lpji1 = (LPJOB_INFO_1W)pJob; ji1a.JobId = lpji1->JobId; GODOT_TO_ACP_STACKALLOC(lpji1->pPrinterName, ji1a.pPrinterName); GODOT_TO_ACP_STACKALLOC(lpji1->pMachineName, ji1a.pMachineName); GODOT_TO_ACP_STACKALLOC(lpji1->pUserName, ji1a.pUserName); GODOT_TO_ACP_STACKALLOC(lpji1->pDocument, ji1a.pDocument); GODOT_TO_ACP_STACKALLOC(lpji1->pDatatype, ji1a.pDatatype); GODOT_TO_ACP_STACKALLOC(lpji1->pStatus, ji1a.pStatus); ji1a.Status = lpji1->Status; ji1a.Priority = lpji1->Priority; ji1a.Position = lpji1->Position; ji1a.TotalPages = lpji1->TotalPages; ji1a.PagesPrinted = lpji1->PagesPrinted; ji1a.Submitted = lpji1->Submitted; return(SetJobA(hPrinter, JobId, Level, (LPBYTE)&ji1a, Command)); } case 2: { JOB_INFO_2A ji2a; LPJOB_INFO_2W lpji2 = (LPJOB_INFO_2W)pJob; BOOL RetVal = FALSE; ji2a.JobId = lpji2->JobId; GODOT_TO_ACP_STACKALLOC(lpji2->pPrinterName, ji2a.pPrinterName); GODOT_TO_ACP_STACKALLOC(lpji2->pMachineName, ji2a.pMachineName); GODOT_TO_ACP_STACKALLOC(lpji2->pUserName, ji2a.pUserName); GODOT_TO_ACP_STACKALLOC(lpji2->pNotifyName, ji2a.pNotifyName); GODOT_TO_ACP_STACKALLOC(lpji2->pDocument, ji2a.pDocument); GODOT_TO_ACP_STACKALLOC(lpji2->pDatatype, ji2a.pDatatype); GODOT_TO_ACP_STACKALLOC(lpji2->pPrintProcessor, ji2a.pPrintProcessor); GODOT_TO_ACP_STACKALLOC(lpji2->pParameters, ji2a.pParameters); GODOT_TO_ACP_STACKALLOC(lpji2->pDriverName, ji2a.pDriverName); GODOT_TO_ACP_STACKALLOC(lpji2->pStatus, ji2a.pStatus); ji2a.pSecurityDescriptor = lpji2->pSecurityDescriptor; ji2a.Status = lpji2->Status; ji2a.Priority = lpji2->Priority; ji2a.Position = lpji2->Position; ji2a.StartTime = lpji2->StartTime; ji2a.UntilTime = lpji2->UntilTime; ji2a.TotalPages = lpji2->TotalPages; ji2a.Size = lpji2->Size; ji2a.Submitted = lpji2->Submitted; ji2a.Time = lpji2->Time; ji2a.PagesPrinted = lpji2->PagesPrinted; if(lpji2->pDevMode) { ji2a.pDevMode = GodotHeapAlloc(sizeof(DEVMODEA) + lpji2->pDevMode->dmDriverExtra); if(ji2a.pDevMode==NULL) { SetLastError(ERROR_OUTOFMEMORY); return(FALSE); } ZeroMemory(ji2a.pDevMode, sizeof(DEVMODEA) + lpji2->pDevMode->dmDriverExtra); DevModeAfromW(ji2a.pDevMode, lpji2->pDevMode); } RetVal = SetJobA(hPrinter, JobId, Level, (LPBYTE)&ji2a, Command); if(lpji2->pDevMode && ji2a.pDevMode) GodotHeapFree(ji2a.pDevMode); return(RetVal); break; } default: { SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); break; } } } End= [EFunc] TemplateName=SetLocaleInfoW Begin= BOOL __stdcall GodotSetLocaleInfoW(LCID Locale, LCTYPE LCType, LPCWSTR lpLCData) { LPSTR lpLCDataAnsi; UINT cpg; UINT mcs; // Begin precall if (LCType & LOCALE_USE_CP_ACP) { // Win9x accepts LOCALE_USE_CP_ACP, so we need to treat the // flag properly and use it for any/all mapping if the user // requests it. cpg = g_acp; mcs = g_mcs; } else { cpg = CpgFromLocale(Locale); mcs = CbPerChOfCpg(cpg); } GODOT_TO_CPG_STACKALLOC(lpLCData, lpLCDataAnsi, cpg, mcs); if(lpLCDataAnsi==NULL) { return(FALSE); } return(SetLocaleInfoA(Locale, LCType, lpLCDataAnsi)); } End= [EFunc] TemplateName=SetMenuItemInfoW Begin= BOOL __stdcall GodotSetMenuItemInfoW(HMENU hMenu, UINT uItem, BOOL fByPosition, LPCMENUITEMINFOW lpmiiw) { MENUITEMINFOA miia; BOOL RetVal; BOOL fAlloc = MenuItemInfoAfromW(&miia, lpmiiw); RetVal = SetMenuItemInfoA(hMenu, uItem, fByPosition, &miia); if(fAlloc) GodotHeapFree(miia.dwTypeData); return(RetVal); } End= [EFunc] TemplateName=SetPrinterW Begin= BOOL __stdcall GodotSetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD Command) { switch(Level) { case 0: { return(SetPrinterA(hPrinter, Level, pPrinter, Command)); break; } case 2: { PRINTER_INFO_2A pi2a; LPPRINTER_INFO_2W lppi2 = (LPPRINTER_INFO_2W)pPrinter; BOOL RetVal = FALSE; GODOT_TO_ACP_STACKALLOC(lppi2->pServerName, pi2a.pServerName); GODOT_TO_ACP_STACKALLOC(lppi2->pPrinterName, pi2a.pPrinterName); GODOT_TO_ACP_STACKALLOC(lppi2->pShareName, pi2a.pShareName); GODOT_TO_ACP_STACKALLOC(lppi2->pPortName, pi2a.pPortName); GODOT_TO_ACP_STACKALLOC(lppi2->pDriverName, pi2a.pDriverName); GODOT_TO_ACP_STACKALLOC(lppi2->pComment, pi2a.pComment); GODOT_TO_ACP_STACKALLOC(lppi2->pLocation, pi2a.pLocation); if((!pi2a.pServerName && lppi2->pServerName) || (!pi2a.pPrinterName && lppi2->pPrinterName) || (!pi2a.pShareName && lppi2->pShareName) || (!pi2a.pPortName && lppi2->pPortName) || (!pi2a.pDriverName && lppi2->pDriverName) || (!pi2a.pComment && lppi2->pComment) || (!pi2a.pLocation && lppi2->pLocation)) { return(FALSE); } GODOT_TO_ACP_STACKALLOC(lppi2->pSepFile, pi2a.pSepFile); GODOT_TO_ACP_STACKALLOC(lppi2->pPrintProcessor, pi2a.pPrintProcessor); GODOT_TO_ACP_STACKALLOC(lppi2->pDatatype, pi2a.pDatatype); GODOT_TO_ACP_STACKALLOC(lppi2->pParameters, pi2a.pParameters); if((!pi2a.pSepFile && lppi2->pSepFile) || (!pi2a.pPrintProcessor && lppi2->pPrintProcessor) || (!pi2a.pDatatype && lppi2->pDatatype) || (!pi2a.pParameters && lppi2->pParameters)) { return(FALSE); } pi2a.pSecurityDescriptor = lppi2->pSecurityDescriptor; pi2a.Attributes = lppi2->Attributes; pi2a.Priority = lppi2->Priority; pi2a.DefaultPriority = lppi2->DefaultPriority; pi2a.StartTime = lppi2->StartTime; pi2a.UntilTime = lppi2->UntilTime; pi2a.Status = lppi2->Status; pi2a.cJobs = lppi2->cJobs; pi2a.AveragePPM = lppi2->AveragePPM; if(lppi2->pDevMode) { pi2a.pDevMode = GodotHeapAlloc(sizeof(DEVMODEA) + lppi2->pDevMode->dmDriverExtra); if(pi2a.pDevMode==NULL) { SetLastError(ERROR_OUTOFMEMORY); return(FALSE); } ZeroMemory(pi2a.pDevMode, sizeof(DEVMODEA) + lppi2->pDevMode->dmDriverExtra); DevModeAfromW(pi2a.pDevMode, lppi2->pDevMode); } RetVal = SetPrinterA(hPrinter, Level, (LPBYTE)&pi2a, Command); if(lppi2->pDevMode && pi2a.pDevMode) GodotHeapFree(pi2a.pDevMode); return(RetVal); break; } case 5: { PRINTER_INFO_5A pi5a; LPPRINTER_INFO_5W lppi5 = (LPPRINTER_INFO_5W)pPrinter; GODOT_TO_ACP_STACKALLOC(lppi5->pPrinterName, pi5a.pPrinterName); GODOT_TO_ACP_STACKALLOC(lppi5->pPortName, pi5a.pPortName); if((!pi5a.pPrinterName && lppi5->pPrinterName) || (!pi5a.pPortName && lppi5->pPortName)) { return(FALSE); } pi5a.Attributes = lppi5->Attributes; pi5a.DeviceNotSelectedTimeout = lppi5->DeviceNotSelectedTimeout; pi5a.TransmissionRetryTimeout = lppi5->TransmissionRetryTimeout; return(SetPrinterA(hPrinter, Level, (LPBYTE)&pi5a, Command)); break; } default: { SetLastError(ERROR_INVALID_PARAMETER); return(FALSE); break; } } } End= [EFunc] TemplateName=SetPrinterDataW Begin= DWORD __stdcall GodotSetPrinterDataW(HANDLE hPrinter, LPWSTR pValueName, DWORD Type, LPBYTE pData, DWORD cbData) { LPSTR pValueNameAnsi; LPSTR pDataAnsi; size_t cchData; GODOT_TO_ACP_STACKALLOC(pValueName, pValueNameAnsi); if(!pValueNameAnsi && pValueName) return(0); switch(Type) { case REG_MULTI_SZ: if (FSTRING_VALID((LPWSTR)pData)) { // Lets go for the minimal buffer we can reasonably get away with cchData = gwcslen((LPWSTR)pData); // Convert the information to ANSI and call the API with it _STACKALLOC((cchData * g_mcs) + 1, pDataAnsi); if(!pDataAnsi) { return(ERROR_STACK_OVERFLOW); } ZeroMemory(pDataAnsi, (cchData * g_mcs) + 1); WideCharToMultiByte(g_acp, 0, (LPWSTR)pData, (cbData / sizeof(WCHAR)), pDataAnsi, (cchData * g_mcs) + 1, NULL, NULL); } else pDataAnsi = (LPSTR)pData; return(SetPrinterDataA(hPrinter, pValueNameAnsi, Type, (LPBYTE)pDataAnsi, lstrlenA(pDataAnsi))); break; case REG_SZ: case REG_EXPAND_SZ: if (FSTRING_VALID((LPWSTR)pData)) { // Lets go for the minimal buffer we can reasonably get away with cchData = cchUnicodeMultiSz((LPWSTR)pData); // Convert the information to ANSI and call the API with it _STACKALLOC((cchData * g_mcs) + 1, pDataAnsi); if(pDataAnsi==NULL) { return(0); } WideCharToMultiByte(g_acp, 0, (LPWSTR)pData, (cbData / sizeof(WCHAR)), (LPSTR)pDataAnsi, (cchData * g_mcs), NULL, NULL); } else pDataAnsi = (LPSTR)pData; return(SetPrinterDataA(hPrinter, pValueNameAnsi, Type, (LPBYTE)pDataAnsi, cbAnsiMultiSz(pDataAnsi))); break; default: return(SetPrinterDataA(hPrinter, pValueNameAnsi, Type, pData, cbData)); break; } } End= [EFunc] TemplateName=SetPropA Begin= BOOL __stdcall GodotSetPropA(HWND hWnd, LPCSTR lpString, HANDLE hData) { if(IsInternalWindowProperty((LPWSTR)lpString, FALSE)) return(FALSE); return(SetPropA(hWnd, lpString, hData)); } End= [EFunc] TemplateName=SetPropW Begin= BOOL __stdcall GodotSetPropW(HWND hWnd, LPCWSTR lpString, HANDLE hData) { LPSTR lpStringAnsi; if(IsInternalWindowProperty(lpString, TRUE)) return(FALSE); GODOT_TO_ACP_STACKALLOC(lpString, lpStringAnsi); if(!lpStringAnsi && lpString) return(0); return(SetPropA(hWnd, lpStringAnsi, hData)); } End= [EFunc] TemplateName=SetVolumeLabelW Begin= BOOL __stdcall GodotSetVolumeLabelW(LPCWSTR lpRootPathName, LPCWSTR lpVolumeName) { LPSTR lpRootPathNameAnsi; LPSTR lpVolumeNameAnsi; UINT cpg = FILES_CPG; // Begin precall GODOT_TO_CPG_STACKALLOC(lpRootPathName, lpRootPathNameAnsi, cpg, g_mcs); GODOT_TO_CPG_STACKALLOC(lpVolumeName, lpVolumeNameAnsi, cpg, g_mcs); return(SetVolumeLabelA(lpRootPathNameAnsi, lpVolumeNameAnsi)); } End= [EFunc] TemplateName=SetWindowsHookA Begin= HHOOK __stdcall GodotSetWindowsHookA(int nFilterType, HOOKPROC pfnFilterProc) { // CONSIDER: Support Hook functions? This is a tough one! // This [EFunc] is not even hooked up at the moment. return(SetWindowsHookA(nFilterType, pfnFilterProc)); } End= [EFunc] TemplateName=SetWindowsHookW Begin= HHOOK __stdcall GodotSetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc) { // CONSIDER: Support Hook functions? This is a tough one! return(SetWindowsHookA(nFilterType, pfnFilterProc)); } End= [EFunc] TemplateName=SetWindowsHookExA Begin= HHOOK __stdcall GodotSetWindowsHookExA(int idHook, HOOKPROC lpfn, HINSTANCE hmod, DWORD dwThreadId) { // CONSIDER: Support Hook functions? This is a tough one! // This [EFunc] is not even hooked up at the moment. return(SetWindowsHookExA(idHook, lpfn, hmod, dwThreadId)); } End= [EFunc] TemplateName=SetWindowsHookExW Begin= HHOOK __stdcall GodotSetWindowsHookExW(int idHook, HOOKPROC lpfn, HINSTANCE hmod, DWORD dwThreadId) { // CONSIDER: Support Hook functions? This is a tough one! return(SetWindowsHookExA(idHook, lpfn, hmod, dwThreadId)); } End= [EFunc] TemplateName=SetWindowLongA Begin= LONG __stdcall GodotSetWindowLongA(HWND hWnd, int nIndex, LONG dwNewLong) { return(SetWindowLongInternal(hWnd, nIndex, dwNewLong, FALSE)); } End= [EFunc] TemplateName=SetWindowLongW Begin= LONG __stdcall GodotSetWindowLongW(HWND hWnd, int nIndex, LONG dwNewLong) { return(SetWindowLongInternal(hWnd, nIndex, dwNewLong, TRUE)); } End= [EFunc] TemplateName=SetWindowTextW Begin= BOOL __stdcall GodotSetWindowTextW(HWND hWnd, LPCWSTR lpString) { BOOL RetVal; LPSTR lpStringAnsi = NULL; ALLOCRETURN ar = GodotToAcpOnHeap(lpString, &lpStringAnsi); if(ar==arFailed) RetVal = FALSE; else RetVal = SetWindowTextA(hWnd, lpStringAnsi); if(ar==arAlloc) GodotHeapFree(lpStringAnsi); return(RetVal); } End= [EFunc] TemplateName=ShellAboutW Begin= INT __stdcall GodotShellAboutW(HWND hWnd, LPCWSTR szApp, LPCWSTR szOtherStuff, HICON hIcon) { LPSTR szAppAnsi; LPSTR szOtherStuffAnsi; GODOT_TO_ACP_STACKALLOC(szApp, szAppAnsi); GODOT_TO_ACP_STACKALLOC(szOtherStuff, szOtherStuffAnsi); if((!szAppAnsi && szApp) || (!szOtherStuffAnsi && szOtherStuff)) return(0); return(ShellAboutA(hWnd, szAppAnsi, szOtherStuffAnsi, hIcon)); } End= [EFunc] TemplateName=SHChangeNotify Begin= // uFlags & SHCNF_TYPE is an ID which indicates what dwItem1 and dwItem2 mean #define SHCNF_IDLIST 0x0000 // LPITEMIDLIST #define SHCNF_PATHA 0x0001 // path name #define SHCNF_PRINTERA 0x0002 // printer friendly name #define SHCNF_DWORD 0x0003 // DWORD #define SHCNF_PRINTJOBA 0x0004 // dwItem1: printer name // dwItem2: SHCNF_PRINTJOB_DATA #define SHCNF_PATHW 0x0005 // path name #define SHCNF_PRINTERW 0x0006 // printer friendly name #define SHCNF_PRINTJOBW 0x0007 // dwItem1: printer name // dwItem2: SHCNF_PRINTJOB_DATA #define SHCNF_TYPE 0x00FF #define SHCNF_FLUSH 0x1000 #define SHCNF_FLUSHNOWAIT 0x2000 #define SHCNF_HAS_WSTR_PARAMS(f) ((f & SHCNF_TYPE) == SHCNF_PATHW || \ (f & SHCNF_TYPE) == SHCNF_PRINTERW || \ (f & SHCNF_TYPE) == SHCNF_PRINTJOBW ) void __stdcall GodotSHChangeNotify(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2) { if(!SHCNF_HAS_WSTR_PARAMS(uFlags)) { SHChangeNotify(wEventId, uFlags, dwItem1, dwItem2); } else { LPSTR dwItem1Ansi, dwItem2Ansi; GODOT_TO_ACP_STACKALLOC(dwItem1, dwItem1Ansi); GODOT_TO_ACP_STACKALLOC(dwItem2, dwItem2Ansi); // Munge flags to ANSI types based on // the Unicode types that are there now if ((uFlags & SHCNF_TYPE) == SHCNF_PATHW) { uFlags = (uFlags & ~SHCNF_TYPE) | SHCNF_PATHA; } else if ((uFlags & SHCNF_TYPE) == SHCNF_PRINTERW) { uFlags = (uFlags & ~SHCNF_TYPE) | SHCNF_PRINTERA; } else { uFlags = (uFlags & ~SHCNF_TYPE) | SHCNF_PRINTJOBA; } SHChangeNotify(wEventId, uFlags, (void*)dwItem1Ansi, (void*)dwItem2Ansi); } return ; } End= [EFunc] TemplateName=ShellExecuteW Begin= HINSTANCE __stdcall GodotShellExecuteW( HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd ) { LPSTR lpOperationAnsi, lpFileAnsi, lpParametersAnsi, lpDirectoryAnsi; GODOT_TO_ACP_STACKALLOC(lpOperation, lpOperationAnsi); GODOT_TO_ACP_STACKALLOC(lpFile, lpFileAnsi); GODOT_TO_ACP_STACKALLOC(lpParameters, lpParametersAnsi); GODOT_TO_ACP_STACKALLOC(lpDirectory, lpDirectoryAnsi); if((!lpOperationAnsi && lpOperation) || (!lpFileAnsi && lpFile) || (!lpParametersAnsi && lpParameters) || (!lpDirectoryAnsi && lpDirectory)) return(0); return(ShellExecuteA(hwnd, lpOperationAnsi, lpFileAnsi, lpParametersAnsi, lpDirectoryAnsi, nShowCmd)); } End= [EFunc] TemplateName=ShellExecuteExW Begin= BOOL __stdcall GodotShellExecuteExW(LPSHELLEXECUTEINFOW lpsei) { SHELLEXECUTEINFOA seia; size_t lpFileLength; BOOL RetVal; ZeroMemory(&seia, sizeof(SHELLEXECUTEINFOA)); seia.cbSize = sizeof(SHELLEXECUTEINFOA); seia.fMask = lpsei->fMask; seia.hwnd = lpsei->hwnd; seia.nShow = lpsei->nShow; seia.hInstApp = lpsei->hInstApp; seia.lpIDList = lpsei->lpIDList; seia.hkeyClass = lpsei->hkeyClass; seia.dwHotKey = lpsei->dwHotKey; seia.hIcon = lpsei->hIcon; seia.hProcess = lpsei->hProcess; lpFileLength = cchUnicodeMultiSz(lpsei->lpFile); _STACKALLOC(lpFileLength, seia.lpFile); GODOT_TO_ACP_STACKALLOC(lpsei->lpVerb, seia.lpVerb); GODOT_TO_ACP_STACKALLOC(lpsei->lpParameters, seia.lpParameters); GODOT_TO_ACP_STACKALLOC(lpsei->lpDirectory, seia.lpDirectory); GODOT_TO_ACP_STACKALLOC(lpsei->lpClass, seia.lpClass); WideCharToMultiByte(g_acp, 0, lpsei->lpFile, lpFileLength, (LPSTR)(seia.lpFile), lpFileLength, NULL, NULL); RetVal = ShellExecuteExA(&seia); lpsei->hInstApp = seia.hInstApp; lpsei->hProcess = seia.hProcess; return RetVal; } End= [EFunc] TemplateName=Shell_NotifyIconW Begin= BOOL __stdcall GodotShell_NotifyIconW(DWORD dwMessage, PNOTIFYICONDATAW lpData) { PNOTIFYICONDATAA pnida; if (lpData->cbSize == (UINT)NOTIFYICONDATAW_V1_SIZE) { // Old structure _STACKALLOC(NOTIFYICONDATAA_V1_SIZE, pnida); if(pnida) { ZeroMemory(pnida, NOTIFYICONDATAA_V1_SIZE); pnida->cbSize = NOTIFYICONDATAA_V1_SIZE; } } else { // New structure _STACKALLOC(sizeof(NOTIFYICONDATA), pnida); if(pnida) { ZeroMemory(pnida, sizeof(NOTIFYICONDATA)); pnida->cbSize = sizeof(NOTIFYICONDATA); pnida->dwState = lpData->dwState; pnida->dwStateMask = lpData->dwStateMask; pnida->uTimeout = lpData->uTimeout; pnida->dwInfoFlags = lpData->dwInfoFlags; WideCharToMultiByte(g_acp, 0, lpData->szInfo, 256, pnida->szInfo, 256, NULL, NULL); WideCharToMultiByte(g_acp, 0, lpData->szInfoTitle, 64, pnida->szInfoTitle, 64, NULL, NULL); } } // Members common to both structures if(pnida) { pnida->hWnd = lpData->hWnd; pnida->uID = lpData->uID; pnida->uFlags = lpData->uFlags; pnida->uCallbackMessage = lpData->uCallbackMessage; pnida->hIcon = lpData->hIcon; WideCharToMultiByte(g_acp, 0, lpData->szTip, 64, pnida->szTip, 64, NULL, NULL); // Call the 'A' version of the API return(Shell_NotifyIconA(dwMessage, pnida)); } SetLastError(ERROR_STACK_OVERFLOW); return(FALSE); } End= [EFunc] TemplateName=SHBrowseForFolderW Begin= LPITEMIDLIST _stdcall GodotSHBrowseForFolderW(LPBROWSEINFOW lpbi) { char buf[_MAX_PATH]; BROWSEINFOA bi; LPITEMIDLIST item; bi.hwndOwner = lpbi->hwndOwner; bi.pidlRoot = lpbi->pidlRoot; bi.pszDisplayName = buf; GODOT_TO_ACP_STACKALLOC(lpbi->lpszTitle, bi.lpszTitle); bi.ulFlags = lpbi->ulFlags; bi.lpfn = lpbi->lpfn; bi.lParam = lpbi->lParam; bi.iImage = lpbi->iImage; if(item = SHBrowseForFolderA(&bi)) { MultiByteToWideChar(g_acp, 0, bi.pszDisplayName, -1, lpbi->pszDisplayName, _MAX_PATH); lpbi->iImage = bi.iImage; } return item; } End= [EFunc] TemplateName=SHFileOperationW Begin= int __stdcall GodotSHFileOperationW(LPSHFILEOPSTRUCTW lpFileOp) { SHFILEOPSTRUCTA sfoa; size_t cch; ZeroMemory(&sfoa, sizeof(SHFILEOPSTRUCTA)); sfoa.hwnd = lpFileOp->hwnd; sfoa.wFunc = lpFileOp->wFunc; sfoa.fFlags = lpFileOp->fFlags; sfoa.fAnyOperationsAborted = lpFileOp->fAnyOperationsAborted; sfoa.hNameMappings = lpFileOp->hNameMappings; cch = cchUnicodeMultiSz(lpFileOp->pFrom); if(cch) { _STACKALLOC((cch*g_mcs + 1), sfoa.pFrom); if(!sfoa.pFrom) { SetLastError(ERROR_STACK_OVERFLOW); return(1); } ZeroMemory((LPSTR)sfoa.pFrom, (cch*g_mcs + 1)); WideCharToMultiByte(g_acp, 0, lpFileOp->pFrom, cch, (LPSTR)sfoa.pFrom, cch*g_mcs, NULL, NULL); } cch = cchUnicodeMultiSz(lpFileOp->pTo); if(cch) { _STACKALLOC((cch*g_mcs + 1), sfoa.pTo); if(!sfoa.pTo) { SetLastError(ERROR_STACK_OVERFLOW); return(1); } ZeroMemory((LPSTR)sfoa.pTo, (cch*g_mcs + 1)); WideCharToMultiByte(g_acp, 0, lpFileOp->pTo, cch, (LPSTR)sfoa.pTo, cch*g_mcs, NULL, NULL); } GODOT_TO_ACP_STACKALLOC(lpFileOp->lpszProgressTitle, sfoa.lpszProgressTitle); return(SHFileOperationA(&sfoa)); } End= [EFunc] TemplateName=SHGetFileInfoW Begin= DWORD_PTR __stdcall GodotSHGetFileInfoW(LPCWSTR pszPath, DWORD dwFileAttribs, SHFILEINFOW * psfi, UINT cbFileInfo, UINT uFlags) { // Begin locals DWORD_PTR RetVal; CHAR pszPathAnsi[_MAX_PATH]; SHFILEINFOA sfia; ZeroMemory(&sfia, sizeof(SHFILEINFOA)); // If SHGFI_ATTR_SPECIFIED is among uFlags, dwAttributes is taken from the structure // We simply initialize it in every case (assuming a pointer was supplied) if (psfi) sfia.dwAttributes = psfi->dwAttributes; // If SHGFI_PIDL is specified, pszPath is actually a pointer to an ITEMIDLIST. // Otherwise, convert the string from wide to MBCS if (!(uFlags & SHGFI_PIDL)) { WideCharToMultiByte(g_acp, 0, pszPath, _MAX_PATH, pszPathAnsi, _MAX_PATH, NULL, NULL); RetVal=SHGetFileInfoA(pszPathAnsi, dwFileAttribs, &sfia, sizeof(SHFILEINFOA), uFlags); } else RetVal=SHGetFileInfoA((LPSTR)pszPath, dwFileAttribs, &sfia, sizeof(SHFILEINFOA), uFlags); if (RetVal && psfi) { psfi->hIcon = sfia.hIcon; psfi->iIcon = sfia.iIcon; psfi->dwAttributes = sfia.dwAttributes; if ((uFlags & (SHGFI_DISPLAYNAME | SHGFI_ICONLOCATION)) && sfia.szDisplayName) MultiByteToWideChar(g_acp, 0, sfia.szDisplayName, -1, psfi->szDisplayName, _MAX_PATH); else psfi->szDisplayName[0] = '\0'; if ((uFlags & SHGFI_TYPENAME) && sfia.szTypeName) MultiByteToWideChar(g_acp, 0, sfia.szTypeName, -1, psfi->szTypeName, 80); else psfi->szTypeName[0] = '\0'; } // Finished return RetVal; } End= [EFunc] TemplateName=SHGetNewLinkInfoW Begin= BOOL __stdcall GodotSHGetNewLinkInfoW(LPCWSTR pszLinkTo, LPCWSTR pszDir, LPWSTR pszName, BOOL * pfMustCopy, UINT uFlags) { BOOL RetVal; LPSTR pszDirAnsi; char * pszNameAnsi[_MAX_PATH]; GODOT_TO_ACP_STACKALLOC(pszDir, pszDirAnsi); if(uFlags & SHGNLI_PIDL) RetVal=SHGetNewLinkInfoA((LPCSTR)pszLinkTo, pszDirAnsi, (LPSTR)pszNameAnsi, pfMustCopy, uFlags); else { LPSTR pszLinkToAnsi; GODOT_TO_ACP_STACKALLOC(pszLinkTo, pszLinkToAnsi); RetVal=SHGetNewLinkInfoA(pszLinkToAnsi, pszDirAnsi, (LPSTR)pszNameAnsi, pfMustCopy, uFlags); } if(RetVal) MultiByteToWideChar(g_acp, 0, (LPSTR)pszNameAnsi, -1, pszName, _MAX_PATH); return RetVal; } End= [EFunc] TemplateName=SHGetPathFromIDListW Begin= BOOL __stdcall GodotSHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath) { char buf[_MAX_PATH]; BOOL fRet; if(fRet = SHGetPathFromIDListA(pidl, buf)) { MultiByteToWideChar(g_acp, 0, buf, -1, pszPath, _MAX_PATH); } return fRet; } End= [EFunc] TemplateName=sndPlaySoundW Begin= BOOL __stdcall GodotsndPlaySoundW(LPCWSTR pszSound, UINT fuSound) { BOOL RetVal; LPSTR pszSoundAnsi; GODOT_TO_ACP_STACKALLOC(pszSound, pszSoundAnsi); RetVal=sndPlaySoundA(pszSoundAnsi, fuSound); return RetVal; } End= [EFunc] TemplateName=StartDocW Begin= int __stdcall GodotStartDocW(HDC hdc, const DOCINFOW * lpdi) { if(lpdi==NULL) { SetLastError(ERROR_INVALID_PARAMETER); return(0); } else { DOCINFOA dia; int RetVal; UINT cpg = CpgFromHdc(hdc); UINT mcs = CbPerChOfCpg(cpg); // Begin precall ZeroMemory(&dia, sizeof(DOCINFOA)); dia.cbSize = sizeof(DOCINFOA); GODOT_TO_CPG_STACKALLOC(lpdi->lpszDocName, dia.lpszDocName, cpg, mcs); GODOT_TO_CPG_STACKALLOC(lpdi->lpszOutput, dia.lpszOutput, cpg, mcs); GODOT_TO_CPG_STACKALLOC(lpdi->lpszDatatype, dia.lpszDatatype, cpg, mcs); dia.fwType = lpdi->fwType; RetVal = StartDocA(hdc, &dia); return(RetVal); } } End= [EFunc] TemplateName=StartDocPrinterW Begin= DWORD __stdcall GodotStartDocPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pDocInfo) { DOC_INFO_2A dcia; switch(Level) { case 2: dcia.dwMode = ((LPDOC_INFO_2W)pDocInfo)->dwMode; dcia.JobId = ((LPDOC_INFO_2W)pDocInfo)->JobId; // fall through to pick up the strings that are shared case 1: GODOT_TO_ACP_STACKALLOC(((LPDOC_INFO_1W)pDocInfo)->pDocName, dcia.pDocName); GODOT_TO_ACP_STACKALLOC(((LPDOC_INFO_1W)pDocInfo)->pOutputFile, dcia.pOutputFile); GODOT_TO_ACP_STACKALLOC(((LPDOC_INFO_1W)pDocInfo)->pDatatype, dcia.pDatatype); break; default: SetLastError(ERROR_INVALID_PARAMETER); return(0); break; } return(StartDocPrinterA(hPrinter, Level, (LPBYTE)&dcia)); } End= [EFunc] TemplateName=TextOutW Begin= BOOL __stdcall GodotTextOutW(HDC hdc, int nXStart, int nYStart, LPCWSTR lpString, int cbString) { // Office does this too: why call TextOutW and have // to work around the Win9x bug twice, after all? return GodotExtTextOutW(hdc, nXStart, nYStart, 0, NULL, lpString, cbString, NULL); } End= [EFunc] TemplateName=SystemParametersInfoW Begin= BOOL __stdcall GodotSystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni) { BOOL RetVal = FALSE; // guilty until proven innocent // About 1/3 of this code is stolen from VSANSI, but they skip too // many uiParams to suit our full needs. // APP COMPAT: It seems that Win9x does not require that uiParam set the size if // cbSize does, so we need to let them live with this. If either value is set properly, // then let them on through. switch(uiAction) { case SPI_GETNONCLIENTMETRICS: case SPI_SETNONCLIENTMETRICS: { PNONCLIENTMETRICSW pncmw = (PNONCLIENTMETRICSW)pvParam; if(pncmw && ((pncmw->cbSize == sizeof(NONCLIENTMETRICSW)) || (uiParam == sizeof(NONCLIENTMETRICSW)))) { NONCLIENTMETRICSA ncma; ncma.cbSize = sizeof(NONCLIENTMETRICSA); if(uiAction == SPI_SETNONCLIENTMETRICS) { ncma.iBorderWidth = pncmw->iBorderWidth; ncma.iScrollWidth = pncmw->iScrollWidth; ncma.iScrollHeight = pncmw->iScrollHeight; ncma.iCaptionWidth = pncmw->iCaptionWidth; ncma.iCaptionHeight = pncmw->iCaptionHeight; LogFontAfromW(&ncma.lfCaptionFont, &pncmw->lfCaptionFont); ncma.iSmCaptionWidth = pncmw->iSmCaptionWidth; ncma.iSmCaptionHeight = pncmw->iSmCaptionHeight; LogFontAfromW(&ncma.lfSmCaptionFont, &pncmw->lfSmCaptionFont); ncma.iMenuWidth = pncmw->iMenuWidth; ncma.iMenuHeight = pncmw->iMenuHeight; LogFontAfromW(&ncma.lfMenuFont, &pncmw->lfMenuFont); LogFontAfromW(&ncma.lfStatusFont, &pncmw->lfStatusFont); LogFontAfromW(&ncma.lfMessageFont, &pncmw->lfMessageFont); } RetVal = SystemParametersInfoA(uiAction, sizeof(NONCLIENTMETRICSA), &ncma, fWinIni); if(RetVal && (uiAction == SPI_GETNONCLIENTMETRICS)) { pncmw->cbSize = sizeof(NONCLIENTMETRICSW); pncmw->iBorderWidth = ncma.iBorderWidth; pncmw->iScrollWidth = ncma.iScrollWidth; pncmw->iScrollHeight = ncma.iScrollHeight; pncmw->iCaptionWidth = ncma.iCaptionWidth; pncmw->iCaptionHeight = ncma.iCaptionHeight; LogFontWfromA(&pncmw->lfCaptionFont, &ncma.lfCaptionFont); pncmw->iSmCaptionWidth = ncma.iSmCaptionWidth; pncmw->iSmCaptionHeight = ncma.iSmCaptionHeight; LogFontWfromA(&pncmw->lfSmCaptionFont, &ncma.lfSmCaptionFont); pncmw->iMenuWidth = ncma.iMenuWidth; pncmw->iMenuHeight = ncma.iMenuHeight; LogFontWfromA(&pncmw->lfMenuFont, &ncma.lfMenuFont); LogFontWfromA(&pncmw->lfStatusFont, &ncma.lfStatusFont); LogFontWfromA(&pncmw->lfMessageFont, &ncma.lfMessageFont); } } else SetLastError(ERROR_INVALID_PARAMETER); break; } case SPI_GETHIGHCONTRAST: case SPI_SETHIGHCONTRAST: { LPHIGHCONTRASTW phc = (LPHIGHCONTRASTW)pvParam; if(phc && ((phc->cbSize == sizeof(HIGHCONTRASTW)) || (uiParam == sizeof(HIGHCONTRASTW)))) { HIGHCONTRASTA hca; ZeroMemory(&hca, sizeof(HIGHCONTRASTA)); hca.cbSize = sizeof(HIGHCONTRASTA); if(uiAction == SPI_SETHIGHCONTRAST) { hca.dwFlags = phc->dwFlags; GODOT_TO_ACP_STACKALLOC(phc->lpszDefaultScheme, hca.lpszDefaultScheme); } else { _STACKALLOC(LF_FULLFACESIZE, hca.lpszDefaultScheme); } if((hca.lpszDefaultScheme == NULL) && (phc->lpszDefaultScheme != NULL)) { return(FALSE); } RetVal = SystemParametersInfoA(uiAction, sizeof(HIGHCONTRASTA), &hca, fWinIni); if(RetVal && (uiAction == SPI_GETHIGHCONTRAST)) { phc->cbSize = sizeof(HIGHCONTRASTW); phc->dwFlags = hca.dwFlags; if(FSTRING_VALID(hca.lpszDefaultScheme) && FSTRING_VALID(phc->lpszDefaultScheme)) { MultiByteToWideChar(g_acp, 0, hca.lpszDefaultScheme, -1, phc->lpszDefaultScheme, LF_FULLFACESIZE); } } } else SetLastError(ERROR_INVALID_PARAMETER); break; } case SPI_GETICONMETRICS: case SPI_SETICONMETRICS: { LPICONMETRICSW lpimw = (LPICONMETRICSW)pvParam; if(lpimw && ((lpimw->cbSize == sizeof(ICONMETRICSW)) || (uiParam == sizeof(ICONMETRICSW)))) { ICONMETRICSA ima; LPLOGFONTW lplfw = &lpimw->lfFont; LPLOGFONTA lplfa = &ima.lfFont; ZeroMemory(&ima, sizeof(ICONMETRICSA)); ima.cbSize = sizeof(ICONMETRICSA); if(uiAction == SPI_SETICONMETRICS) { ima.iHorzSpacing = lpimw->iHorzSpacing; ima.iVertSpacing = lpimw->iVertSpacing; ima.iTitleWrap = lpimw->iTitleWrap; LogFontAfromW(lplfa, lplfw); } RetVal = SystemParametersInfoA(uiAction, sizeof(ICONMETRICSA), &ima, fWinIni); if(RetVal && (uiAction == SPI_GETICONMETRICS)) { lpimw->cbSize = sizeof(ICONMETRICSW); lpimw->iHorzSpacing = ima.iHorzSpacing; lpimw->iVertSpacing = ima.iVertSpacing; lpimw->iTitleWrap = ima.iTitleWrap; LogFontWfromA(lplfw, lplfa); } } else SetLastError(ERROR_INVALID_PARAMETER); break; } case SPI_GETICONTITLELOGFONT: case SPI_SETICONTITLELOGFONT: { if (uiParam == sizeof(LOGFONTW)) { LOGFONTA lfa; LPLOGFONTW lplfw = (LPLOGFONTW)pvParam; ZeroMemory(&lfa, sizeof(LOGFONTA)); if(uiAction == SPI_SETICONTITLELOGFONT) LogFontAfromW(&lfa, lplfw); RetVal = SystemParametersInfoA(uiAction, sizeof(LOGFONTA), &lfa, fWinIni); if(RetVal && (uiAction == SPI_GETICONTITLELOGFONT)) LogFontWfromA(lplfw, &lfa); } else SetLastError(ERROR_INVALID_PARAMETER); break; } case SPI_GETSERIALKEYS: case SPI_SETSERIALKEYS: { LPSERIALKEYSW lpskw = (LPSERIALKEYSW)pvParam; if(lpskw && ((lpskw->cbSize == sizeof(SERIALKEYSW)) || (uiParam == sizeof(SERIALKEYSW)))) { SERIALKEYSA ska; ZeroMemory(&ska, sizeof(SERIALKEYSA)); GODOT_TO_ACP_STACKALLOC(lpskw->lpszActivePort, ska.lpszActivePort); if((ska.lpszActivePort == NULL) && (lpskw->lpszActivePort != NULL)) { return(FALSE); } ska.lpszPort = NULL; ska.cbSize = sizeof(SERIALKEYSA); if(uiAction == SPI_SETSERIALKEYS) { ska.dwFlags = lpskw->dwFlags; ska.iBaudRate = lpskw->iBaudRate; ska.iPortState = lpskw->iPortState; ska.iActive = lpskw->iActive; } RetVal = SystemParametersInfoA(uiAction, sizeof(SERIALKEYSA), &ska, fWinIni); if(RetVal && (uiAction == SPI_GETSERIALKEYS)) { lpskw->cbSize = sizeof(SERIALKEYSW); lpskw->dwFlags = ska.dwFlags; lpskw->iBaudRate = ska.iBaudRate; lpskw->iPortState = ska.iPortState; lpskw->iActive = ska.iActive; } } else SetLastError(ERROR_INVALID_PARAMETER); break; } case SPI_GETSOUNDSENTRY: case SPI_SETSOUNDSENTRY: { LPSOUNDSENTRYW lpssw = (LPSOUNDSENTRYW)pvParam; if(lpssw && ((lpssw->cbSize == sizeof(SOUNDSENTRYW)) || (uiParam == sizeof(SOUNDSENTRYW)))) { SOUNDSENTRYA ssa; ZeroMemory(&ssa, sizeof(SOUNDSENTRYA)); ssa.cbSize = sizeof(SOUNDSENTRYA); if(uiAction == SPI_GETSOUNDSENTRY) { _STACKALLOC(MAX_PATH, ssa.lpszWindowsEffectDLL); } else // if(uiAction==SPI_SETSOUNDSENTRY) { ssa.dwFlags = lpssw->dwFlags; ssa.iFSTextEffect = lpssw->iFSTextEffect; ssa.iFSTextEffectMSec = lpssw->iFSTextEffectMSec; ssa.iFSTextEffectColorBits = lpssw->iFSTextEffectColorBits; ssa.iFSGrafEffect = lpssw->iFSGrafEffect; ssa.iFSGrafEffectMSec = lpssw->iFSGrafEffectMSec; ssa.iFSGrafEffectColor = lpssw->iFSGrafEffectColor; ssa.iWindowsEffect = lpssw->iWindowsEffect; ssa.iWindowsEffectMSec = lpssw->iWindowsEffectMSec; GODOT_TO_ACP_STACKALLOC(lpssw->lpszWindowsEffectDLL, ssa.lpszWindowsEffectDLL); ssa.iWindowsEffectOrdinal = lpssw->iWindowsEffectOrdinal; } if((ssa.lpszWindowsEffectDLL == NULL) && (lpssw->lpszWindowsEffectDLL != NULL)) { return(FALSE); } RetVal = SystemParametersInfoA(uiAction, sizeof(SOUNDSENTRYA), &ssa, fWinIni); if(RetVal && (uiAction == SPI_GETSOUNDSENTRY)) { lpssw->cbSize = sizeof(SOUNDSENTRYW); lpssw->dwFlags = ssa.dwFlags; lpssw->iFSTextEffect = ssa.iFSTextEffect; lpssw->iFSTextEffectMSec = ssa.iFSTextEffectMSec; lpssw->iFSTextEffectColorBits = ssa.iFSTextEffectColorBits; lpssw->iFSGrafEffect = ssa.iFSGrafEffect; lpssw->iFSGrafEffectMSec = ssa.iFSGrafEffectMSec; lpssw->iFSGrafEffectColor = ssa.iFSGrafEffectColor; lpssw->iWindowsEffect = ssa.iWindowsEffect; lpssw->iWindowsEffectMSec = ssa.iWindowsEffectMSec; MultiByteToWideChar(g_acp, 0, ssa.lpszWindowsEffectDLL, -1, lpssw->lpszWindowsEffectDLL, MAX_PATH); lpssw->iWindowsEffectOrdinal = ssa.iWindowsEffectOrdinal; } } else SetLastError(ERROR_INVALID_PARAMETER); break; } case SPI_SETDESKWALLPAPER: case SPI_GETDESKWALLPAPER: { LPSTR pvParamAnsi = NULL; if(uiAction == SPI_SETDESKWALLPAPER) GODOT_TO_ACP_STACKALLOC(pvParam, pvParamAnsi); else _STACKALLOC(MAX_PATH + 1, pvParamAnsi); if((pvParamAnsi == NULL) && (pvParam != NULL)) { return(FALSE); } RetVal = SystemParametersInfoA(uiAction, uiParam, pvParamAnsi, fWinIni); if(RetVal && (uiAction == SPI_GETDESKWALLPAPER) && FSTRING_VALID(pvParamAnsi) && FSTRING_VALID((LPWSTR)pvParam)) { MultiByteToWideChar(g_acp, 0, pvParamAnsi, -1, (LPWSTR)pvParam, MAX_PATH); } break; } default: { // Call the 'A' version of the API without conversion, etc. RetVal = SystemParametersInfoA(uiAction, uiParam, pvParam, fWinIni); break; } } // Finished return RetVal; } End= [EFunc] TemplateName=TranslateAcceleratorW Begin= int __stdcall GodotTranslateAcceleratorW(HWND hWnd, HACCEL hAccTable, LPMSG lpMsg) { return((int)GodotDispatchMessage(mtTranslateAccelerator, hWnd, hAccTable, lpMsg)); } End= [EFunc] TemplateName=UpdateResourceW Begin= BOOL __stdcall GodotUpdateResourceW(HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cbData) { // UNSUPPORTED FUNCTION: Documented as a failure stub return(UpdateResourceInternalW(hUpdate, lpType, lpName, wLanguage, lpData, cbData)); } End= [EFunc] TemplateName=VerFindFileW Begin= DWORD __stdcall GodotVerFindFileW( DWORD uFlags, LPWSTR szFileName, LPWSTR szWinDir, LPWSTR szAppDir, LPWSTR szCurDir, PUINT lpuCurDirLen, LPWSTR szDestDir, PUINT lpuDestDirLen ) { // Begin locals DWORD RetVal; LPSTR szFileNameAnsi, szWinDirAnsi, szAppDirAnsi; char szCurDirAnsi[MAX_PATH + 1]; char szDestDirAnsi[MAX_PATH + 1]; UINT uCurDirLen, uDestDirLen; // Begin precall GODOT_TO_ACP_STACKALLOC(szFileName, szFileNameAnsi); GODOT_TO_ACP_STACKALLOC(szWinDir, szWinDirAnsi); GODOT_TO_ACP_STACKALLOC(szAppDir, szAppDirAnsi); if((!szFileNameAnsi && szFileName) || (!szWinDirAnsi && szWinDir) || (!szAppDirAnsi && szAppDir)) return(0); uCurDirLen = *lpuCurDirLen * g_mcs; uDestDirLen= *lpuDestDirLen * g_mcs; ZeroMemory(szCurDirAnsi, MAX_PATH + 1); ZeroMemory(szDestDirAnsi, MAX_PATH + 1); RetVal=VerFindFileA(uFlags, szFileNameAnsi, szWinDirAnsi, szAppDirAnsi, szCurDirAnsi, &uCurDirLen, szDestDirAnsi, &uDestDirLen); // Begin postcall: note that we do not care what the return value // really was,since these buffer sizes are set either way. if(uCurDirLen > *lpuCurDirLen) *lpuCurDirLen = uCurDirLen; else { MultiByteToWideChar(g_acp, 0, szCurDirAnsi, -1, szCurDir, *lpuCurDirLen); *lpuCurDirLen = gwcslen(szCurDir); } if(uDestDirLen > *lpuDestDirLen) *lpuDestDirLen = uCurDirLen; else { // Convert the full length of the ANSI name into the full size of the Unicode buffer MultiByteToWideChar(g_acp, 0, szDestDirAnsi, -1, szDestDir, *lpuDestDirLen); *lpuDestDirLen = gwcslen(szDestDir); } // Finished return RetVal; } End= [EFunc] TemplateName=VerInstallFileW Begin= DWORD __stdcall GodotVerInstallFileW( DWORD uFlags, LPWSTR szSrcFileName, LPWSTR szDestFileName, LPWSTR szSrcDir, LPWSTR szDestDir, LPWSTR szCurDir, LPWSTR szTmpFile, PUINT lpuTmpFileLen ) { // Begin locals DWORD RetVal; LPSTR szSrcFileNameAnsi, szDestFileNameAnsi, szSrcDirAnsi, szDestDirAnsi, szCurDirAnsi; CHAR szTmpFileAnsi[MAX_PATH + 1]; UINT uTmpFileLen; // Begin precall GODOT_TO_ACP_STACKALLOC(szSrcFileName, szSrcFileNameAnsi); GODOT_TO_ACP_STACKALLOC(szDestFileName, szDestFileNameAnsi); GODOT_TO_ACP_STACKALLOC(szSrcDir, szSrcDirAnsi); GODOT_TO_ACP_STACKALLOC(szDestDir, szDestDirAnsi); GODOT_TO_ACP_STACKALLOC(szCurDir, szCurDirAnsi); if((!szSrcFileNameAnsi && szSrcFileName) || (!szDestFileNameAnsi && szDestFileName) || (!szSrcDirAnsi && szSrcDir) || (!szDestDirAnsi && szDestDir) || (!szCurDirAnsi && szCurDir)) return(0); uTmpFileLen = *lpuTmpFileLen * g_mcs; ZeroMemory(&szTmpFileAnsi, MAX_PATH + 1); RetVal=VerInstallFileA(uFlags, szSrcFileNameAnsi, szDestFileNameAnsi, szSrcDirAnsi, szDestDirAnsi, szCurDirAnsi, szTmpFileAnsi, &uTmpFileLen); // Begin postcall: note that we do not care what the return value // really was,since these buffer sizes must be set either way. if(uTmpFileLen > *lpuTmpFileLen) *lpuTmpFileLen = uTmpFileLen; else { // Convert the full length of the ANSI name into the full size of the Unicode buffer MultiByteToWideChar(g_acp, 0, szTmpFileAnsi, -1, szTmpFile, *lpuTmpFileLen); *lpuTmpFileLen = gwcslen(szTmpFile); } // Finished return RetVal; } End= [EFunc] TemplateName=VerLanguageNameW Begin= DWORD __stdcall GodotVerLanguageNameW(DWORD wLang, LPWSTR szLang, DWORD nSize) { DWORD RetVal; LPSTR szLangAnsi = NULL; _STACKALLOC((nSize *g_mcs) + 1, szLangAnsi); if(szLangAnsi==NULL) { return(0); } ZeroMemory(szLangAnsi, (nSize * g_mcs) + 1); RetVal=VerLanguageNameA(wLang, szLangAnsi, nSize); // kinda sucks but we are not being any worse than // the OS is here -- See Windows Bugs # 311758 for // more details if(szLang) { if (RetVal < nSize) MultiByteToWideChar(g_acp, 0, szLangAnsi, -1, szLang, RetVal); else MultiByteToWideChar(g_acp, 0, szLangAnsi, -1, szLang, nSize); } // Finished return RetVal; } End= [EFunc] TemplateName=VerQueryValueW Begin= BOOL __stdcall GodotVerQueryValueW(const LPVOID pBlock, LPWSTR lpSubBlock, LPVOID * lplpBuffer, PUINT puLen) { const WCHAR pwzStringFileInfo[] = L"\\StringFileInfo"; BOOL RetVal; LPSTR lpSubBlockAnsi; BYTE* pbyt; LPWSTR lpwz; // Begin precall GODOT_TO_ACP_STACKALLOC(lpSubBlock, lpSubBlockAnsi); if(lpSubBlockAnsi==NULL) { return(FALSE); } pbyt = (BYTE*)pBlock + VERINFO_BUFFER; RetVal=VerQueryValueA((void *)pbyt, lpSubBlockAnsi, lplpBuffer, puLen); if (RetVal && (gwcsncmp(pwzStringFileInfo, lpSubBlock, gwcslen(pwzStringFileInfo)) == 0)) { // Ok, this means we have to convert. We have a string. :-) lpwz = (LPWSTR)pBlock; if (*puLen == 0) lpwz = L'\0'; else MultiByteToWideChar(g_acp, 0, *lplpBuffer, -1, lpwz, VERINFO_BUFFER/sizeof(WCHAR)); if(lplpBuffer) *lplpBuffer = lpwz; } // Finished return RetVal; } End= [EFunc] TemplateName=VkKeyScanW Begin= SHORT __stdcall GodotVkKeyScanW(WCHAR ch) { char chAnsi; UINT cpg = CpgFromLocale(LOWORD(GetKeyboardLayout(0))); UINT mcs = CbPerChOfCpg(cpg); WideCharToMultiByte(cpg, 0, (WCHAR *)&ch, 1, (CHAR *)&chAnsi, sizeof(char), NULL, NULL); return(VkKeyScanA(chAnsi)); } End= [EFunc] TemplateName=VkKeyScanExW Begin= SHORT __stdcall GodotVkKeyScanExW(WCHAR ch, HKL dwhkl) { char chAnsi; UINT cpg = CpgFromLocale(LOWORD(dwhkl)); UINT mcs = CbPerChOfCpg(cpg); WideCharToMultiByte(cpg, 0, (WCHAR *)&ch, 1, (CHAR *)&chAnsi, sizeof(char), NULL, NULL); return(VkKeyScanExA(chAnsi, dwhkl)); } End= [EFunc] TemplateName=waveInGetDevCapsW Begin= MMRESULT __stdcall GodotwaveInGetDevCapsW(UINT_PTR uDeviceID, LPWAVEINCAPSW pwic, UINT cbwic) { // UNSUPPORTED FUNCTION: Documented as a failure stub if(cbwic < sizeof(WAVEINCAPSW)) { return(MMSYSERR_INVALPARAM); } else { WAVEINCAPSA wicA; MMRESULT RetVal; ZeroMemory(&wicA, sizeof(WAVEINCAPSA)); RetVal = waveInGetDevCapsA(uDeviceID, &wicA, sizeof(WAVEINCAPSA)); if(RetVal == MMSYSERR_NOERROR) { pwic->wMid = wicA.wMid; pwic->wPid = wicA.wPid; pwic->vDriverVersion = wicA.vDriverVersion; pwic->dwFormats = wicA.dwFormats; pwic->wChannels = wicA.wChannels; pwic->wReserved1 = wicA.wReserved1; MultiByteToWideChar(g_acp, 0, wicA.szPname, MAXPNAMELEN, pwic->szPname, MAXPNAMELEN); } return(RetVal); } } End= [EFunc] TemplateName=waveInGetErrorTextW Begin= MMRESULT __stdcall GodotwaveInGetErrorTextW(MMRESULT mmrError, LPWSTR pszText, UINT cchText) { // UNSUPPORTED FUNCTION: Documented as a failure stub if(pszText==NULL || cchText == 0) return(waveInGetErrorTextA(mmrError, (LPSTR)pszText, cchText)); else { LPSTR pszTextA; MMRESULT RetVal; _STACKALLOC((cchText * g_mcs) + 1, pszTextA); if(!pszTextA) return(MMSYSERR_NOMEM); ZeroMemory(pszTextA, (cchText * g_mcs) + 1); RetVal = waveInGetErrorTextA(mmrError, pszTextA, cchText); if(RetVal == MMSYSERR_NOERROR) MultiByteToWideChar(g_acp, 0, pszTextA, -1, pszText, cchText); return(RetVal); } } End= [EFunc] TemplateName=waveOutGetDevCapsW Begin= MMRESULT __stdcall GodotwaveOutGetDevCapsW(UINT_PTR uDeviceID, LPWAVEOUTCAPSW pwoc, UINT cbwoc) { // UNSUPPORTED FUNCTION: Documented as a failure stub if(cbwoc < sizeof(WAVEOUTCAPSW)) { return(MMSYSERR_INVALPARAM); } else { WAVEOUTCAPSA wocA; MMRESULT RetVal; ZeroMemory(&wocA, sizeof(WAVEOUTCAPS)); RetVal = waveOutGetDevCapsA(uDeviceID, &wocA, sizeof(WAVEOUTCAPSA)); if(RetVal == MMSYSERR_NOERROR) { pwoc->wMid = wocA.wMid; pwoc->wPid = wocA.wPid; pwoc->vDriverVersion = wocA.vDriverVersion; pwoc->dwFormats = wocA.dwFormats; pwoc->wChannels = wocA.wChannels; pwoc->wReserved1 = wocA.wReserved1; pwoc->dwSupport = wocA.dwSupport; MultiByteToWideChar(g_acp, 0, wocA.szPname, MAXPNAMELEN, pwoc->szPname, MAXPNAMELEN); } return(RetVal); } } End= [EFunc] TemplateName=waveOutGetErrorTextW Begin= MMRESULT __stdcall GodotwaveOutGetErrorTextW(MMRESULT mmrError, LPWSTR pszText, UINT cchText) { // UNSUPPORTED FUNCTION: Documented as a failure stub if(pszText==NULL || cchText == 0) return(waveOutGetErrorTextA(mmrError, (LPSTR)pszText, cchText)); else { LPSTR pszTextA; MMRESULT RetVal; _STACKALLOC((cchText * g_mcs) + 1, pszTextA); if(!pszTextA) return(MMSYSERR_NOMEM); ZeroMemory(pszTextA, (cchText * g_mcs) + 1); RetVal = waveOutGetErrorTextA(mmrError, pszTextA, cchText); if(RetVal == MMSYSERR_NOERROR) MultiByteToWideChar(g_acp, 0, pszTextA, -1, pszText, cchText); return(RetVal); } } End= [EFunc] TemplateName=WideCharToMultiByte Begin= // WideCharToMultiByte is wrapped for UTF-7/UTF-8 support int __stdcall GodotWideCharToMultiByte( UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cbMultiByte, LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar ) { UINT cpg = ((CodePage == CP_THREAD_ACP) ? g_acp : CodePage); // See if it's a special code page value for UTF translations. if (cpg >= NLS_CP_ALGORITHM_RANGE) return(UnicodeToUTF(cpg, dwFlags, lpWideCharStr, cchWideChar, lpMultiByteStr, cbMultiByte, lpDefaultChar, lpUsedDefaultChar)); // GB 18030 specified? if (cpg == CP_GB18030) return(GB18030Helper(cpg, dwFlags | NLS_CP_WCTOMB, lpMultiByteStr, cbMultiByte, (LPWSTR)lpWideCharStr, cchWideChar, NULL)); return(WideCharToMultiByte(cpg, dwFlags, lpWideCharStr, cchWideChar, lpMultiByteStr, cbMultiByte, lpDefaultChar, lpUsedDefaultChar)); } End= [EFunc] TemplateName=WinHelpW Begin= BOOL __stdcall GodotWinHelpW(HWND hWndMain, LPCWSTR lpszHelp, UINT uCommand, ULONG_PTR dwData) { LPSTR lpszHelpAnsi; GODOT_TO_ACP_STACKALLOC(lpszHelp, lpszHelpAnsi); switch(uCommand & ~HELP_TCARD) { case HELP_COMMAND: case HELP_KEY: case HELP_PARTIALKEY: { ULONG_PTR dwDataAnsi; GODOT_TO_ACP_STACKALLOC(dwData, dwDataAnsi); return(WinHelpA(hWndMain, lpszHelpAnsi, uCommand, dwData)); break; } case HELP_MULTIKEY: { LPMULTIKEYHELPW lpmkh = (LPMULTIKEYHELPW)dwData; MULTIKEYHELPA mkhA; char * szKeyPhrase; size_t cchKeyPhrase; ZeroMemory(&mkhA, sizeof(MULTIKEYHELPA)); mkhA.mkSize = sizeof(MULTIKEYHELPA); WideCharToMultiByte(g_acp, 0, (WCHAR *)&(lpmkh->mkKeylist), 1, (CHAR *)&(mkhA.mkKeylist), sizeof(char), NULL, NULL); cchKeyPhrase = gwcslen(lpmkh->szKeyphrase) + 1; _STACKALLOC(cchKeyPhrase*g_mcs, szKeyPhrase); WideCharToMultiByte(g_acp, 0, lpmkh->szKeyphrase, cchKeyPhrase, szKeyPhrase, cchKeyPhrase*g_mcs, NULL, NULL); lstrcpyA(mkhA.szKeyphrase, szKeyPhrase); return(WinHelpA(hWndMain, lpszHelpAnsi, uCommand, (ULONG_PTR)&mkhA)); break; } case HELP_SETWINPOS: { LPHELPWININFOW lphwi = (LPHELPWININFOW)dwData; LPHELPWININFOA lphwiA; LPSTR lpAnsiKey; size_t cchMember; BOOL RetVal; lphwiA = LocalAlloc(LPTR, (lphwi->wStructSize)); if(!lphwiA) return(FALSE); else { *lphwiA = *((LPHELPWININFOA)dwData); // copies identical parts lphwiA->wStructSize = sizeof(HELPWININFOA); cchMember = gwcslen(lphwi->rgchMember) + 1; _STACKALLOC(cchMember*g_mcs, lpAnsiKey); WideCharToMultiByte(g_acp, 0, lphwi->rgchMember, cchMember, lpAnsiKey, cchMember*g_mcs, NULL, NULL); lstrcpyA(lphwiA->rgchMember, lpAnsiKey); RetVal = WinHelpA(hWndMain, lpszHelpAnsi, uCommand, (ULONG_PTR)lphwiA); LocalFree(lphwiA); return(RetVal); } break; } default: return(WinHelpA(hWndMain, lpszHelpAnsi, uCommand, dwData)); break; } } End= [EFunc] TemplateName=WNetAddConnection2W Begin= DWORD __stdcall GodotWNetAddConnection2W(LPNETRESOURCEW lpnrw, LPCWSTR lpPassword, LPCWSTR lpUserName, DWORD dwFlags) { // Begin locals LPSTR lpPasswordAnsi; LPSTR lpUserNameAnsi; NETRESOURCEA nra; // Begin precall ZeroMemory(&nra, sizeof(NETRESOURCEA)); memcpy(&nra, lpnrw, (4*sizeof(DWORD))); GODOT_TO_ACP_STACKALLOC(lpnrw->lpLocalName, nra.lpLocalName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpRemoteName, nra.lpRemoteName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpComment, nra.lpComment); GODOT_TO_ACP_STACKALLOC(lpnrw->lpProvider, nra.lpProvider); GODOT_TO_ACP_STACKALLOC(lpUserName, lpUserNameAnsi); GODOT_TO_ACP_STACKALLOC(lpPassword, lpPasswordAnsi); if((!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!lpUserNameAnsi && lpUserName) || (!lpPasswordAnsi && lpPassword)) { SetLastError(ERROR_STACK_OVERFLOW); return(ERROR_EXTENDED_ERROR); } return(WNetAddConnection2A(&nra, lpPasswordAnsi, lpUserNameAnsi, dwFlags)); } End= [EFunc] TemplateName=WNetAddConnection3W Begin= DWORD __stdcall GodotWNetAddConnection3W(HWND hwnd, LPNETRESOURCEW lpnrw, LPCWSTR lpPassword, LPCWSTR lpUser, DWORD dwFlags) { // Begin locals LPSTR lpPasswordAnsi; LPSTR lpUserNameAnsi; NETRESOURCEA nra; // Begin precall ZeroMemory(&nra, sizeof(NETRESOURCEA)); memcpy(&nra, lpnrw, (4*sizeof(DWORD))); GODOT_TO_ACP_STACKALLOC(lpnrw->lpLocalName, nra.lpLocalName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpRemoteName, nra.lpRemoteName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpComment, nra.lpComment); GODOT_TO_ACP_STACKALLOC(lpnrw->lpProvider, nra.lpProvider); GODOT_TO_ACP_STACKALLOC(lpUser, lpUserNameAnsi); GODOT_TO_ACP_STACKALLOC(lpPassword, lpPasswordAnsi); if((!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!lpUserNameAnsi && lpUser) || (!lpPasswordAnsi && lpPassword)) { SetLastError(ERROR_STACK_OVERFLOW); return(ERROR_EXTENDED_ERROR); } return(WNetAddConnection3A(hwnd, &nra, lpPasswordAnsi, lpUserNameAnsi, dwFlags)); } End= [EFunc] TemplateName=WNetConnectionDialog1W Begin= DWORD __stdcall GodotWNetConnectionDialog1W(LPCONNECTDLGSTRUCTW lpConnDlgStruct) { // Begin locals CONNECTDLGSTRUCTA cdsa; // Begin precall ZeroMemory(&cdsa, sizeof(CONNECTDLGSTRUCTA)); cdsa.cbStructure = lpConnDlgStruct->cbStructure; cdsa.hwndOwner = lpConnDlgStruct->hwndOwner; memcpy(&(cdsa.lpConnRes), lpConnDlgStruct->lpConnRes, (4*sizeof(DWORD))); GODOT_TO_ACP_STACKALLOC((lpConnDlgStruct->lpConnRes)->lpLocalName, (cdsa.lpConnRes)->lpLocalName); GODOT_TO_ACP_STACKALLOC((lpConnDlgStruct->lpConnRes)->lpRemoteName, (cdsa.lpConnRes)->lpRemoteName); GODOT_TO_ACP_STACKALLOC((lpConnDlgStruct->lpConnRes)->lpComment, (cdsa.lpConnRes)->lpComment); GODOT_TO_ACP_STACKALLOC((lpConnDlgStruct->lpConnRes)->lpProvider, (cdsa.lpConnRes)->lpProvider); if((!(cdsa.lpConnRes)->lpLocalName && (lpConnDlgStruct->lpConnRes)->lpLocalName) || (!(cdsa.lpConnRes)->lpRemoteName && (lpConnDlgStruct->lpConnRes)->lpRemoteName) || (!(cdsa.lpConnRes)->lpComment && (lpConnDlgStruct->lpConnRes)->lpComment) || (!(cdsa.lpConnRes)->lpProvider && (lpConnDlgStruct->lpConnRes)->lpProvider)) { SetLastError(ERROR_STACK_OVERFLOW); return(ERROR_EXTENDED_ERROR); } cdsa.dwFlags = lpConnDlgStruct->dwFlags; cdsa.dwDevNum = lpConnDlgStruct->dwDevNum; // Call the 'A' version of the API return(WNetConnectionDialog1A(&cdsa)); } End= [EFunc] TemplateName=WNetDisconnectDialog1W Begin= DWORD __stdcall GodotWNetDisconnectDialog1W(LPDISCDLGSTRUCTW lpConnDlgStruct) { // Begin locals DISCDLGSTRUCTA ddsa; // Begin precall ZeroMemory(&ddsa, sizeof(DISCDLGSTRUCTA)); ddsa.cbStructure = lpConnDlgStruct->cbStructure; ddsa.hwndOwner = lpConnDlgStruct->hwndOwner; ddsa.dwFlags = lpConnDlgStruct->dwFlags; GODOT_TO_ACP_STACKALLOC(lpConnDlgStruct->lpLocalName, ddsa.lpLocalName); GODOT_TO_ACP_STACKALLOC(lpConnDlgStruct->lpRemoteName, ddsa.lpRemoteName); if((!ddsa.lpLocalName && lpConnDlgStruct->lpLocalName) || (!ddsa.lpRemoteName && lpConnDlgStruct->lpRemoteName)) { SetLastError(ERROR_STACK_OVERFLOW); return(ERROR_EXTENDED_ERROR); } // Call the 'A' version of the API return(WNetDisconnectDialog1A(&ddsa)); } End= [EFunc] TemplateName=WNetGetConnectionW Begin= DWORD __stdcall GodotWNetGetConnectionW(LPCWSTR lpLocalName, LPWSTR lpRemoteName, LPDWORD lpnLength) { // Begin locals DWORD RetVal; LPSTR lpLocalNameAnsi; LPSTR lpRemoteNameAnsi; DWORD nLength; // Begin precall GODOT_TO_ACP_STACKALLOC(lpLocalName, lpLocalNameAnsi); if(!lpnLength) nLength = 0; else nLength = (*lpnLength * g_mcs) + 1; _STACKALLOC(nLength, lpRemoteNameAnsi); RetVal=WNetGetConnectionA(lpLocalNameAnsi, lpRemoteNameAnsi, &nLength); if(RetVal==NO_ERROR) { if(lpnLength) { MultiByteToWideChar(g_acp, 0, lpRemoteNameAnsi, nLength, lpRemoteName, *lpnLength); *lpnLength = gwcslen(lpRemoteName); } } else { if(lpnLength) *lpnLength = nLength; } // Finished return RetVal; } End= [EFunc] TemplateName=WNetGetLastErrorW Begin= DWORD __stdcall GodotWNetGetLastErrorW(LPDWORD lpError, LPWSTR lpszError, DWORD cchError, LPWSTR lpszName, DWORD cchName) { DWORD RetVal; LPSTR lpErrorBufAnsi; LPSTR lpNameBufAnsi; // Begin precall _STACKALLOC((cchError*g_mcs)+1, lpErrorBufAnsi); _STACKALLOC((cchName*g_mcs)+1, lpNameBufAnsi); if((lpErrorBufAnsi==NULL) || (lpNameBufAnsi==NULL)) { SetLastError(ERROR_STACK_OVERFLOW); return(0); } ZeroMemory(lpErrorBufAnsi, (cchError*g_mcs)+1); ZeroMemory(lpNameBufAnsi, (cchName*g_mcs)+1); RetVal=WNetGetLastErrorA(lpError, lpErrorBufAnsi, cchError, lpNameBufAnsi, cchName); if(RetVal==NO_ERROR) { MultiByteToWideChar(g_acp, 0, lpErrorBufAnsi, -1, lpszError, cchError); MultiByteToWideChar(g_acp, 0, lpNameBufAnsi, -1, lpszName, cchName); } // Finished return RetVal; } End= [EFunc] TemplateName=WNetGetProviderNameW Begin= DWORD __stdcall GodotWNetGetProviderNameW(DWORD dwNetType, LPWSTR lpProviderName, LPDWORD lpBufferSize) { // Begin locals DWORD RetVal; LPSTR lpProviderNameAnsi; // Note that the PSDK docs that the buffer must be at least // one character. if((!lpProviderName) || (!lpBufferSize) || (!(*lpBufferSize))) RetVal = ERROR_INVALID_ADDRESS; else { _STACKALLOC((*lpBufferSize + 1)*g_mcs, lpProviderNameAnsi); // Call the 'A' version of the API RetVal=WNetGetProviderNameA(dwNetType, lpProviderNameAnsi, lpBufferSize); // Begin postcall if(RetVal==NO_ERROR) { MultiByteToWideChar(g_acp, 0, lpProviderNameAnsi, -1, lpProviderName, *lpBufferSize); } else if(RetVal == ERROR_MORE_DATA) { // We do not know the exact size here, so out best guess is the // size of the string. Note that we are getting back bytes here // but need to pass back characters. This means we will divide by // two on DBCS. *lpBufferSize = (*lpBufferSize / g_mcs); } } // Finished return RetVal; } End= [EFunc] TemplateName=WNetGetResourceInformationW Begin= DWORD __stdcall GodotWNetGetResourceInformationW(LPNETRESOURCEW lpnrw, LPVOID lpBuffer, LPDWORD lpcb, LPWSTR * lplpSystem) { // Begin locals DWORD RetVal; NETRESOURCEA nra; LPSTR * lplpSystemAnsi = NULL; LPVOID lpBufferAnsi; LPNETRESOURCEW lprnw; LPNETRESOURCEA lpnraOut; DWORD dwOffset; LPWSTR lpwz; size_t cbSystem; ZeroMemory(&nra, sizeof(NETRESOURCEA)); memcpy(&nra, lpnrw, (4*sizeof(DWORD))); GODOT_TO_ACP_STACKALLOC(lpnrw->lpLocalName, nra.lpLocalName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpRemoteName, nra.lpRemoteName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpComment, nra.lpComment); GODOT_TO_ACP_STACKALLOC(lpnrw->lpProvider, nra.lpProvider); if((!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName)) { SetLastError(ERROR_STACK_OVERFLOW); return(ERROR_EXTENDED_ERROR); } // Set up the buffer if there is one, otherwise // pass NULLL to try to get a buffer size if(lpcb && *lpcb) { _STACKALLOC(*lpcb, lpBufferAnsi); } else lpBufferAnsi = NULL; // Call the 'A' version of the API RetVal=WNetGetResourceInformationA(&nra, lpBuffer, lpcb, lplpSystemAnsi); // Begin postcall if(RetVal==NO_ERROR) { // Set up our NETRESOURCE vars lpnraOut = lpBufferAnsi; lprnw = lpBuffer; // Copy the first four (non-string) parameters and set the offset memcpy(lpnrw, lpnraOut, (4*sizeof(DWORD))); dwOffset = sizeof(NETRESOURCEW); // Local name lpwz = (LPWSTR)&lprnw + dwOffset; MultiByteToWideChar(g_acp, 0, lpnraOut->lpLocalName, -1, lpwz, -1); dwOffset += (lpwz ? gwcslen(lpwz) + 1 : 0); lpnrw->lpLocalName = lpwz; // Remote name lpwz = (LPWSTR)&lprnw + dwOffset; MultiByteToWideChar(g_acp, 0, lpnraOut->lpRemoteName, -1, lpwz, -1); dwOffset += (lpwz ? gwcslen(lpwz) + 1 : 0); lpnrw->lpRemoteName = lpwz; // Comment lpwz = (LPWSTR)&lprnw + dwOffset; MultiByteToWideChar(g_acp, 0, lpnraOut->lpComment, -1, lpwz, -1); dwOffset += (lpwz ? gwcslen(lpwz) + 1 : 0); lpnrw->lpComment = lpwz; // Provider lpwz = (LPWSTR)&lprnw + dwOffset; MultiByteToWideChar(g_acp, 0, lpnraOut->lpProvider, -1, lpwz, -1); dwOffset += (lpwz ? gwcslen(lpwz) + 1 : 0); lpnrw->lpProvider = lpwz; if(lplpSystem && lplpSystemAnsi) { // Now we take care of lplpSystemAnsi. We cannot directly do this, but we // can convert it to a temp buffer, search for the string in the caller's // lpBuffer with gwcsstr and let it return that pointer if there is one. cbSystem = strlen(*lplpSystemAnsi); _STACKALLOC((cbSystem * g_mcs) + 1, lpwz); MultiByteToWideChar(g_acp, 0, *lplpSystemAnsi, -1, lpwz, cbSystem); *lplpSystem = gwcsstr(lpBuffer, lpwz); } } else if (RetVal==ERROR_MORE_DATA && lpcb) { // We do not know the exact size here, so out best guess is the // size of the "A" buffer we get back, *2 for all of the structure // past the NETRESOURCEA part. *lpcb = (sizeof(NETRESOURCEA) + ((*lpcb - (sizeof(NETRESOURCEA))) * sizeof(WCHAR))); } // Finished return RetVal; } End= [EFunc] TemplateName=WNetGetResourceParentW Begin= DWORD __stdcall GodotWNetGetResourceParentW(LPNETRESOURCEW lpnrw, LPVOID lpBuffer, LPDWORD lpcbBuffer) { // Begin locals DWORD RetVal; NETRESOURCEA nra; LPVOID lpBufferAnsi; LPNETRESOURCEW lprnw; LPNETRESOURCEA lpnraOut; DWORD dwOffset; LPWSTR lpwz; // Begin precall ZeroMemory(&nra, sizeof(NETRESOURCEA)); memcpy(&nra, lpnrw, (4*sizeof(DWORD))); GODOT_TO_ACP_STACKALLOC(lpnrw->lpLocalName, nra.lpLocalName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpRemoteName, nra.lpRemoteName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpComment, nra.lpComment); GODOT_TO_ACP_STACKALLOC(lpnrw->lpProvider, nra.lpProvider); if((!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName)) { SetLastError(ERROR_STACK_OVERFLOW); return(ERROR_EXTENDED_ERROR); } // Set up the buffer if there is one, otherwise // pass NULL to try to get a buffer size if(lpcbBuffer && *lpcbBuffer) { _STACKALLOC(*lpcbBuffer, lpBufferAnsi); if(lpBufferAnsi==NULL) { return(ERROR_STACK_OVERFLOW); } } else lpBufferAnsi = NULL; // Call the API RetVal=WNetGetResourceParentA(&nra, lpBufferAnsi, lpcbBuffer); // Begin postcall if(RetVal==NO_ERROR) { // Set up our NETRESOURCE vars, a valid lpBufferAnsi is implied here lpnraOut = lpBufferAnsi; lprnw = lpBuffer; // Copy the first four (non-string) parameters and set the offset memcpy(lpnrw, lpnraOut, (4*sizeof(DWORD))); dwOffset = sizeof(NETRESOURCEW); // Local name if(FSTRING_VALID(lpnraOut->lpLocalName)) { lpwz = (LPWSTR)&lprnw + dwOffset; MultiByteToWideChar(g_acp, 0, lpnraOut->lpLocalName, -1, lpwz, -1); dwOffset += (lpwz ? gwcslen(lpwz) + 1 : 0); lpnrw->lpLocalName = lpwz; } // Remote name if(FSTRING_VALID(lpnraOut->lpRemoteName)) { lpwz = (LPWSTR)&lprnw + dwOffset; MultiByteToWideChar(g_acp, 0, lpnraOut->lpRemoteName, -1, lpwz, -1); dwOffset += (lpwz ? gwcslen(lpwz) + 1 : 0); lpnrw->lpRemoteName = lpwz; } // Comment if(FSTRING_VALID(lpnraOut->lpComment)) { lpwz = (LPWSTR)&lprnw + dwOffset; MultiByteToWideChar(g_acp, 0, lpnraOut->lpComment, -1, lpwz, -1); dwOffset += (lpwz ? gwcslen(lpwz) + 1 : 0); lpnrw->lpComment = lpwz; } // Provider if(FSTRING_VALID(lpnraOut->lpProvider)) { lpwz = (LPWSTR)&lprnw + dwOffset; MultiByteToWideChar(g_acp, 0, lpnraOut->lpProvider, -1, lpwz, -1); dwOffset += (lpwz ? gwcslen(lpwz) + 1 : 0); lpnrw->lpProvider = lpwz; } } else if (RetVal==ERROR_MORE_DATA && lpcbBuffer) { // We do not know the exact size here, so out best guess is the // size of the "A" buffer we get back, *2 for all of the structure // past the NETRESOURCEA part. *lpcbBuffer = (sizeof(NETRESOURCEA) + ((*lpcbBuffer - (sizeof(NETRESOURCEA))) * sizeof(WCHAR))); } // Finished return RetVal; } End= [EFunc] TemplateName=WNetGetUserW Begin= DWORD __stdcall GodotWNetGetUserW(LPCWSTR lpName, LPWSTR lpUserName, LPDWORD lpnLength) { DWORD RetVal; LPSTR lpNameAnsi; LPSTR lpUserNameAnsi; DWORD nLength; if(!lpnLength) { SetLastError(ERROR_INVALID_PARAMETER); return(0); } nLength = *lpnLength; GODOT_TO_ACP_STACKALLOC(lpName, lpNameAnsi); // Alloc buffer, assume caller is being honest about size _STACKALLOC((nLength *g_mcs)+1, lpUserNameAnsi); RetVal=WNetGetUserA(lpNameAnsi, lpUserNameAnsi, &nLength); if(RetVal==WN_NO_ERROR) { if (*lpnLength >= nLength) { // Success and buffer was big enough MultiByteToWideChar(g_acp, 0, lpUserNameAnsi, nLength, lpUserName, *lpnLength); *lpnLength = gwcslen(lpUserName); } else { // It was not real success, as their buffer was not large enough RetVal=ERROR_MORE_DATA; *lpnLength = nLength; } } else *lpnLength = nLength; // Finished return RetVal; } End= [EFunc] TemplateName=WNetOpenEnumW Begin= DWORD __stdcall GodotWNetOpenEnumW(DWORD dwScope, DWORD dwType, DWORD dwUsage, LPNETRESOURCEW lpnrw, LPHANDLE lphEnum) { NETRESOURCEA nra; ZeroMemory(&nra, sizeof(NETRESOURCEA)); memcpy(&nra, lpnrw, (4*sizeof(DWORD))); GODOT_TO_ACP_STACKALLOC(lpnrw->lpLocalName, nra.lpLocalName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpRemoteName, nra.lpRemoteName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpComment, nra.lpComment); GODOT_TO_ACP_STACKALLOC(lpnrw->lpProvider, nra.lpProvider); if((!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName)) { SetLastError(ERROR_STACK_OVERFLOW); return(ERROR_EXTENDED_ERROR); } // Call the 'A' version of the API return(WNetOpenEnumA(dwScope, dwType, dwUsage, &nra, lphEnum)); } End= [EFunc] TemplateName=WNetUseConnectionW Begin= DWORD __stdcall GodotWNetUseConnectionW( HWND hwndOwner, LPNETRESOURCEW lpnrw, LPCWSTR lpUserID, LPCWSTR lpPassword, DWORD dwFlags, LPWSTR lpAccessName, LPDWORD lpBufferSize, LPDWORD lpResult ) { // Begin locals DWORD RetVal; LPSTR lpUserIDAnsi; LPSTR lpPasswordAnsi; NETRESOURCEA nra; LPSTR lpAccessNameAnsi; // Begin precall ZeroMemory(&nra, sizeof(NETRESOURCEA)); memcpy(&nra, lpnrw, (4*sizeof(DWORD))); GODOT_TO_ACP_STACKALLOC(lpnrw->lpLocalName, nra.lpLocalName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpRemoteName, nra.lpRemoteName); GODOT_TO_ACP_STACKALLOC(lpnrw->lpComment, nra.lpComment); GODOT_TO_ACP_STACKALLOC(lpnrw->lpProvider, nra.lpProvider); GODOT_TO_ACP_STACKALLOC(lpUserID, lpUserIDAnsi); GODOT_TO_ACP_STACKALLOC(lpPassword, lpPasswordAnsi); if((!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!nra.lpLocalName && lpnrw->lpLocalName) || (!lpUserIDAnsi && lpUserID) || (!lpPasswordAnsi && lpPassword)) { SetLastError(ERROR_STACK_OVERFLOW); return(ERROR_EXTENDED_ERROR); } // Alloc buffer, assume caller is being honest about size _STACKALLOC((*lpBufferSize*g_mcs)+1, lpAccessNameAnsi); // IMPORTANT! Per PSDK: Windows 95/98: // The lpUserID and lpPassword parameters are in reverse order from the order used // on Windows NT/Windows 2000. // Thus, we reverse the order RetVal=WNetUseConnectionA(hwndOwner, &nra, lpPasswordAnsi, lpUserIDAnsi, dwFlags, lpAccessNameAnsi, lpBufferSize, lpResult ); if(RetVal==NO_ERROR) { MultiByteToWideChar(g_acp, 0, lpAccessNameAnsi, -1, lpAccessName, *lpBufferSize); *lpBufferSize = gwcslen(lpAccessName); } else if(RetVal==ERROR_MORE_DATA) { // Since *lpBufferSize is the size in cch, we should be able to live with it } // Finished return RetVal; } End= [EFunc] TemplateName=wvsprintfW Begin= // Stolen from wsprintf.c in the NT sources #define WSPRINTF_LIMIT 1024 const ULONG MAX_ULONG = 0xFFFFFFFF; #define MAXULONG MAX_ULONG #define out(c) if (cchLimit) {*lpOut++=(c); cchLimit--;} else goto errorout int __stdcall GodotwvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, va_list arglist) { BOOL fAllocateMem; WCHAR prefix, fillch; int left, width, prec, size, sign, radix, upper, hprefix; int cchLimit = WSPRINTF_LIMIT, cch; LPWSTR lpT; LPWSTR lpTWC = NULL; LPBYTE psz; va_list varglist = arglist; union { LONG64 l; ULONG64 ul; char sz[2]; WCHAR wsz[2]; } val; while (*lpFmt != 0) { if (*lpFmt == L'%') { /* * read the flags. These can be in any order */ left = 0; prefix = 0; while (*++lpFmt) { if (*lpFmt == L'-') left++; else if (*lpFmt == L'#') prefix++; else break; } /* * find fill character */ if (*lpFmt == L'0') { fillch = L'0'; lpFmt++; } else fillch = L' '; /* * read the width specification */ lpFmt = SP_GetFmtValueW(lpFmt, &cch); width = cch; /* * read the precision */ if (*lpFmt == L'.') { lpFmt = SP_GetFmtValueW(++lpFmt, &cch); prec = cch; } else prec = -1; /* * get the operand size * default size: size == 0 * long number: size == 1 * wide chars: size == 2 * 64bit number: size == 3 * It may be a good idea to check the value of size when it * is tested for non-zero below (IanJa) */ hprefix = 0; if ((*lpFmt == L'w') || (*lpFmt == L't')) { size = 2; lpFmt++; } else if (*lpFmt == L'l') { size = 1; lpFmt++; } else if (*lpFmt == L'I') { if (*(lpFmt+1) == L'3' && *(lpFmt+2) == L'2') { size = 1; lpFmt += 3; } else if (*(lpFmt+1) == L'6' && *(lpFmt+2) == L'4') { size = 3; lpFmt += 3; } else { size = (sizeof(INT_PTR) == sizeof(LONG)) ? 1 : 3; lpFmt++; } } else { size = 0; if (*lpFmt == L'h') { lpFmt++; hprefix = 1; } else if ((*lpFmt == L'i') || (*lpFmt == L'd')) { // %i or %d specified (no modifiers) - use long // %u seems to have always been short - leave alone size = 1; } } upper = 0; sign = 0; radix = 10; switch (*lpFmt) { case 0: goto errorout; case L'i': case L'd': sign++; /*** FALL THROUGH to case 'u' ***/ case L'u': /* turn off prefix if decimal */ prefix = 0; donumeric: /* special cases to act like MSC v5.10 */ if (left || prec >= 0) fillch = L' '; /* * if size == 1, "%lu" was specified (good); * if size == 2, "%wu" was specified (bad) * if size == 3, "%p" was specified */ if (size == 3) { val.l = va_arg(varglist, LONG64); } else if (size) { val.l = va_arg(varglist, LONG); } else if (sign) { val.l = va_arg(varglist, SHORT); } else { val.ul = va_arg(varglist, unsigned); } if (sign && val.l < 0L) val.l = -val.l; else sign = 0; /* * Unless printing a full 64-bit value, ensure values * here are not in canonical longword format to prevent * the sign extended upper 32-bits from being printed. */ if (size != 3) { val.l &= MAXULONG; } lpT = lpOut; /* * blast the number backwards into the user buffer */ cch = SP_PutNumberW(lpOut, val.l, cchLimit, radix, upper); if (!(cchLimit -= cch)) goto errorout; lpOut += cch; width -= cch; prec -= cch; if (prec > 0) width -= prec; /* * fill to the field precision */ while (prec-- > 0) out(L'0'); if (width > 0 && !left) { /* * if we're filling with spaces, put sign first */ if (fillch != L'0') { if (sign) { sign = 0; out(L'-'); width--; } if (prefix) { out(prefix); out(L'0'); prefix = 0; } } if (sign) width--; /* * fill to the field width */ while (width-- > 0) out(fillch); /* * still have a sign? */ if (sign) out(L'-'); if (prefix) { out(prefix); out(L'0'); } /* * now reverse the string in place */ SP_ReverseW(lpT, lpOut - 1); } else { /* * add the sign character */ if (sign) { out(L'-'); width--; } if (prefix) { out(prefix); out(L'0'); } /* * reverse the string in place */ SP_ReverseW(lpT, lpOut - 1); /* * pad to the right of the string in case left aligned */ while (width-- > 0) out(fillch); } break; case L'p': size = (sizeof(PVOID) == sizeof(LONG)) ? 1 : 3; if (prec == -1) { prec = 2 * sizeof(PVOID); } /*** FALL THROUGH to case 'X' ***/ case L'X': upper++; /*** FALL THROUGH to case 'x' ***/ case L'x': radix = 16; if (prefix) if (upper) prefix = L'X'; else prefix = L'x'; goto donumeric; case L'c': if (!size && !hprefix) { size = 1; // force WCHAR } /*** FALL THROUGH to case 'C' ***/ case L'C': /* * if size == 0, "%C" or "%hc" was specified (CHAR); * if size == 1, "%c" or "%lc" was specified (WCHAR); * if size == 2, "%wc" or "%tc" was specified (WCHAR) */ cch = 1; /* One character must be copied to the output buffer */ if (size) { val.wsz[0] = va_arg(varglist, WCHAR); val.wsz[1] = 0; lpT = val.wsz; goto putwstring; } else { val.sz[0] = va_arg(varglist, CHAR); val.sz[1] = 0; psz = (LPBYTE)val.sz; goto putstring; } case L's': if (!size && !hprefix) { size = 1; // force LPWSTR } /*** FALL THROUGH to case 'S' ***/ case L'S': /* * if size == 0, "%S" or "%hs" was specified (LPSTR) * if size == 1, "%s" or "%ls" was specified (LPWSTR); * if size == 2, "%ws" or "%ts" was specified (LPWSTR) */ if (size) { lpT = va_arg(varglist, LPWSTR); cch = gwcslen(lpT); putwstring: fAllocateMem = FALSE; } else { psz = va_arg(varglist, LPBYTE); if (psz == NULL) { cch = 0; } else { cch = strlen((LPSTR)psz); } putstring: lpTWC = GodotHeapAlloc(cch * sizeof(WCHAR)); if(lpTWC) { cch = MultiByteToWideChar(g_acp, 0, (LPSTR)psz, cch, lpTWC, cch); fAllocateMem = TRUE; } else { cch = 0; fAllocateMem = FALSE; } lpT = lpTWC; } if (prec >= 0 && cch > prec) cch = prec; width -= cch; if (fAllocateMem) { if (cch + (width < 0 ? 0 : width) >= cchLimit) { GodotHeapFree(lpTWC); goto errorout; } } if (left) { while (cch--) out(*lpT++); while (width-- > 0) out(fillch); } else { while (width-- > 0) out(fillch); while (cch--) out(*lpT++); } if (fAllocateMem) { GodotHeapFree(lpTWC); } break; default: normalch: out((WCHAR)*lpFmt); break; } /* END OF SWITCH(*lpFmt) */ } /* END OF IF(%) */ else goto normalch; /* character not a '%', just do it */ /* * advance to next format string character */ lpFmt++; } /* END OF OUTER WHILE LOOP */ errorout: *lpOut = 0; return WSPRINTF_LIMIT - cchLimit; } End= [EFunc] TemplateName=wsprintfW Begin= int _cdecl GodotwsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, ... ) { va_list arglist; int RetVal; va_start(arglist, lpFmt); RetVal = GodotwvsprintfW(lpOut, lpFmt, arglist); va_end(arglist); return RetVal; } End=