ApfelTeeSaft/reactos
1
0
Fork 0
mirror of https://github.com/ApfelTeeSaft/reactos.git synced 2026-08-26 19:33:31 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
6762703ce4c0dabdb89f59c1249d874ea5815b65
reactos/sdk/include/psdk/shlwapi.h
T
Carl J. Bialorucki 6762703ce4 [PSDK][INCLUDE/WINE] Introduce our own shlwapi.h for PSDK and import wine-10.0 shlwapi.h for Wine code (#8419) 
- [PSDK] Introduce our own Microsoft compatible and MIT-licensed shlwapi.h and fix breaking changes
- [INCLUDE/WINE] Import shlwapi.h from wine-10.0 for use with Wine compatible code
- [CMAKELISTS.TXT] Bump up IE version from IE60 to IE60SP2. This is required because we are already using IE60SP2 guarded functionality; the new header unhides this.
- [SHLWAPI] Fix breaking changes, including a typo for 'SHGVSPB_GLOBALDEAFAULTS' (should be 'SHGVSPB_GLOBALDEFAULTS')
- [MSI] Use wine's shlwapi.h instead of our own in automation.c, don't precompile shlwapi.h.
- [URLMON_WINETEST] Primarily use wineheaders for this test
2025-10-17 09:23:31 -05:00

1281 lines
60 KiB
C
Raw Blame History

/*
* PROJECT: ReactOS SDK
* LICENSE: MIT (https://spdx.org/licenses/MIT)
* PURPOSE: shlwapi header
* COPYRIGHT: Copyright 2025 Carl Bialorucki ([email protected])
*/
#ifndef _INC_SHLWAPI
#define _INC_SHLWAPI
#ifndef NOSHLWAPI
#include <specstrings.h>
#include <objbase.h>
#include <shtypes.h>
#include <pshpack8.h>
#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<base*>((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 <poppack.h>
#endif // NOSHLWAPI
#endif // _INC_SHLWAPI
Reference in New Issue View Git Blame Copy Permalink