/* * PROJECT: ReactOS SDK * LICENSE: MIT (https://spdx.org/licenses/MIT) * PURPOSE: shlwapi header * COPYRIGHT: Copyright 2025 Carl Bialorucki (carl.bialorucki@reactos.org) */ #ifndef _INC_SHLWAPI #define _INC_SHLWAPI #ifndef NOSHLWAPI #include #include #include #include #ifndef WINSHLWAPI #ifdef __GNUC__ /* FIXME: HACK: CORE-6504 */ #define LWSTDAPI_(t) t WINAPI #define LWSTDAPIV_(t) t WINAPIV #else #ifndef _SHLWAPI_ #define LWSTDAPI_(t) EXTERN_C DECLSPEC_IMPORT t STDAPICALLTYPE #define LWSTDAPIV_(t) EXTERN_C DECLSPEC_IMPORT t STDAPIVCALLTYPE #else #define LWSTDAPI_(t) STDAPI_(t) #define LWSTDAPIV_(t) STDAPIV_(t) #endif // _SHLWAPI_ #endif // __GNUC__ #define LWSTDAPI LWSTDAPI_(HRESULT) #define LWSTDAPIV LWSTDAPIV_(HRESULT) #endif // WINSHLWAPI #ifdef __cplusplus extern "C" { #endif /* * GLOBAL SHLWAPI DEFINITIONS * These definitions are always available. */ /* SHAutoComplete definitions */ #define SHACF_DEFAULT 0x00000000 #define SHACF_FILESYSTEM 0x00000001 #define SHACF_URLHISTORY 0x00000002 #define SHACF_URLMRU 0x00000004 #define SHACF_URLALL (SHACF_URLHISTORY|SHACF_URLMRU) #define SHACF_USETAB 0x00000008 #define SHACF_FILESYS_ONLY 0x00000010 #if (_WIN32_IE >= _WIN32_IE_IE60) #define SHACF_FILESYS_DIRS 0x00000020 #endif // _WIN32_IE_IE60 #if (_WIN32_IE >= _WIN32_IE_IE70) #define SHACF_VIRTUAL_NAMESPACE 0x00000040 #endif // _WIN32_IE_IE70 #define SHACF_AUTOSUGGEST_FORCE_ON 0x10000000 #define SHACF_AUTOSUGGEST_FORCE_OFF 0x20000000 #define SHACF_AUTOAPPEND_FORCE_ON 0x40000000 #define SHACF_AUTOAPPEND_FORCE_OFF 0x80000000 LWSTDAPI SHAutoComplete(_In_ HWND, DWORD); LWSTDAPI SHGetThreadRef(_Outptr_ IUnknown**); LWSTDAPI SHSetThreadRef(_In_opt_ IUnknown*); LWSTDAPI_(BOOL) SHCreateThread(_In_ LPTHREAD_START_ROUTINE pfnThreadProc, _In_opt_ void* pData, _In_ DWORD flags, _In_opt_ LPTHREAD_START_ROUTINE pfnCallback); LWSTDAPI_(BOOL) SHSkipJunction(_In_opt_ struct IBindCtx*, _In_ const CLSID*); /* SHCreateThread definitions */ enum { CTF_INSIST = 0x0001, CTF_THREAD_REF = 0x0002, CTF_PROCESS_REF = 0x0004, CTF_COINIT_STA = 0x0008, CTF_COINIT = 0x0008, #if (_WIN32_IE >= _WIN32_IE_IE60) CTF_FREELIBANDEXIT = 0x0010, CTF_REF_COUNTED = 0x0020, CTF_WAIT_ALLOWCOM = 0x0040, #endif // _WIN32_IE_IE60 #if (_WIN32_IE >= _WIN32_IE_IE70) CTF_UNUSED = 0x0080, CTF_INHERITWOW64 = 0x0100, #endif // _WIN32_IE_IE70 #if (NTDDI_VERSION >= NTDDI_VISTA) CTF_WAIT_NO_REENTRANCY = 0x0200, #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_WIN7) CTF_KEYBOARD_LOCALE = 0x0400, CTF_OLEINITIALIZE = 0x0800, CTF_COINIT_MTA = 0x1000, CTF_NOADDREFLIB = 0x2000, #endif // NTDDI_VERSION >= NTDDI_WIN7 }; /* SHFormatDateTime definitions */ #define FDTF_SHORTTIME 0x00000001 #define FDTF_SHORTDATE 0x00000002 #define FDTF_DEFAULT (FDTF_SHORTDATE | FDTF_SHORTTIME) #define FDTF_LONGDATE 0x00000004 #define FDTF_LONGTIME 0x00000008 #define FDTF_RELATIVE 0x00000010 #define FDTF_LTRDATE 0x00000100 #define FDTF_RTLDATE 0x00000200 #define FDTF_NOAUTOREADINGORDER 0x00000400 /* DLL version definitions */ #define DLLVER_MAJOR_MASK 0xFFFF000000000000 #define DLLVER_MINOR_MASK 0x0000FFFF00000000 #define DLLVER_BUILD_MASK 0x00000000FFFF0000 #define DLLVER_QFE_MASK 0x000000000000FFFF #define MAKEDLLVERULL(major, minor, build, qfe) \ (((ULONGLONG)(major) << 48) | ((ULONGLONG)(minor) << 32) | ((ULONGLONG)(build) << 16) | (ULONGLONG)(qfe)) #define DLLVER_PLATFORM_WINDOWS 0x01 // Windows 9.x #define DLLVER_PLATFORM_NT 0x02 // Windows NT typedef struct _DllVersionInfo { DWORD cbSize; DWORD dwMajorVersion; DWORD dwMinorVersion; DWORD dwBuildNumber; DWORD dwPlatformID; } DLLVERSIONINFO; typedef HRESULT (CALLBACK *DLLGETVERSIONPROC)(DLLVERSIONINFO *); typedef struct _DLLVERSIONINFO2 { DLLVERSIONINFO info1; DWORD dwFlags; ULONGLONG ullVersion; } DLLVERSIONINFO2; STDAPI DllInstall(BOOL, _In_opt_ LPCWSTR) DECLSPEC_HIDDEN; /* QueryInterface definitions */ typedef struct { const IID *piid; #if defined(__REACTOS__) || (WINVER >= _WIN32_WINNT_WIN10) DWORD dwOffset; #else int dwOffset; #endif } QITAB, *LPQITAB; #define OFFSETOFCLASS(base, derived) \ ((DWORD)(DWORD_PTR)(static_cast((derived*)8))-8) #define QITABENTMULTI(Cthis, Ifoo, Iimpl) { &IID_##Ifoo, OFFSETOFCLASS(Iimpl, Cthis) } #define QITABENT(Cthis, Ifoo) QITABENTMULTI(Cthis, Ifoo, Ifoo) STDAPI QISearch(_Inout_ void* base, _In_ const QITAB *pqit, _In_ REFIID riid, _Outptr_ void **ppv); /* Miscellaneous shell functions */ LWSTDAPI_(int) GetMenuPosFromID(_In_ HMENU hMenu, _In_ UINT uID); LWSTDAPI_(void) IUnknown_AtomicRelease(_Inout_opt_ IUnknown **punk); LWSTDAPI_(void) IUnknown_Set(_Inout_ IUnknown **ppunk, _In_opt_ IUnknown *punk); LWSTDAPI IUnknown_GetWindow(_In_ IUnknown *punk, _Out_ HWND *phwnd); LWSTDAPI IUnknown_SetSite(_In_ IUnknown *punk, _In_opt_ IUnknown *punkSite); LWSTDAPI IUnknown_GetSite(_In_ IUnknown *punk, _In_ REFIID riid, _Outptr_ void **ppv); LWSTDAPI IUnknown_QueryService(_In_opt_ IUnknown *punk, _In_ REFGUID guidService, _In_ REFIID riid, _Outptr_ void **ppvOut); LWSTDAPI IStream_Size(_In_ IStream *pstm, _Out_ ULARGE_INTEGER *pui); /* Version gated definitions */ #if (_WIN32_IE >= _WIN32_IE_IE60) #define SHGVSPB_PERUSER 0x00000001 #define SHGVSPB_ALLUSERS 0x00000002 #define SHGVSPB_PERFOLDER 0x00000004 #define SHGVSPB_ALLFOLDERS 0x00000008 #define SHGVSPB_INHERIT 0x00000010 #define SHGVSPB_ROAM 0x00000020 #define SHGVSPB_NOAUTODEFAULTS 0x80000000 #define SHGVSPB_FOLDER (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER) #define SHGVSPB_FOLDERNODEFAULTS (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER | SHGVSPB_NOAUTODEFAULTS) #define SHGVSPB_USERDEFAULTS (SHGVSPB_PERUSER | SHGVSPB_ALLFOLDERS) #define SHGVSPB_GLOBALDEFAULTS (SHGVSPB_ALLUSERS | SHGVSPB_ALLFOLDERS) LWSTDAPI SHGetViewStatePropertyBag(_In_opt_ PCIDLIST_ABSOLUTE pidl, _In_opt_ LPCWSTR bag_name, _In_ DWORD flags, _In_ REFIID riid, _Outptr_ void **ppv); LWSTDAPI SHReleaseThreadRef(void); #endif // (_WIN32_IE >= _WIN32_IE_IE60) #if (_WIN32_IE >= 0x0602) LWSTDAPI_(BOOL) IsInternetESCEnabled(void); #endif // (_WIN32_IE >= 0x0602) /* According to Geoff Chappell, SHAllocShared, SHFreeShared, SHLockShared, and SHUnlockShared * were available in shlwapi.dll starting with IE40. However, Microsoft didn't expose them * in their public shlwapi header until IE60SP2. */ #if (_WIN32_IE >= _WIN32_IE_IE60SP2) LWSTDAPI_(HANDLE) SHAllocShared(_In_opt_ const void *pvData, _In_ DWORD dwSize, _In_ DWORD dwDestinationProcessId); LWSTDAPI_(BOOL) SHFreeShared(_In_ HANDLE hData, _In_ DWORD dwProcessId); LWSTDAPI_(PVOID) SHLockShared(_In_ HANDLE hData, _In_ DWORD dwProcessId); LWSTDAPI_(BOOL) SHUnlockShared(_In_ void *pvData); LWSTDAPI SHCreateThreadRef(_Inout_ LONG*, _Outptr_ IUnknown**); #endif // _WIN32_IE >= _WIN32_IE_IE60SP2 /* * OPTIONAL SHLWAPI DEFINITIONS * These definitions can be turned on or off depending on what constants are defined. * * | Constant | Effect | * |--------------------|-----------------------------| * | NO_SHLWAPI_GDI | Disables GDI functions | * | NO_SHLWAPI_ISOS | Disables IsOS function | * | NO_SHLWAPI_PATH | Disables path functions | * | NO_SHLWAPI_REG | Disables registry functions | * | NO_SHLWAPI_STREAM | Disables stream functions | * | NO_SHLWAPI_STRFCNS | Disables string functions | */ /* GDI functions */ #ifndef NO_SHLWAPI_GDI LWSTDAPI_(COLORREF) ColorAdjustLuma(COLORREF,int,BOOL); LWSTDAPI_(COLORREF) ColorHLSToRGB(WORD,WORD,WORD); LWSTDAPI_(void) ColorRGBToHLS(COLORREF, _Out_ LPWORD, _Out_ LPWORD, _Out_ LPWORD); LWSTDAPI_(HPALETTE) SHCreateShellPalette(_In_opt_ HDC); #endif // NO_SHLWAPI_GDI /* IsOS function */ #ifndef NO_SHLWAPI_ISOS #define OS_WINDOWS 0 #define OS_NT 1 #define OS_WIN95ORGREATER 2 #define OS_NT4ORGREATER 3 /* 4 is omitted on purpose */ #define OS_WIN98ORGREATER 5 #define OS_WIN98_GOLD 6 #define OS_WIN2000ORGREATER 7 #define OS_WIN2000PRO 8 #define OS_WIN2000SERVER 9 #define OS_WIN2000ADVSERVER 10 #define OS_WIN2000DATACENTER 11 #define OS_WIN2000TERMINAL 12 #define OS_EMBEDDED 13 #define OS_TERMINALCLIENT 14 #define OS_TERMINALREMOTEADMIN 15 #define OS_WIN95_GOLD 16 #define OS_MEORGREATER 17 #define OS_XPORGREATER 18 #define OS_HOME 19 #define OS_PROFESSIONAL 20 #define OS_DATACENTER 21 #define OS_ADVSERVER 22 #define OS_SERVER 23 #define OS_TERMINALSERVER 24 #define OS_PERSONALTERMINALSERVER 25 #define OS_FASTUSERSWITCHING 26 #define OS_WELCOMELOGONUI 27 #define OS_DOMAINMEMBER 28 #define OS_ANYSERVER 29 #define OS_WOW6432 30 #define OS_WEBSERVER 31 #define OS_SMALLBUSINESSSERVER 32 #define OS_TABLETPC 33 #define OS_SERVERADMINUI 34 #define OS_MEDIACENTER 35 #define OS_APPLIANCE 36 LWSTDAPI_(BOOL) IsOS(DWORD dwOS); #endif // NO_SHLWAPI_ISOS /* Path functions */ #ifndef NO_SHLWAPI_PATH #define GCT_INVALID 0x0 #define GCT_LFNCHAR 0x1 #define GCT_SHORTCHAR 0x2 #define GCT_WILD 0x4 #define GCT_SEPARATOR 0x8 LWSTDAPI HashData(_In_reads_bytes_(cbData) const unsigned char *, DWORD cbData, _Out_writes_bytes_(cbHash) unsigned char *lpDest, DWORD cbHash); #if (_WIN32_IE >= _WIN32_IE_IE70) LWSTDAPI PathCreateFromUrlAlloc(_In_ LPCWSTR pszUrl, _Outptr_ LPWSTR* pszPath, DWORD dwReserved); #endif // _WIN32_IE_IE70 LWSTDAPI_(LPSTR) PathAddBackslashA(_Inout_updates_(MAX_PATH) LPSTR); LWSTDAPI_(LPWSTR) PathAddBackslashW(_Inout_updates_(MAX_PATH) LPWSTR); LWSTDAPI_(BOOL) PathAddExtensionA(_Inout_updates_(MAX_PATH) LPSTR, _In_opt_ LPCSTR); LWSTDAPI_(BOOL) PathAddExtensionW(_Inout_updates_(MAX_PATH) LPWSTR,_In_opt_ LPCWSTR); LWSTDAPI_(BOOL) PathAppendA(_Inout_updates_(MAX_PATH) LPSTR, _In_ LPCSTR); LWSTDAPI_(BOOL) PathAppendW(_Inout_updates_(MAX_PATH) LPWSTR, _In_ LPCWSTR); LWSTDAPI_(LPSTR) PathBuildRootA(_Out_writes_(4) LPSTR, int); LWSTDAPI_(LPWSTR) PathBuildRootW(_Out_writes_(4) LPWSTR, int); LWSTDAPI_(BOOL) PathCanonicalizeA(_Out_writes_(MAX_PATH) LPSTR, _In_ LPCSTR); LWSTDAPI_(BOOL) PathCanonicalizeW(_Out_writes_(MAX_PATH) LPWSTR, _In_ LPCWSTR); LWSTDAPI_(LPSTR) PathCombineA(_Out_writes_(MAX_PATH) LPSTR, _In_opt_ LPCSTR, _In_opt_ LPCSTR); LWSTDAPI_(LPWSTR) PathCombineW(_Out_writes_(MAX_PATH) LPWSTR, _In_opt_ LPCWSTR, _In_opt_ LPCWSTR); LWSTDAPI_(BOOL) PathCompactPathA(_In_opt_ HDC, _Inout_updates_(MAX_PATH) LPSTR, _In_ UINT); LWSTDAPI_(BOOL) PathCompactPathW(_In_opt_ HDC, _Inout_updates_(MAX_PATH) LPWSTR, _In_ UINT); LWSTDAPI_(BOOL) PathCompactPathExA(_Out_writes_(cchMax) LPSTR, _In_ LPCSTR, _In_ UINT cchMax, _In_ DWORD); LWSTDAPI_(BOOL) PathCompactPathExW(_Out_writes_(cchMax) LPWSTR, _In_ LPCWSTR, _In_ UINT cchMax, _In_ DWORD); LWSTDAPI_(int) PathCommonPrefixA(_In_ LPCSTR, _In_ LPCSTR, _Out_writes_opt_(MAX_PATH) LPSTR); LWSTDAPI_(int) PathCommonPrefixW(_In_ LPCWSTR, _In_ LPCWSTR, _Out_writes_opt_(MAX_PATH) LPWSTR); LWSTDAPI PathCreateFromUrlA(_In_ LPCSTR, _Out_writes_to_(*pcchPath, *pcchPath) LPSTR, _Inout_ LPDWORD pcchPath, DWORD); LWSTDAPI PathCreateFromUrlW(_In_ LPCWSTR pszUrl, _Out_writes_to_(*pcchPath, *pcchPath) LPWSTR pszPath, _Inout_ LPDWORD pcchPath, DWORD dwFlags); LWSTDAPI_(BOOL) PathFileExistsA(_In_ LPCSTR pszPath); LWSTDAPI_(BOOL) PathFileExistsW(_In_ LPCWSTR pszPath); LWSTDAPI_(LPSTR) PathFindExtensionA(_In_ LPCSTR pszPath); LWSTDAPI_(LPWSTR) PathFindExtensionW(_In_ LPCWSTR pszPath); LWSTDAPI_(LPSTR) PathFindFileNameA(_In_ LPCSTR pszPath); LWSTDAPI_(LPWSTR) PathFindFileNameW(_In_ LPCWSTR pszPath); LWSTDAPI_(LPSTR) PathFindNextComponentA(_In_ LPCSTR); LWSTDAPI_(LPWSTR) PathFindNextComponentW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathFindOnPathA(_Inout_updates_(MAX_PATH) LPSTR, _In_opt_ LPCSTR*); LWSTDAPI_(BOOL) PathFindOnPathW(_Inout_updates_(MAX_PATH) LPWSTR, _In_opt_ LPCWSTR*); LWSTDAPI_(LPCSTR) PathFindSuffixArrayA(_In_ LPCSTR, _In_reads_(iArraySize) LPCSTR *, int iArraySize); LWSTDAPI_(LPCWSTR) PathFindSuffixArrayW(_In_ LPCWSTR, _In_reads_(iArraySize) LPCWSTR *, int iArraySize); LWSTDAPI_(LPSTR) PathGetArgsA(_In_ LPCSTR pszPath); LWSTDAPI_(LPWSTR) PathGetArgsW(_In_ LPCWSTR pszPath); LWSTDAPI_(UINT) PathGetCharTypeA(_In_ UCHAR ch); LWSTDAPI_(UINT) PathGetCharTypeW(_In_ WCHAR ch); LWSTDAPI_(int) PathGetDriveNumberA(_In_ LPCSTR); LWSTDAPI_(int) PathGetDriveNumberW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsContentTypeA(_In_ LPCSTR, _In_ LPCSTR); LWSTDAPI_(BOOL) PathIsContentTypeW(_In_ LPCWSTR, _In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsDirectoryA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathIsDirectoryW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsDirectoryEmptyA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathIsDirectoryEmptyW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsFileSpecA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathIsFileSpecW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsLFNFileSpecA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathIsLFNFileSpecW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsNetworkPathA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathIsNetworkPathW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsPrefixA(_In_ LPCSTR, _In_ LPCSTR); LWSTDAPI_(BOOL) PathIsPrefixW(_In_ LPCWSTR, _In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsRelativeA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathIsRelativeW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsRootA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathIsRootW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsSameRootA(_In_ LPCSTR, _In_ LPCSTR); LWSTDAPI_(BOOL) PathIsSameRootW(_In_ LPCWSTR, _In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsSystemFolderA(_In_opt_ LPCSTR, _In_ DWORD); LWSTDAPI_(BOOL) PathIsSystemFolderW(_In_opt_ LPCWSTR, _In_ DWORD); LWSTDAPI_(BOOL) PathIsUNCA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathIsUNCW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsUNCServerA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathIsUNCServerW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsUNCServerShareA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathIsUNCServerShareW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathIsURLA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathIsURLW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathMakePrettyA(_Inout_ LPSTR); LWSTDAPI_(BOOL) PathMakePrettyW(_Inout_ LPWSTR); LWSTDAPI_(BOOL) PathMakeSystemFolderA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathMakeSystemFolderW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathMatchSpecA(_In_ LPCSTR pszFile, _In_ LPCSTR pszSpec); LWSTDAPI_(BOOL) PathMatchSpecW(_In_ LPCWSTR pszFile, _In_ LPCWSTR pszSpec); #if (_WIN32_IE >= _WIN32_IE_IE70) LWSTDAPI PathMatchSpecExA(_In_ LPCSTR, _In_ LPCSTR, _In_ DWORD); LWSTDAPI PathMatchSpecExW(_In_ LPCWSTR, _In_ LPCWSTR, _In_ DWORD); #endif // _WIN32_IE_IE70 LWSTDAPI_(int) PathParseIconLocationA(_Inout_ LPSTR); LWSTDAPI_(int) PathParseIconLocationW(_Inout_ LPWSTR); LWSTDAPI_(BOOL) PathQuoteSpacesA(_Inout_updates_(MAX_PATH) LPSTR); LWSTDAPI_(BOOL) PathQuoteSpacesW(_Inout_updates_(MAX_PATH) LPWSTR); LWSTDAPI_(BOOL) PathRelativePathToA(_Out_writes_(MAX_PATH) LPSTR, _In_ LPCSTR, _In_ DWORD, _In_ LPCSTR, _In_ DWORD); LWSTDAPI_(BOOL) PathRelativePathToW(_Out_writes_(MAX_PATH) LPWSTR, _In_ LPCWSTR, _In_ DWORD, _In_ LPCWSTR, _In_ DWORD); LWSTDAPI_(void) PathRemoveArgsA(_Inout_ LPSTR); LWSTDAPI_(void) PathRemoveArgsW(_Inout_ LPWSTR); LWSTDAPI_(LPSTR) PathRemoveBackslashA(_Inout_ LPSTR); LWSTDAPI_(LPWSTR) PathRemoveBackslashW(_Inout_ LPWSTR); LWSTDAPI_(void) PathRemoveBlanksA(_Inout_ LPSTR); LWSTDAPI_(void) PathRemoveBlanksW(_Inout_ LPWSTR); LWSTDAPI_(void) PathRemoveExtensionA(_Inout_ LPSTR); LWSTDAPI_(void) PathRemoveExtensionW(_Inout_ LPWSTR); LWSTDAPI_(BOOL) PathRemoveFileSpecA(_Inout_ LPSTR); LWSTDAPI_(BOOL) PathRemoveFileSpecW(_Inout_ LPWSTR); LWSTDAPI_(BOOL) PathRenameExtensionA(_Inout_updates_(MAX_PATH) LPSTR, _In_ LPCSTR); LWSTDAPI_(BOOL) PathRenameExtensionW(_Inout_updates_(MAX_PATH) LPWSTR, _In_ LPCWSTR); LWSTDAPI_(BOOL) PathSearchAndQualifyA(_In_ LPCSTR, _Out_writes_(cchBuf) LPSTR, _In_ UINT cchBuf); LWSTDAPI_(BOOL) PathSearchAndQualifyW(_In_ LPCWSTR, _Out_writes_(cchBuf) LPWSTR, _In_ UINT cchBuf); LWSTDAPI_(void) PathSetDlgItemPathA(_In_ HWND, int, LPCSTR); LWSTDAPI_(void) PathSetDlgItemPathW(_In_ HWND, int, LPCWSTR); LWSTDAPI_(LPSTR) PathSkipRootA(_In_ LPCSTR); LWSTDAPI_(LPWSTR) PathSkipRootW(_In_ LPCWSTR); LWSTDAPI_(void) PathStripPathA(_Inout_ LPSTR); LWSTDAPI_(void) PathStripPathW(_Inout_ LPWSTR); LWSTDAPI_(BOOL) PathStripToRootA(_Inout_ LPSTR); LWSTDAPI_(BOOL) PathStripToRootW(_Inout_ LPWSTR); LWSTDAPI_(void) PathUndecorateA(_Inout_ LPSTR); LWSTDAPI_(void) PathUndecorateW(_Inout_ LPWSTR); LWSTDAPI_(BOOL) PathUnExpandEnvStringsA(_In_ LPCSTR, _Out_writes_(cchBuf) LPSTR, _In_ UINT cchBuf); LWSTDAPI_(BOOL) PathUnExpandEnvStringsW(_In_ LPCWSTR, _Out_writes_(cchBuf) LPWSTR, _In_ UINT cchBuf); LWSTDAPI_(BOOL) PathUnmakeSystemFolderA(_In_ LPCSTR); LWSTDAPI_(BOOL) PathUnmakeSystemFolderW(_In_ LPCWSTR); LWSTDAPI_(BOOL) PathUnquoteSpacesA(_Inout_ LPSTR); LWSTDAPI_(BOOL) PathUnquoteSpacesW(_Inout_ LPWSTR); #ifdef UNICODE #define PathAddBackslash PathAddBackslashW #define PathAddExtension PathAddExtensionW #define PathAppend PathAppendW #define PathBuildRoot PathBuildRootW #define PathCanonicalize PathCanonicalizeW #define PathCombine PathCombineW #define PathCompactPath PathCompactPathW #define PathCompactPathEx PathCompactPathExW #define PathCommonPrefix PathCommonPrefixW #define PathCreateFromUrl PathCreateFromUrlW #define PathFileExists PathFileExistsW #define PathFindExtension PathFindExtensionW #define PathFindFileName PathFindFileNameW #define PathFindNextComponent PathFindNextComponentW #define PathFindOnPath PathFindOnPathW #define PathFindSuffixArray PathFindSuffixArrayW #define PathGetArgs PathGetArgsW #define PathGetCharType PathGetCharTypeW #define PathGetDriveNumber PathGetDriveNumberW #define PathIsContentType PathIsContentTypeW #define PathIsDirectory PathIsDirectoryW #define PathIsDirectoryEmpty PathIsDirectoryEmptyW #define PathIsFileSpec PathIsFileSpecW #define PathIsLFNFileSpec PathIsLFNFileSpecW #define PathIsNetworkPath PathIsNetworkPathW #define PathIsPrefix PathIsPrefixW #define PathIsRelative PathIsRelativeW #define PathIsRoot PathIsRootW #define PathIsSameRoot PathIsSameRootW #define PathIsSystemFolder PathIsSystemFolderW #define PathIsUNC PathIsUNCW #define PathIsUNCServer PathIsUNCServerW #define PathIsUNCServerShare PathIsUNCServerShareW #define PathIsURL PathIsURLW #define PathMakePretty PathMakePrettyW #define PathMakeSystemFolder PathMakeSystemFolderW #define PathMatchSpec PathMatchSpecW #if (_WIN32_IE >= _WIN32_IE_IE70) #define PathMatchSpecEx PathMatchSpecExW #endif // _WIN32_IE_IE70 #define PathParseIconLocation PathParseIconLocationW #define PathQuoteSpaces PathQuoteSpacesW #define PathRelativePathTo PathRelativePathToW #define PathRemoveArgs PathRemoveArgsW #define PathRemoveBackslash PathRemoveBackslashW #define PathRemoveBlanks PathRemoveBlanksW #define PathRemoveExtension PathRemoveExtensionW #define PathRemoveFileSpec PathRemoveFileSpecW #define PathRenameExtension PathRenameExtensionW #define PathSearchAndQualify PathSearchAndQualifyW #define PathSetDlgItemPath PathSetDlgItemPathW #define PathSkipRoot PathSkipRootW #define PathStripPath PathStripPathW #define PathStripToRoot PathStripToRootW #define PathUndecorate PathUndecorateW #define PathUnExpandEnvStrings PathUnExpandEnvStringsW #define PathUnmakeSystemFolder PathUnmakeSystemFolderW #define PathUnquoteSpaces PathUnquoteSpacesW #else #define PathAddBackslash PathAddBackslashA #define PathAddExtension PathAddExtensionA #define PathAppend PathAppendA #define PathBuildRoot PathBuildRootA #define PathCanonicalize PathCanonicalizeA #define PathCombine PathCombineA #define PathCompactPath PathCompactPathA #define PathCompactPathEx PathCompactPathExA #define PathCommonPrefix PathCommonPrefixA #define PathCreateFromUrl PathCreateFromUrlA #define PathFileExists PathFileExistsA #define PathFindExtension PathFindExtensionA #define PathFindFileName PathFindFileNameA #define PathFindNextComponent PathFindNextComponentA #define PathFindOnPath PathFindOnPathA #define PathFindSuffixArray PathFindSuffixArrayA #define PathGetArgs PathGetArgsA #define PathGetCharType PathGetCharTypeA #define PathGetDriveNumber PathGetDriveNumberA #define PathIsContentType PathIsContentTypeA #define PathIsDirectory PathIsDirectoryA #define PathIsDirectoryEmpty PathIsDirectoryEmptyA #define PathIsFileSpec PathIsFileSpecA #define PathIsLFNFileSpec PathIsLFNFileSpecA #define PathIsNetworkPath PathIsNetworkPathA #define PathIsPrefix PathIsPrefixA #define PathIsRelative PathIsRelativeA #define PathIsRoot PathIsRootA #define PathIsSameRoot PathIsSameRootA #define PathIsSystemFolder PathIsSystemFolderA #define PathIsUNC PathIsUNCA #define PathIsUNCServer PathIsUNCServerA #define PathIsUNCServerShare PathIsUNCServerShareA #define PathIsURL PathIsURLA #define PathMakePretty PathMakePrettyA #define PathMakeSystemFolder PathMakeSystemFolderA #define PathMatchSpec PathMatchSpecA #if (_WIN32_IE >= _WIN32_IE_IE70) #define PathMatchSpecEx PathMatchSpecExA #endif // _WIN32_IE_IE70 #define PathParseIconLocation PathParseIconLocationA #define PathQuoteSpaces PathQuoteSpacesA #define PathRelativePathTo PathRelativePathToA #define PathRemoveArgs PathRemoveArgsA #define PathRemoveBackslash PathRemoveBackslashA #define PathRemoveBlanks PathRemoveBlanksA #define PathRemoveExtension PathRemoveExtensionA #define PathRemoveFileSpec PathRemoveFileSpecA #define PathRenameExtension PathRenameExtensionA #define PathSearchAndQualify PathSearchAndQualifyA #define PathSetDlgItemPath PathSetDlgItemPathA #define PathSkipRoot PathSkipRootA #define PathStripPath PathStripPathA #define PathStripToRoot PathStripToRootA #define PathUndecorate PathUndecorateA #define PathUnExpandEnvStrings PathUnExpandEnvStringsA #define PathUnmakeSystemFolder PathUnmakeSystemFolderA #define PathUnquoteSpaces PathUnquoteSpacesA #endif // UNICODE #define URL_APPLY_DEFAULT 0x00000001 #define URL_APPLY_GUESSSCHEME 0x00000002 #define URL_APPLY_GUESSFILE 0x00000004 #define URL_APPLY_FORCEAPPLY 0x00000008 #define URL_ESCAPE_PERCENT 0x00001000 #define URL_ESCAPE_SEGMENT_ONLY 0x00002000 #define URL_FILE_USE_PATHURL 0x00010000 #define URL_ESCAPE_AS_UTF8 0x00040000 #define URL_UNESCAPE_INPLACE 0x00100000 #define URL_CONVERT_IF_DOSPATH 0x00200000 #define URL_UNESCAPE_HIGH_ANSI_ONLY 0x00400000 #define URL_INTERNAL_PATH 0x00800000 #define URL_DONT_ESCAPE_EXTRA_INFO 0x02000000 #define URL_ESCAPE_SPACES_ONLY 0x04000000 #define URL_DONT_SIMPLIFY 0x08000000 #define URL_UNESCAPE 0x10000000 #define URL_ESCAPE_UNSAFE 0x20000000 #define URL_PLUGGABLE_PROTOCOL 0x40000000 #define URL_WININET_COMPATIBILITY 0x80000000 #define URL_UNESCAPE_AS_UTF8 URL_ESCAPE_AS_UTF8 #define URL_UNESCAPE_URI_COMPONENT URL_UNESCAPE_AS_UTF8 #define URL_NO_META URL_DONT_SIMPLIFY #define URL_DONT_UNESCAPE_EXTRA_INFO URL_DONT_ESCAPE_EXTRA_INFO #define URL_BROWSER_MODE URL_DONT_ESCAPE_EXTRA_INFO typedef enum { URL_SCHEME_INVALID = -1, URL_SCHEME_UNKNOWN = 0, URL_SCHEME_FTP, URL_SCHEME_HTTP, URL_SCHEME_GOPHER, URL_SCHEME_MAILTO, URL_SCHEME_NEWS, URL_SCHEME_NNTP, URL_SCHEME_TELNET, URL_SCHEME_WAIS, URL_SCHEME_FILE, URL_SCHEME_MK, URL_SCHEME_HTTPS, URL_SCHEME_SHELL, URL_SCHEME_SNEWS, URL_SCHEME_LOCAL, URL_SCHEME_JAVASCRIPT, URL_SCHEME_VBSCRIPT, URL_SCHEME_ABOUT, URL_SCHEME_RES, #if (_WIN32_IE >= _WIN32_IE_IE60) URL_SCHEME_MSSHELLROOTED, URL_SCHEME_MSSHELLIDLIST, URL_SCHEME_MSHELP, #endif // _WIN32_IE_IE60 #if (_WIN32_IE >= _WIN32_IE_IE70) URL_SCHEME_MSSHELLDEVICE, URL_SCHEME_WILDCARD, #endif // _WIN32_IE_IE70 #if (NTDDI_VERSION >= NTDDI_VISTA) URL_SCHEME_SEARCH_MS, #endif // NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTASP1) URL_SCHEME_SEARCH, #endif // NTDDI_VISTASP1 #if (NTDDI_VERSION >= NTDDI_WIN7) URL_SCHEME_KNOWNFOLDER, #endif // NTDDI_WIN7 URL_SCHEME_MAXVALUE } URL_SCHEME; typedef enum { URL_PART_NONE = 0, URL_PART_SCHEME = 1, URL_PART_HOSTNAME, URL_PART_USERNAME, URL_PART_PASSWORD, URL_PART_PORT, URL_PART_QUERY } URL_PART; #define URL_PARTFLAG_KEEPSCHEME 0x00000001 typedef enum { URLIS_URL, URLIS_OPAQUE, URLIS_NOHISTORY, URLIS_FILEURL, URLIS_APPLIABLE, URLIS_DIRECTORY, URLIS_HASQUERY } URLIS; typedef struct tagPARSEDURLA { DWORD cbSize; LPCSTR pszProtocol; UINT cchProtocol; LPCSTR pszSuffix; UINT cchSuffix; UINT nScheme; } PARSEDURLA, *PPARSEDURLA; typedef struct tagPARSEDURLW { DWORD cbSize; LPCWSTR pszProtocol; UINT cchProtocol; LPCWSTR pszSuffix; UINT cchSuffix; UINT nScheme; } PARSEDURLW, *PPARSEDURLW; LWSTDAPI UrlApplySchemeA(_In_ LPCSTR, _Out_writes_(*pcchOut) LPSTR, _Inout_ LPDWORD pcchOut, DWORD); LWSTDAPI UrlApplySchemeW(_In_ LPCWSTR, _Out_writes_(*pcchOut) LPWSTR, _Inout_ LPDWORD pcchOut, DWORD); LWSTDAPI UrlCanonicalizeA(_In_ LPCSTR, _Out_writes_to_(*pcchCanonicalized, *pcchCanonicalized) LPSTR, _Inout_ LPDWORD pcchCanonicalized, DWORD); LWSTDAPI UrlCanonicalizeW(_In_ LPCWSTR, _Out_writes_to_(*pcchCanonicalized, *pcchCanonicalized) LPWSTR, _Inout_ LPDWORD pcchCanonicalized, DWORD); LWSTDAPI UrlCombineA(_In_ LPCSTR, _In_ LPCSTR, _Out_writes_to_opt_(*pcchCombined, *pcchCombined) LPSTR, _Inout_ LPDWORD pcchCombined, DWORD); LWSTDAPI UrlCombineW(_In_ LPCWSTR, _In_ LPCWSTR, _Out_writes_to_opt_(*pcchCombined, *pcchCombined) LPWSTR, _Inout_ LPDWORD pcchCombined, DWORD); LWSTDAPI_(int) UrlCompareA(_In_ LPCSTR, _In_ LPCSTR, BOOL); LWSTDAPI_(int) UrlCompareW(_In_ LPCWSTR, _In_ LPCWSTR, BOOL); LWSTDAPI UrlEscapeA(_In_ LPCSTR, _Out_writes_to_(*pcchEscaped, *pcchEscaped) LPSTR, _Inout_ LPDWORD pcchEscaped, DWORD); LWSTDAPI UrlEscapeW(_In_ LPCWSTR, _Out_writes_to_(*pcchEscaped, *pcchEscaped) LPWSTR, _Inout_ LPDWORD pcchEscaped, DWORD); LWSTDAPI_(LPCSTR) UrlGetLocationA(_In_ LPCSTR); LWSTDAPI_(LPCWSTR) UrlGetLocationW(_In_ LPCWSTR); LWSTDAPI UrlGetPartA(_In_ LPCSTR, _Out_writes_(*pcchOut) LPSTR, _Inout_ LPDWORD pcchOut, DWORD, DWORD); LWSTDAPI UrlGetPartW(_In_ LPCWSTR, _Out_writes_(*pcchOut) LPWSTR, _Inout_ LPDWORD pcchOut, DWORD, DWORD); LWSTDAPI UrlHashA(_In_ LPCSTR, _Out_writes_bytes_(cbHash) unsigned char *, DWORD cbHash); LWSTDAPI UrlHashW(_In_ LPCWSTR, _Out_writes_bytes_(cbHash) unsigned char *, DWORD cbHash); LWSTDAPI_(BOOL) UrlIsA(_In_ LPCSTR, URLIS); LWSTDAPI_(BOOL) UrlIsW(_In_ LPCWSTR, URLIS); #define UrlIsFileUrlA(x) UrlIsA(x, URLIS_FILEURL) #define UrlIsFileUrlW(x) UrlIsW(x, URLIS_FILEURL) LWSTDAPI_(BOOL) UrlIsNoHistoryA(_In_ LPCSTR); LWSTDAPI_(BOOL) UrlIsNoHistoryW(_In_ LPCWSTR); LWSTDAPI_(BOOL) UrlIsOpaqueA(_In_ LPCSTR); LWSTDAPI_(BOOL) UrlIsOpaqueW(_In_ LPCWSTR); LWSTDAPI UrlUnescapeA(_Inout_ LPSTR, _Out_writes_to_opt_(*pcchUnescaped, *pcchUnescaped) LPSTR, _Inout_opt_ LPDWORD pcchUnescaped, DWORD); LWSTDAPI UrlUnescapeW(_Inout_ LPWSTR, _Out_writes_to_opt_(*pcchUnescaped, *pcchUnescaped) LPWSTR, _Inout_opt_ LPDWORD pcchUnescaped, DWORD); LWSTDAPI UrlCreateFromPathA(_In_ LPCSTR, _Out_writes_to_(*pcchUrl, *pcchUrl) LPSTR, _Inout_ LPDWORD pcchUrl, DWORD); LWSTDAPI UrlCreateFromPathW(_In_ LPCWSTR, _Out_writes_to_(*pcchUrl, *pcchUrl) LPWSTR, _Inout_ LPDWORD pcchUrl, DWORD); LWSTDAPI ParseURLA(_In_ LPCSTR pszUrl, _Inout_ PARSEDURLA *ppu); LWSTDAPI ParseURLW(_In_ LPCWSTR pszUrl, _Inout_ PARSEDURLW *ppu); #ifdef UNICODE #define UrlApplyScheme UrlApplySchemeW #define UrlCanonicalize UrlCanonicalizeW #define UrlCombine UrlCombineW #define UrlCompare UrlCompareW #define UrlEscape UrlEscapeW #define UrlGetLocation UrlGetLocationW #define UrlGetPart UrlGetPartW #define UrlHash UrlHashW #define UrlIs UrlIsW #define UrlIsFileUrl UrlIsFileUrlW #define UrlIsNoHistory UrlIsNoHistoryW #define UrlIsOpaque UrlIsOpaqueW #define UrlUnescape UrlUnescapeW #define UrlCreateFromPath UrlCreateFromPathW #define ParseURL ParseURLW #else #define UrlApplyScheme UrlApplySchemeA #define UrlCanonicalize UrlCanonicalizeA #define UrlCombine UrlCombineA #define UrlCompare UrlCompareA #define UrlEscape UrlEscapeA #define UrlGetLocation UrlGetLocationA #define UrlGetPart UrlGetPartA #define UrlHash UrlHashA #define UrlIs UrlIsA #define UrlIsFileUrl UrlIsFileUrlA #define UrlIsNoHistory UrlIsNoHistoryA #define UrlIsOpaque UrlIsOpaqueA #define UrlUnescape UrlUnescapeA #define UrlCreateFromPath UrlCreateFromPathA #define ParseURL ParseURLA #endif // UNICODE #define UrlEscapeSpaces(x, y, z) UrlCanonicalize(x, y, z, URL_ESCAPE_SPACES_ONLY | URL_DONT_ESCAPE_EXTRA_INFO) #define UrlUnescapeInPlace(x, y) UrlUnescape(x, NULL, NULL, y | URL_UNESCAPE_INPLACE) #endif // NO_SHLWAPI_PATH /* Registry functions */ #ifndef NO_SHLWAPI_REG #define SRRF_RT_REG_NONE 0x0001 #define SRRF_RT_REG_SZ 0x0002 #define SRRF_RT_REG_EXPAND_SZ 0x0004 #define SRRF_RT_REG_BINARY 0x0008 #define SRRF_RT_REG_DWORD 0x0010 #define SRRF_RT_REG_MULTI_SZ 0x0020 #define SRRF_RT_REG_QWORD 0x0040 #define SRRF_RT_ANY 0xFFFF #define SRRF_RT_DWORD (SRRF_RT_REG_BINARY | SRRF_RT_REG_DWORD) #define SRRF_RT_QWORD (SRRF_RT_REG_BINARY | SRRF_RT_REG_QWORD) #define SRRF_RM_ANY 0x00000 #define SRRF_RM_NORMAL 0x10000 #define SRRF_RM_SAFE 0x20000 #define SRRF_RM_SAFENETWORK 0x40000 #define SRRF_NOEXPAND 0x10000000 #define SRRF_ZEROONFAILURE 0x20000000 #define SRRF_NOVIRT 0x40000000 typedef INT SRRF; #define SHREGSET_HKCU 0x1 #define SHREGSET_FORCE_HKCU 0x2 #define SHREGSET_HKLM 0x4 #define SHREGSET_FORCE_HKLM 0x8 #define SHREGSET_DEFAULT (SHREGSET_FORCE_HKCU | SHREGSET_HKLM) typedef enum { SHREGDEL_DEFAULT = 0, SHREGDEL_HKCU = 0x1, SHREGDEL_HKLM = 0x10, SHREGDEL_BOTH = SHREGDEL_HKLM | SHREGDEL_HKCU } SHREGDEL_FLAGS; typedef enum { SHREGENUM_DEFAULT = 0, SHREGENUM_HKCU = 0x1, SHREGENUM_HKLM = 0x10, SHREGENUM_BOTH = SHREGENUM_HKLM | SHREGENUM_HKCU } SHREGENUM_FLAGS; typedef HANDLE HUSKEY; typedef HUSKEY *PHUSKEY; LWSTDAPI_(LONG) SHRegCloseUSKey(_In_ HUSKEY); LWSTDAPI_(HKEY) SHRegDuplicateHKey(_In_ HKEY); LWSTDAPI_(DWORD) SHCopyKeyA(_In_ HKEY, _In_opt_ LPCSTR, _In_ HKEY, _Reserved_ DWORD); LWSTDAPI_(DWORD) SHCopyKeyW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ HKEY, _Reserved_ DWORD); LWSTDAPI_(DWORD) SHDeleteEmptyKeyA(_In_ HKEY, _In_opt_ LPCSTR); LWSTDAPI_(DWORD) SHDeleteEmptyKeyW(_In_ HKEY, _In_opt_ LPCWSTR); LWSTDAPI_(DWORD) SHDeleteKeyA(_In_ HKEY, _In_opt_ LPCSTR); LWSTDAPI_(DWORD) SHDeleteKeyW(_In_ HKEY, _In_opt_ LPCWSTR); LWSTDAPI_(DWORD) SHDeleteOrphanKeyA(HKEY, LPCSTR); LWSTDAPI_(DWORD) SHDeleteOrphanKeyW(HKEY, LPCWSTR); LWSTDAPI_(DWORD) SHDeleteValueA(_In_ HKEY, _In_opt_ LPCSTR, _In_ LPCSTR); LWSTDAPI_(DWORD) SHDeleteValueW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ LPCWSTR); LWSTDAPI_(LONG) SHEnumKeyExA(_In_ HKEY, _In_ DWORD, _Out_writes_(*pcchName) LPSTR, _Inout_ LPDWORD pcchName); LWSTDAPI_(LONG) SHEnumKeyExW(_In_ HKEY, _In_ DWORD, _Out_writes_(*pcchName) LPWSTR, _Inout_ LPDWORD pcchName); LWSTDAPI_(LONG) SHEnumValueA(_In_ HKEY, _In_ DWORD, _Out_writes_opt_(*pcchValueName) LPSTR, _Inout_opt_ LPDWORD pcchValueName, _Out_opt_ LPDWORD, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, _Inout_opt_ LPDWORD pcbData); LWSTDAPI_(LONG) SHEnumValueW(_In_ HKEY, _In_ DWORD, _Out_writes_opt_(*pcchValueName) LPWSTR, _Inout_opt_ LPDWORD pcchValueName, _Out_opt_ LPDWORD, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, _Inout_opt_ LPDWORD pcbData); LWSTDAPI_(DWORD) SHGetValueA(_In_ HKEY, _In_opt_ LPCSTR, _In_opt_ LPCSTR, _Out_opt_ LPDWORD, _Out_writes_bytes_opt_(*pcbData) LPVOID, _Inout_opt_ LPDWORD pcbData); LWSTDAPI_(DWORD) SHGetValueW(_In_ HKEY, _In_opt_ LPCWSTR, _In_opt_ LPCWSTR, _Out_opt_ LPDWORD, _Out_writes_bytes_opt_(*pcbData) LPVOID, _Inout_opt_ LPDWORD pcbData); LWSTDAPI_(DWORD) SHSetValueA(_In_ HKEY, _In_opt_ LPCSTR, _In_opt_ LPCSTR, _In_ DWORD, _In_reads_bytes_opt_(cbData) LPCVOID, _In_ DWORD cbData); LWSTDAPI_(DWORD) SHSetValueW(_In_ HKEY, _In_opt_ LPCWSTR, _In_opt_ LPCWSTR, _In_ DWORD, _In_reads_bytes_opt_(cbData) LPCVOID, _In_ DWORD cbData); LWSTDAPI_(DWORD) SHQueryValueExA(_In_ HKEY, _In_opt_ LPCSTR, _Reserved_ LPDWORD, _Out_opt_ LPDWORD, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, _Inout_opt_ LPDWORD pcbData); LWSTDAPI_(DWORD) SHQueryValueExW(_In_ HKEY, _In_opt_ LPCWSTR, _Reserved_ LPDWORD, _Out_opt_ LPDWORD, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, _Inout_opt_ LPDWORD pcbData); LWSTDAPI_(LONG) SHQueryInfoKeyA(_In_ HKEY, _Out_opt_ LPDWORD, _Out_opt_ LPDWORD, _Out_opt_ LPDWORD, _Out_opt_ LPDWORD); LWSTDAPI_(LONG) SHQueryInfoKeyW(_In_ HKEY, _Out_opt_ LPDWORD, _Out_opt_ LPDWORD, _Out_opt_ LPDWORD, _Out_opt_ LPDWORD); LWSTDAPI_(LONG) SHRegCreateUSKeyA(_In_ LPCSTR, _In_ REGSAM, _In_opt_ HUSKEY, _Out_ PHUSKEY, _In_ DWORD); LWSTDAPI_(LONG) SHRegCreateUSKeyW(_In_ LPCWSTR, _In_ REGSAM, _In_opt_ HUSKEY, _Out_ PHUSKEY, _In_ DWORD); LWSTDAPI_(LONG) SHRegDeleteEmptyUSKeyA(_In_ HUSKEY, _In_ LPCSTR, _In_ SHREGDEL_FLAGS); LWSTDAPI_(LONG) SHRegDeleteEmptyUSKeyW(_In_ HUSKEY, _In_ LPCWSTR, _In_ SHREGDEL_FLAGS); LWSTDAPI_(LONG) SHRegDeleteUSValueA(_In_ HUSKEY, _In_ LPCSTR, _In_ SHREGDEL_FLAGS); LWSTDAPI_(LONG) SHRegDeleteUSValueW(_In_ HUSKEY, _In_ LPCWSTR, _In_ SHREGDEL_FLAGS); LWSTDAPI_(LONG) SHRegEnumUSKeyA(_In_ HUSKEY, _In_ DWORD, _Out_writes_to_(*pcchName, *pcchName) LPSTR, _Inout_ LPDWORD pcchName, _In_ SHREGENUM_FLAGS); LWSTDAPI_(LONG) SHRegEnumUSKeyW(_In_ HUSKEY, _In_ DWORD, _Out_writes_to_(*pcchName, *pcchName) LPWSTR, _Inout_ LPDWORD pcchName, _In_ SHREGENUM_FLAGS); LWSTDAPI_(LONG) SHRegEnumUSValueA(_In_ HUSKEY, _In_ DWORD, _Out_writes_to_(*pcchValueName, *pcchValueName) LPSTR, _Inout_ LPDWORD pcchValueName, _Out_opt_ LPDWORD, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, _Inout_opt_ LPDWORD pcbData, _In_ SHREGENUM_FLAGS); LWSTDAPI_(LONG) SHRegEnumUSValueW(_In_ HUSKEY, _In_ DWORD, _Out_writes_to_(*pcchValueName, *pcchValueName) LPWSTR, _Inout_ LPDWORD pcchValueName, _Out_opt_ LPDWORD, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, _Inout_opt_ LPDWORD pcbData, _In_ SHREGENUM_FLAGS); LWSTDAPI_(BOOL) SHRegGetBoolUSValueA(_In_ LPCSTR, _In_opt_ LPCSTR, _In_ BOOL, _In_ BOOL); LWSTDAPI_(BOOL) SHRegGetBoolUSValueW(_In_ LPCWSTR, _In_opt_ LPCWSTR, _In_ BOOL, _In_ BOOL); LWSTDAPI_(DWORD) SHRegGetPathA(_In_ HKEY, _In_opt_ LPCSTR, _In_opt_ LPCSTR, _Out_writes_(MAX_PATH) LPSTR, _In_ DWORD); LWSTDAPI_(DWORD) SHRegGetPathW(_In_ HKEY, _In_opt_ LPCWSTR, _In_opt_ LPCWSTR, _Out_writes_(MAX_PATH) LPWSTR, _In_ DWORD); LWSTDAPI_(LONG) SHRegGetUSValueA(_In_ LPCSTR, _In_opt_ LPCSTR, _Inout_opt_ LPDWORD, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, _Inout_opt_ LPDWORD pcbData, _In_ BOOL, _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID, _In_ DWORD dwDefaultDataSize); LWSTDAPI_(LONG) SHRegGetUSValueW(_In_ LPCWSTR, _In_opt_ LPCWSTR, _Inout_opt_ LPDWORD, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, _Inout_opt_ LPDWORD pcbData, _In_ BOOL, _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID, _In_ DWORD dwDefaultDataSize); LWSTDAPI_(LSTATUS) SHRegGetValueA(_In_ HKEY hkey, _In_opt_ LPCSTR pszSubKey, _In_opt_ LPCSTR pszValue, _In_ SRRF srrfFlags, _Out_opt_ LPDWORD pdwType, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID pvData, _Inout_opt_ LPDWORD pcbData); LWSTDAPI_(LSTATUS) SHRegGetValueW(_In_ HKEY hkey, _In_opt_ LPCWSTR pszSubKey, _In_opt_ LPCWSTR pszValue, _In_ SRRF srrfFlags, _Out_opt_ LPDWORD pdwType, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID pvData, _Inout_opt_ LPDWORD pcbData); LWSTDAPI_(LONG) SHRegOpenUSKeyA(_In_ LPCSTR, _In_ REGSAM, _In_opt_ HUSKEY, _Out_ PHUSKEY, _In_ BOOL); LWSTDAPI_(LONG) SHRegOpenUSKeyW(_In_ LPCWSTR, _In_ REGSAM, _In_opt_ HUSKEY, _Out_ PHUSKEY, _In_ BOOL); LWSTDAPI_(LONG) SHRegQueryInfoUSKeyA(_In_ HUSKEY, _Out_opt_ LPDWORD, _Out_opt_ LPDWORD, _Out_opt_ LPDWORD, _Out_opt_ LPDWORD, _In_ SHREGENUM_FLAGS); LWSTDAPI_(LONG) SHRegQueryInfoUSKeyW(_In_ HUSKEY, _Out_opt_ LPDWORD, _Out_opt_ LPDWORD, _Out_opt_ LPDWORD, _Out_opt_ LPDWORD, _In_ SHREGENUM_FLAGS); LWSTDAPI_(LONG) SHRegQueryUSValueA(_In_ HUSKEY, _In_opt_ LPCSTR, _Inout_opt_ LPDWORD, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, _Inout_opt_ LPDWORD pcbData, _In_ BOOL, _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID, _In_opt_ DWORD dwDefaultDataSize); LWSTDAPI_(LONG) SHRegQueryUSValueW(_In_ HUSKEY, _In_opt_ LPCWSTR, _Inout_opt_ LPDWORD, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, _Inout_opt_ LPDWORD pcbData, _In_ BOOL, _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID, _In_opt_ DWORD dwDefaultDataSize); LWSTDAPI_(DWORD) SHRegSetPathA(_In_ HKEY, _In_opt_ LPCSTR, _In_opt_ LPCSTR, _In_ LPCSTR, _In_ DWORD); LWSTDAPI_(DWORD) SHRegSetPathW(_In_ HKEY, _In_opt_ LPCWSTR, _In_opt_ LPCWSTR, _In_ LPCWSTR, _In_ DWORD); LWSTDAPI_(LONG) SHRegSetUSValueA(_In_ LPCSTR, _In_ LPCSTR, _In_ DWORD, _In_reads_bytes_opt_(cbData) LPVOID, _In_opt_ DWORD cbData, _In_opt_ DWORD); LWSTDAPI_(LONG) SHRegSetUSValueW(_In_ LPCWSTR, _In_ LPCWSTR, _In_ DWORD, _In_reads_bytes_opt_(cbData) LPVOID, _In_opt_ DWORD cbData, _In_opt_ DWORD); LWSTDAPI_(LONG) SHRegWriteUSValueA(_In_ HUSKEY, _In_ LPCSTR, _In_ DWORD, _In_reads_bytes_(cbData) LPVOID, _In_ DWORD cbData, _In_ DWORD); LWSTDAPI_(LONG) SHRegWriteUSValueW(_In_ HUSKEY, _In_ LPCWSTR, _In_ DWORD, _In_reads_bytes_(cbData) LPVOID, _In_ DWORD cbData, _In_ DWORD); /* This only exists for the -W variant. */ LWSTDAPI_(int) SHRegGetIntW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ int); #ifdef UNICODE #define SHCopyKey SHCopyKeyW #define SHDeleteEmptyKey SHDeleteEmptyKeyW #define SHDeleteKey SHDeleteKeyW #define SHDeleteOrphanKey SHDeleteOrphanKeyW #define SHDeleteValue SHDeleteValueW #define SHEnumKeyEx SHEnumKeyExW #define SHEnumValue SHEnumValueW #define SHGetValue SHGetValueW #define SHSetValue SHSetValueW #define SHQueryValueEx SHQueryValueExW #define SHQueryInfoKey SHQueryInfoKeyW #define SHRegCreateUSKey SHRegCreateUSKeyW #define SHRegDeleteEmptyUSKey SHRegDeleteEmptyUSKeyW #define SHRegDeleteUSValue SHRegDeleteUSValueW #define SHRegEnumUSKey SHRegEnumUSKeyW #define SHRegEnumUSValue SHRegEnumUSValueW #define SHRegGetBoolUSValue SHRegGetBoolUSValueW #define SHRegGetPath SHRegGetPathW #define SHRegGetUSValue SHRegGetUSValueW #define SHRegGetValue SHRegGetValueW #define SHRegOpenUSKey SHRegOpenUSKeyW #define SHRegQueryInfoUSKey SHRegQueryInfoUSKeyW #define SHRegQueryUSValue SHRegQueryUSValueW #define SHRegSetPath SHRegSetPathW #define SHRegSetUSValue SHRegSetUSValueW #define SHRegWriteUSValue SHRegWriteUSValueW #define SHRegGetInt SHRegGetIntW #else #define SHCopyKey SHCopyKeyA #define SHDeleteEmptyKey SHDeleteEmptyKeyA #define SHDeleteKey SHDeleteKeyA #define SHDeleteOrphanKey SHDeleteOrphanKeyA #define SHDeleteValue SHDeleteValueA #define SHEnumKeyEx SHEnumKeyExA #define SHEnumValue SHEnumValueA #define SHGetValue SHGetValueA #define SHSetValue SHSetValueA #define SHQueryValueEx SHQueryValueExA #define SHQueryInfoKey SHQueryInfoKeyA #define SHRegCreateUSKey SHRegCreateUSKeyA #define SHRegDeleteEmptyUSKey SHRegDeleteEmptyUSKeyA #define SHRegDeleteUSValue SHRegDeleteUSValueA #define SHRegEnumUSKey SHRegEnumUSKeyA #define SHRegEnumUSValue SHRegEnumUSValueA #define SHRegGetBoolUSValue SHRegGetBoolUSValueA #define SHRegGetPath SHRegGetPathA #define SHRegGetUSValue SHRegGetUSValueA #define SHRegGetValue SHRegGetValueA #define SHRegOpenUSKey SHRegOpenUSKeyA #define SHRegQueryInfoUSKey SHRegQueryInfoUSKeyA #define SHRegQueryUSValue SHRegQueryUSValueA #define SHRegSetPath SHRegSetPathA #define SHRegSetUSValue SHRegSetUSValueA #define SHRegWriteUSValue SHRegWriteUSValueA #endif // UNICODE enum { ASSOCF_NONE = 0x00000000, ASSOCF_INIT_NOREMAPCLSID = 0x00000001, ASSOCF_INIT_BYEXENAME = 0x00000002, ASSOCF_OPEN_BYEXENAME = 0x00000002, ASSOCF_INIT_DEFAULTTOSTAR = 0x00000004, ASSOCF_INIT_DEFAULTTOFOLDER = 0x00000008, ASSOCF_NOUSERSETTINGS = 0x00000010, ASSOCF_NOTRUNCATE = 0x00000020, ASSOCF_VERIFY = 0x00000040, ASSOCF_REMAPRUNDLL = 0x00000080, ASSOCF_NOFIXUPS = 0x00000100, ASSOCF_IGNOREBASECLASS = 0x00000200, ASSOCF_INIT_IGNOREUNKNOWN = 0x00000400, #if (NTDDI_VERSION >= NTDDI_WIN8) ASSOCF_INIT_FIXED_PROGID = 0x00000800, ASSOCF_IS_PROTOCOL = 0x00001000, ASSOCF_INIT_FOR_FILE = 0x00002000, #endif // NTDDI_WIN8 #if (NTDDI_VERSION >= NTDDI_WIN10_RS1) ASSOCF_IS_FULL_URI = 0x00004000, ASSOCF_PER_MACHINE_ONLY = 0x00008000, #endif // NTDDI_WIN10_RS1 #if (NTDDI_VERSION >= NTDDI_WIN10_RS4) ASSOCF_APP_TO_APP = 0x00010000, #endif // NTDDI_WIN10_RS4 }; typedef enum { ASSOCSTR_COMMAND = 1, ASSOCSTR_EXECUTABLE, ASSOCSTR_FRIENDLYDOCNAME, ASSOCSTR_FRIENDLYAPPNAME, ASSOCSTR_NOOPEN, ASSOCSTR_SHELLNEWVALUE, ASSOCSTR_DDECOMMAND, ASSOCSTR_DDEIFEXEC, ASSOCSTR_DDEAPPLICATION, ASSOCSTR_DDETOPIC, ASSOCSTR_INFOTIP, #if (_WIN32_IE >= _WIN32_IE_IE60) ASSOCSTR_QUICKTIP, ASSOCSTR_TILEINFO, ASSOCSTR_CONTENTTYPE, ASSOCSTR_DEFAULTICON, ASSOCSTR_SHELLEXTENSION, #endif // _WIN32_IE_IE60 #if (_WIN32_IE >= _WIN32_IE_IE80) ASSOCSTR_DROPTARGET, ASSOCSTR_DELEGATEEXECUTE, #endif // _WIN32_IE_IE80 ASSOCSTR_SUPPORTED_URI_PROTOCOLS, #if (NTDDI_VERSION >= NTDDI_WIN10) ASSOCSTR_PROGID, ASSOCSTR_APPID, ASSOCSTR_APPPUBLISHER, ASSOCSTR_APPICONREFERENCE, #endif // NTDDI_WIN10 ASSOCSTR_MAX } ASSOCSTR; typedef enum { ASSOCKEY_SHELLEXECCLASS = 1, ASSOCKEY_APP, ASSOCKEY_CLASS, ASSOCKEY_BASECLASS, ASSOCKEY_MAX } ASSOCKEY; typedef enum { ASSOCDATA_MSIDESCRIPTOR = 1, ASSOCDATA_NOACTIVATEHANDLER, ASSOCDATA_QUERYCLASSSTORE, ASSOCDATA_HASPERUSERASSOC, #if (_WIN32_IE >= _WIN32_IE_IE60) ASSOCDATA_EDITFLAGS, ASSOCDATA_VALUE, #endif // _WIN32_IE_IE60 ASSOCDATA_MAX } ASSOCDATA; typedef enum { ASSOCENUM_NONE } ASSOCENUM; typedef enum { FTA_None = 0x00000000, FTA_Exclude = 0x00000001, FTA_Show = 0x00000002, FTA_HasExtension = 0x00000004, FTA_NoEdit = 0x00000008, FTA_NoRemove = 0x00000010, FTA_NoNewVerb = 0x00000020, FTA_NoEditVerb = 0x00000040, FTA_NoRemoveVerb = 0x00000080, FTA_NoEditDesc = 0x00000100, FTA_NoEditIcon = 0x00000200, FTA_NoEditDflt = 0x00000400, FTA_NoEditVerbCmd = 0x00000800, FTA_NoEditVerbExe = 0x00001000, FTA_NoDDE = 0x00002000, FTA_NoEditMIME = 0x00008000, FTA_OpenIsSafe = 0x00010000, FTA_AlwaysUnsafe = 0x00020000, FTA_NoRecentDocs = 0x00100000, FTA_SafeForElevation = 0x00200000, FTA_AlwaysUseDirectInvoke = 0x00400000 } FILETYPEATTRIBUTEFLAGS; DEFINE_ENUM_FLAG_OPERATORS(FILETYPEATTRIBUTEFLAGS) typedef DWORD ASSOCF; #define INTERFACE IQueryAssociations DECLARE_INTERFACE_(IQueryAssociations,IUnknown) { STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; STDMETHOD_(ULONG,AddRef)(THIS) PURE; STDMETHOD_(ULONG,Release)(THIS) PURE; STDMETHOD(Init)(THIS_ _In_ ASSOCF flags, _In_opt_ LPCWSTR pszAssoc, _In_opt_ HKEY hkProgid, _In_opt_ HWND hwnd) PURE; STDMETHOD(GetString)(THIS_ _In_ ASSOCF flags, _In_ ASSOCSTR str, _In_opt_ LPCWSTR pszExtra, _Out_writes_opt_(*pcchOut) LPWSTR pszOut, _Inout_ DWORD *pcchOut) PURE; STDMETHOD(GetKey)(THIS_ _In_ ASSOCF flags, _In_ ASSOCKEY key, _In_opt_ LPCWSTR pszExtra, _Out_ HKEY *phkeyOut) PURE; STDMETHOD(GetData)(THIS_ _In_ ASSOCF flags, _In_ ASSOCDATA data, _In_opt_ LPCWSTR pszExtra, _Out_writes_bytes_opt_(*pcbOut) LPVOID pvOut, _Inout_opt_ DWORD *pcbOut) PURE; STDMETHOD(GetEnum)(THIS_ _In_ ASSOCF flags, _In_ ASSOCENUM assocenum, _In_opt_ LPCWSTR pszExtra, _In_ REFIID riid, _Outptr_ LPVOID *ppvOut) PURE; }; #undef INTERFACE #if !defined(__cplusplus) || defined(CINTERFACE) #define IQueryAssociations_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) #define IQueryAssociations_AddRef(p) (p)->lpVtbl->AddRef(p) #define IQueryAssociations_Release(p) (p)->lpVtbl->Release(p) #define IQueryAssociations_Init(p,a,b,c,d) (p)->lpVtbl->Init(p,a,b,c,d) #define IQueryAssociations_GetString(p,a,b,c,d,e) (p)->lpVtbl->GetString(p,a,b,c,d,e) #define IQueryAssociations_GetKey(p,a,b,c,d) (p)->lpVtbl->GetKey(p,a,b,c,d) #define IQueryAssociations_GetData(p,a,b,c,d,e) (p)->lpVtbl->GetData(p,a,b,c,d,e) #define IQueryAssociations_GetEnum(p,a,b,c,d,e) (p)->lpVtbl->GetEnum(p,a,b,c,d,e) #endif typedef struct IQueryAssociations *LPQUERYASSOCIATIONS; LWSTDAPI AssocCreate(_In_ CLSID, _In_ REFIID, _Outptr_ LPVOID*); #if (_WIN32_IE >= _WIN32_IE_IE60SP1) LWSTDAPI_(BOOL) AssocIsDangerous(_In_ LPCWSTR); #endif // _WIN32_IE_IE60SP1 LWSTDAPI AssocQueryStringA(_In_ ASSOCF, _In_ ASSOCSTR, _In_ LPCSTR, _In_opt_ LPCSTR, _Out_writes_opt_(*pcchOut) LPSTR, _Inout_ LPDWORD pcchOut); LWSTDAPI AssocQueryStringW(_In_ ASSOCF, _In_ ASSOCSTR, _In_ LPCWSTR, _In_opt_ LPCWSTR, _Out_writes_opt_(*pcchOut) LPWSTR, _Inout_ LPDWORD pcchOut); LWSTDAPI AssocQueryStringByKeyA(_In_ ASSOCF, _In_ ASSOCSTR, _In_ HKEY, _In_opt_ LPCSTR, _Out_writes_opt_(*pcchOut) LPSTR, _Inout_ LPDWORD pcchOut); LWSTDAPI AssocQueryStringByKeyW(_In_ ASSOCF, _In_ ASSOCSTR, _In_ HKEY, _In_opt_ LPCWSTR, _Out_writes_opt_(*pcchOut) LPWSTR, _Inout_ LPDWORD pcchOut); LWSTDAPI AssocQueryKeyA(_In_ ASSOCF, _In_ ASSOCKEY, _In_ LPCSTR, _In_opt_ LPCSTR, _Out_ PHKEY); LWSTDAPI AssocQueryKeyW(_In_ ASSOCF, _In_ ASSOCKEY, _In_ LPCWSTR, _In_opt_ LPCWSTR, _Out_ PHKEY); #ifdef UNICODE #define AssocQueryString AssocQueryStringW #define AssocQueryStringByKey AssocQueryStringByKeyW #define AssocQueryKey AssocQueryKeyW #else #define AssocQueryString AssocQueryStringA #define AssocQueryStringByKey AssocQueryStringByKeyA #define AssocQueryKey AssocQueryKeyA #endif #endif // NO_SHLWAPI_REG /* Stream functions */ #ifndef NO_SHLWAPI_STREAM LWSTDAPI SHCreateStreamWrapper(LPBYTE,DWORD,DWORD,struct IStream**); LWSTDAPI_(IStream *) SHCreateMemStream(_In_reads_bytes_opt_(cbInit) const BYTE *pInit, _In_ UINT cbInit); LWSTDAPI SHCreateStreamOnFileEx(_In_ LPCWSTR, _In_ DWORD, _In_ DWORD, _In_ BOOL, _In_opt_ struct IStream*, _Outptr_ struct IStream**); LWSTDAPI SHCreateStreamOnFileA(_In_ LPCSTR, _In_ DWORD, _Outptr_ struct IStream**); LWSTDAPI SHCreateStreamOnFileW(_In_ LPCWSTR, _In_ DWORD, _Outptr_ struct IStream**); LWSTDAPI_(IStream *) SHOpenRegStreamA(_In_ HKEY, _In_opt_ LPCSTR, _In_opt_ LPCSTR, _In_ DWORD); LWSTDAPI_(IStream *) SHOpenRegStreamW(_In_ HKEY, _In_opt_ LPCWSTR, _In_opt_ LPCWSTR, _In_ DWORD); LWSTDAPI_(IStream *) SHOpenRegStream2A(_In_ HKEY, _In_opt_ LPCSTR, _In_opt_ LPCSTR, _In_ DWORD); LWSTDAPI_(IStream *) SHOpenRegStream2W(_In_ HKEY, _In_opt_ LPCWSTR, _In_opt_ LPCWSTR, _In_ DWORD); #ifdef UNICODE #define SHCreateStreamOnFile SHCreateStreamOnFileW #define SHOpenRegStream SHOpenRegStream2W #define SHOpenRegStream2 SHOpenRegStream2W #else #define SHCreateStreamOnFile SHCreateStreamOnFileA #define SHOpenRegStream SHOpenRegStream2A #define SHOpenRegStream2 SHOpenRegStream2A #endif // UNICODE #ifndef _SHLWAPI_ LWSTDAPI IStream_Reset(_In_ struct IStream*); #if !defined(IStream_Read) && defined(__cplusplus) LWSTDAPI IStream_Read(_In_ struct IStream*, _Out_ void*, _In_ ULONG); LWSTDAPI IStream_Write(_In_ struct IStream*, _In_ const void*, _In_ ULONG); #endif #endif // _SHLWAPI_ #endif // NO_SHLWAPI_STREAM /* String functions */ #ifndef NO_SHLWAPI_STRFCNS #define STIF_DEFAULT 0x0L #define STIF_SUPPORT_HEX 0x1L // These functions don't have -A and -W variants LWSTDAPI SHLoadIndirectString(_In_ LPCWSTR, _Out_writes_(cchOutBuf) LPWSTR, _In_ UINT cchOutBuf, _Reserved_ PVOID*); LWSTDAPI StrRetToBSTR(_Inout_ STRRET*, _In_opt_ PCUITEMID_CHILD, _Outptr_ BSTR*); // These functions only exist as -W variants and don't have suffixless definitions LWSTDAPI_(DWORD) StrCatChainW(_Out_writes_(cchDst) LPWSTR, DWORD cchDst, DWORD, _In_ LPCWSTR); LWSTDAPI_(int) StrCmpLogicalW(_In_ LPCWSTR, _In_ LPCWSTR); #if (_WIN32_IE >= _WIN32_IE_IE60) LWSTDAPI_(LPWSTR) StrStrNW(_In_ LPCWSTR, _In_ LPCWSTR, UINT); LWSTDAPI_(LPWSTR) StrStrNIW(_In_ LPCWSTR, _In_ LPCWSTR, UINT); #endif // _WIN32_IE_IE60 // IntlStrEqWorker exists in both an -A and -W variant but doesn't have a suffixless definition LWSTDAPI_(BOOL) IntlStrEqWorkerA(BOOL, _In_reads_(nChar) LPCSTR, _In_reads_(nChar) LPCSTR, int nChar); LWSTDAPI_(BOOL) IntlStrEqWorkerW(BOOL, _In_reads_(nChar) LPCWSTR, _In_reads_(nChar) LPCWSTR, int nChar); // Normal -A and -W functions with a suffixless definition LWSTDAPI_(BOOL) ChrCmpIA (WORD,WORD); LWSTDAPI_(BOOL) ChrCmpIW (WCHAR,WCHAR); #define IntlStrEqNA(s1,s2,n) IntlStrEqWorkerA(TRUE,s1,s2,n) #define IntlStrEqNW(s1,s2,n) IntlStrEqWorkerW(TRUE,s1,s2,n) #define IntlStrEqNIA(s1,s2,n) IntlStrEqWorkerA(FALSE,s1,s2,n) #define IntlStrEqNIW(s1,s2,n) IntlStrEqWorkerW(FALSE,s1,s2,n) LWSTDAPI SHStrDupA(_In_ LPCSTR psz, _Outptr_ WCHAR** ppwsz); LWSTDAPI SHStrDupW(_In_ LPCWSTR psz, _Outptr_ WCHAR** ppwsz); #define StrCatA lstrcatA LWSTDAPI_(LPWSTR) StrCatW(_Inout_ LPWSTR, _In_ LPCWSTR); LWSTDAPI_(LPSTR) StrCatBuffA(_Inout_updates_(cchDestBuffSize) LPSTR, _In_ LPCSTR, int cchDestBuffSize); LWSTDAPI_(LPWSTR) StrCatBuffW(_Inout_updates_(cchDestBuffSize) LPWSTR, _In_ LPCWSTR, int cchDestBuffSize); LWSTDAPI_(LPSTR) StrChrA(_In_ LPCSTR, WORD); LWSTDAPI_(LPWSTR) StrChrW(_In_ LPCWSTR, WCHAR); LWSTDAPI_(LPSTR) StrChrIA(_In_ LPCSTR, WORD); LWSTDAPI_(LPWSTR) StrChrIW(_In_ LPCWSTR, WCHAR); #define StrCmpA lstrcmpA LWSTDAPI_(int) StrCmpW(_In_ LPCWSTR, _In_ LPCWSTR); #define StrCmpIA lstrcmpiA LWSTDAPI_(int) StrCmpIW(_In_ LPCWSTR, _In_ LPCWSTR); LWSTDAPI_(int) StrCmpNA(_In_ LPCSTR, _In_ LPCSTR, INT); LWSTDAPI_(int) StrCmpNW(_In_ LPCWSTR, _In_ LPCWSTR, INT); LWSTDAPI_(int) StrCmpNIA(_In_ LPCSTR, _In_ LPCSTR, INT); LWSTDAPI_(int) StrCmpNIW(_In_ LPCWSTR, _In_ LPCWSTR, INT); #define StrCpyA lstrcpyA LWSTDAPI_(LPWSTR) StrCpyW(_Out_ LPWSTR, _In_ LPCWSTR); #define StrCpyNA lstrcpynA LWSTDAPI_(LPWSTR) StrCpyNW(_Out_writes_(cchMax) LPWSTR, _In_ LPCWSTR, int cchMax); LWSTDAPI_(int) StrCSpnA(_In_ LPCSTR, _In_ LPCSTR); LWSTDAPI_(int) StrCSpnW(_In_ LPCWSTR, _In_ LPCWSTR); LWSTDAPI_(int) StrCSpnIA(_In_ LPCSTR, _In_ LPCSTR); LWSTDAPI_(int) StrCSpnIW(_In_ LPCWSTR, _In_ LPCWSTR); LWSTDAPI_(LPSTR) StrDupA(_In_ LPCSTR); LWSTDAPI_(LPWSTR) StrDupW(_In_ LPCWSTR); LWSTDAPI_(LPSTR) StrFormatByteSize64A(LONGLONG, _Out_writes_(cchBuf) LPSTR, UINT cchBuf); LWSTDAPI_(LPSTR) StrFormatByteSizeA(DWORD, _Out_writes_(cchBuf) LPSTR, UINT cchBuf); LWSTDAPI_(LPWSTR) StrFormatByteSizeW(LONGLONG, _Out_writes_(cchBuf) LPWSTR, UINT cchBuf); LWSTDAPI_(LPSTR) StrFormatKBSizeA(LONGLONG, _Out_writes_(cchBuf) LPSTR, UINT cchBuf); LWSTDAPI_(LPWSTR) StrFormatKBSizeW(LONGLONG, _Out_writes_(cchBuf) LPWSTR, UINT cchBuf); LWSTDAPI_(int) StrFromTimeIntervalA(_Out_writes_(cchMax) LPSTR, UINT cchMax, DWORD, int); LWSTDAPI_(int) StrFromTimeIntervalW(_Out_writes_(cchMax) LPWSTR, UINT cchMax, DWORD, int); #define StrIntlEqNA(a,b,c) StrIsIntlEqualA(TRUE,a,b,c) #define StrIntlEqNW(a,b,c) StrIsIntlEqualW(TRUE,a,b,c) #define StrIntlEqNIA(a,b,c) StrIsIntlEqualA(FALSE,a,b,c) #define StrIntlEqNIW(a,b,c) StrIsIntlEqualW(FALSE,a,b,c) LWSTDAPI_(BOOL) StrIsIntlEqualA(BOOL, _In_ LPCSTR, _In_ LPCSTR, int); LWSTDAPI_(BOOL) StrIsIntlEqualW(BOOL, _In_ LPCWSTR, _In_ LPCWSTR, int); LWSTDAPI_(LPSTR) StrNCatA(_Inout_updates_(cchMax) LPSTR, LPCSTR, int cchMax); LWSTDAPI_(LPWSTR) StrNCatW(_Inout_updates_(cchMax) LPWSTR, LPCWSTR, int cchMax); LWSTDAPI_(LPSTR) StrPBrkA(_In_ LPCSTR, _In_ LPCSTR); LWSTDAPI_(LPWSTR) StrPBrkW(_In_ LPCWSTR, _In_ LPCWSTR); LWSTDAPI_(LPSTR) StrRChrA(_In_ LPCSTR, _In_opt_ LPCSTR, WORD); LWSTDAPI_(LPWSTR) StrRChrW(_In_ LPCWSTR, _In_opt_ LPCWSTR, WCHAR); LWSTDAPI_(LPSTR) StrRChrIA(_In_ LPCSTR, _In_opt_ LPCSTR, WORD); LWSTDAPI_(LPWSTR) StrRChrIW(_In_ LPCWSTR, _In_opt_ LPCWSTR, WCHAR); LWSTDAPI_(LPSTR) StrRStrIA(_In_ LPCSTR, _In_opt_ LPCSTR, _In_ LPCSTR); LWSTDAPI_(LPWSTR) StrRStrIW(_In_ LPCWSTR, _In_opt_ LPCWSTR, _In_ LPCWSTR); LWSTDAPI StrRetToBufA(_Inout_ STRRET*, _In_opt_ PCUITEMID_CHILD, _Out_writes_(cchBuf) LPSTR, UINT cchBuf); LWSTDAPI StrRetToBufW(_Inout_ STRRET*, _In_opt_ PCUITEMID_CHILD, _Out_writes_(cchBuf) LPWSTR, UINT cchBuf); LWSTDAPI StrRetToStrA(_Inout_ STRRET*, _In_opt_ PCUITEMID_CHILD, _Outptr_ LPSTR*); LWSTDAPI StrRetToStrW(_Inout_ STRRET*, _In_opt_ PCUITEMID_CHILD, _Outptr_ LPWSTR*); LWSTDAPI_(int) StrSpnA(_In_ LPCSTR psz, _In_ LPCSTR pszSet); LWSTDAPI_(int) StrSpnW(_In_ LPCWSTR psz, _In_ LPCWSTR pszSet); LWSTDAPI_(LPSTR) StrStrA(_In_ LPCSTR pszFirst, _In_ LPCSTR pszSrch); LWSTDAPI_(LPWSTR) StrStrW(_In_ LPCWSTR pszFirst, _In_ LPCWSTR pszSrch); LWSTDAPI_(LPSTR) StrStrIA(_In_ LPCSTR pszFirst, _In_ LPCSTR pszSrch); LWSTDAPI_(LPWSTR) StrStrIW(_In_ LPCWSTR pszFirst, _In_ LPCWSTR pszSrch); LWSTDAPI_(int) StrToIntA(_In_ LPCSTR); LWSTDAPI_(int) StrToIntW(_In_ LPCWSTR); LWSTDAPI_(BOOL) StrToIntExA(_In_ LPCSTR, DWORD, _Out_ int*); LWSTDAPI_(BOOL) StrToIntExW(_In_ LPCWSTR, DWORD, _Out_ int*); LWSTDAPI_(BOOL) StrTrimA(_Inout_ LPSTR, _In_ LPCSTR); LWSTDAPI_(BOOL) StrTrimW(_Inout_ LPWSTR, _In_ LPCWSTR); LWSTDAPIV_(int) wnsprintfA(_Out_writes_(cchDest) LPSTR, _In_ INT cchDest, _In_ _Printf_format_string_ LPCSTR, ...); LWSTDAPIV_(int) wnsprintfW(_Out_writes_(cchDest) LPWSTR, _In_ INT cchDest, _In_ _Printf_format_string_ LPCWSTR, ...); LWSTDAPI_(int) wvnsprintfA(_Out_writes_(cchDest) LPSTR, _In_ INT cchDest, _In_ _Printf_format_string_ LPCSTR, _In_ va_list); LWSTDAPI_(int) wvnsprintfW(_Out_writes_(cchDest) LPWSTR, _In_ INT cchDest, _In_ _Printf_format_string_ LPCWSTR, _In_ va_list); #if (_WIN32_IE >= _WIN32_IE_IE60) LWSTDAPI_(BOOL) StrToInt64ExA(_In_ LPCSTR, DWORD, _Out_ LONGLONG*); LWSTDAPI_(BOOL) StrToInt64ExW(_In_ LPCWSTR, DWORD, _Out_ LONGLONG*); #endif // _WIN32_IE_IE60 #if (_WIN32_IE >= _WIN32_IE_IE60SP2) LWSTDAPI_(BOOL) IsCharSpaceA(CHAR); LWSTDAPI_(BOOL) IsCharSpaceW(WCHAR); #endif // _WIN32_IE_IE60SP2 #ifdef UNICODE #define ChrCmpI ChrCmpIW #define IntlStrEqN IntlStrEqNW #define IntlStrEqNI IntlStrEqNIW #define SHStrDup SHStrDupW #define StrCat StrCatW #define StrCatBuff StrCatBuffW #define StrChr StrChrW #define StrChrI StrChrIW #define StrCmp StrCmpW #define StrCmpI StrCmpIW #define StrCmpN StrCmpNW #define StrCmpNI StrCmpNIW #define StrCpy StrCpyW #define StrCpyN StrCpyNW #define StrCSpn StrCSpnW #define StrCSpnI StrCSpnIW #define StrDup StrDupW #define StrFormatByteSize StrFormatByteSizeW #define StrFormatByteSize64 StrFormatByteSizeW #define StrFormatKBSize StrFormatKBSizeW #define StrFromTimeInterval StrFromTimeIntervalW #define StrIntlEqN StrIntlEqNW #define StrIntlEqNI StrIntlEqNIW #define StrIsIntlEqual StrIsIntlEqualW #define StrNCat StrNCatW #define StrPBrk StrPBrkW #define StrRChr StrRChrW #define StrRChrI StrRChrIW #define StrRStrI StrRStrIW #define StrRetToBuf StrRetToBufW #define StrRetToStr StrRetToStrW #define StrSpn StrSpnW #define StrStr StrStrW #define StrStrI StrStrIW #define StrToInt StrToIntW #define StrToIntEx StrToIntExW #define StrTrim StrTrimW #define wnsprintf wnsprintfW #define wvnsprintf wvnsprintfW #if (_WIN32_IE >= _WIN32_IE_IE60) #define StrToInt64Ex StrToInt64ExW #endif // _WIN32_IE_IE60 #if (_WIN32_IE >= _WIN32_IE_IE60SP2) #define IsCharSpace IsCharSpaceW #endif // _WIN32_IE_IE60SP2 #else #define ChrCmpI ChrCmpIA #define IntlStrEqN IntlStrEqNA #define IntlStrEqNI IntlStrEqNIA #define SHStrDup SHStrDupA #define StrCat StrCatA #define StrCatBuff StrCatBuffA #define StrChr StrChrA #define StrChrI StrChrIA #define StrCmp StrCmpA #define StrCmpI StrCmpIA #define StrCmpN StrCmpNA #define StrCmpNI StrCmpNIA #define StrCpy StrCpyA #define StrCpyN StrCpyNA #define StrCSpn StrCSpnA #define StrCSpnI StrCSpnIA #define StrDup StrDupA #define StrFormatByteSize StrFormatByteSizeA #define StrFormatByteSize64 StrFormatByteSize64A #define StrFormatKBSize StrFormatKBSizeA #define StrFromTimeInterval StrFromTimeIntervalA #define StrIntlEqN StrIntlEqNA #define StrIntlEqNI StrIntlEqNIA #define StrIsIntlEqual StrIsIntlEqualA #define StrNCat StrNCatA #define StrPBrk StrPBrkA #define StrRChr StrRChrA #define StrRChrI StrRChrIA #define StrRStrI StrRStrIA #define StrRetToBuf StrRetToBufA #define StrRetToStr StrRetToStrA #define StrSpn StrSpnA #define StrStr StrStrA #define StrStrI StrStrIA #define StrToInt StrToIntA #define StrToIntEx StrToIntExA #define StrTrim StrTrimA #define wnsprintf wnsprintfA #define wvnsprintf wvnsprintfA #if (_WIN32_IE >= _WIN32_IE_IE60) #define StrToInt64Ex StrToInt64ExA #endif // _WIN32_IE_IE60 #if (_WIN32_IE >= _WIN32_IE_IE60SP2) #define IsCharSpace IsCharSpaceA #endif // _WIN32_IE_IE60SP2 #endif // UNICODE #if (NTDDI_VERSION >= NTDDI_VISTASP1) typedef int SFBS_FLAGS; enum tagSFBS_FLAGS { SFBS_FLAGS_ROUND_TO_NEAREST_DISPLAYED_DIGIT = 0x0001, SFBS_FLAGS_TRUNCATE_UNDISPLAYED_DECIMAL_DIGITS = 0x0002 }; LWSTDAPI StrFormatByteSizeEx(ULONGLONG ull, SFBS_FLAGS flags, _Out_writes_(cchBuf) PWSTR pszBuf, _In_range_(>,0) UINT cchBuf); #endif // NTDDI_VISTASP1 #endif // NO_SHLWAPI_STRFCNS #ifdef __cplusplus } #endif // __cplusplus #include #endif // NOSHLWAPI #endif // _INC_SHLWAPI