Headers diff for shlwapi.dll between 6.0.6002.18005-Windows 6.0 and 6.1.7601.17514-Windows 7.0 versions



 shlwapi.h (6.0.6002.18005-Windows 6.0)   shlwapi.h (6.1.7601.17514-Windows 7.0) 
skipping to change at line 21 skipping to change at line 21
#ifndef _INC_SHLWAPI #ifndef _INC_SHLWAPI
#define _INC_SHLWAPI #define _INC_SHLWAPI
#ifndef NOSHLWAPI #ifndef NOSHLWAPI
#include <SpecStrings.h> #include <SpecStrings.h>
#include <objbase.h> #include <objbase.h>
#include <shtypes.h> #include <shtypes.h>
#ifdef UNIX
typedef interface IInternetSecurityMgrSite IInternetSecurityMgrSite;
typedef interface IInternetSecurityManager IInternetSecurityManager;
typedef interface IInternetHostSecurityManager IInternetHostSecurityManager;
#endif
// //
// Define API decoration for direct importing of DLL references. // Define API decoration for direct importing of DLL references.
// //
#ifndef WINSHLWAPI #ifndef WINSHLWAPI
#if !defined(_SHLWAPI_) #if !defined(_SHLWAPI_)
#define LWSTDAPI EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE #define LWSTDAPI EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE
#define LWSTDAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE #define LWSTDAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE
#define LWSTDAPIV EXTERN_C DECLSPEC_IMPORT HRESULT STDAPIVCALLTYPE #define LWSTDAPIV EXTERN_C DECLSPEC_IMPORT HRESULT STDAPIVCALLTYPE
#define LWSTDAPIV_(type) EXTERN_C DECLSPEC_IMPORT type STDAPIVCALLTYPE #define LWSTDAPIV_(type) EXTERN_C DECLSPEC_IMPORT type STDAPIVCALLTYPE
#else #else
skipping to change at line 53 skipping to change at line 47
#ifdef _WIN32 #ifdef _WIN32
#include <pshpack8.h> #include <pshpack8.h>
#endif #endif
#if defined(DEPRECATE_SUPPORTED) #if defined(DEPRECATE_SUPPORTED)
#pragma warning(push) #pragma warning(push)
#pragma warning(disable:4995) #pragma warning(disable:4995)
#endif #endif
// objidl.h
#ifndef __IBindCtx_FWD_DEFINED__
#define __IBindCtx_FWD_DEFINED__
typedef interface IBindCtx IBindCtx;
#endif /* __IBindCtx_FWD_DEFINED__ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#if defined(__cplusplus) && defined(STRICT_CONST) #if defined(__cplusplus) && defined(STRICT_CONST)
#define USE_STRICT_CONST #define USE_STRICT_CONST
#endif #endif
// //
// Users of this header may define any number of these constants to avoid // Users of this header may define any number of these constants to avoid
// the definitions of each functional group. // the definitions of each functional group.
skipping to change at line 105 skipping to change at line 105
LWSTDAPI_(int) StrCmpNW(__in LPCWSTR lpStr1, __in LPCWSTR lpStr2, int nChar ); LWSTDAPI_(int) StrCmpNW(__in LPCWSTR lpStr1, __in LPCWSTR lpStr2, int nChar );
LWSTDAPI_(int) StrCmpNIA(__in LPCSTR lpStr1, __in LPCSTR lpStr2, int nChar) ; LWSTDAPI_(int) StrCmpNIA(__in LPCSTR lpStr1, __in LPCSTR lpStr2, int nChar) ;
LWSTDAPI_(int) StrCmpNIW(__in LPCWSTR lpStr1, __in LPCWSTR lpStr2, int nCha r); LWSTDAPI_(int) StrCmpNIW(__in LPCWSTR lpStr1, __in LPCWSTR lpStr2, int nCha r);
LWSTDAPI_(int) StrCSpnA(LPCSTR lpStr, LPCSTR lpSet); LWSTDAPI_(int) StrCSpnA(LPCSTR lpStr, LPCSTR lpSet);
LWSTDAPI_(int) StrCSpnW(LPCWSTR lpStr, LPCWSTR lpSet); LWSTDAPI_(int) StrCSpnW(LPCWSTR lpStr, LPCWSTR lpSet);
LWSTDAPI_(int) StrCSpnIA(LPCSTR lpStr, LPCSTR lpSet); LWSTDAPI_(int) StrCSpnIA(LPCSTR lpStr, LPCSTR lpSet);
LWSTDAPI_(int) StrCSpnIW(LPCWSTR lpStr, LPCWSTR lpSet); LWSTDAPI_(int) StrCSpnIW(LPCWSTR lpStr, LPCWSTR lpSet);
LWSTDAPI_(LPSTR) StrDupA(LPCSTR lpSrch); LWSTDAPI_(LPSTR) StrDupA(LPCSTR lpSrch);
LWSTDAPI_(LPWSTR) StrDupW(LPCWSTR lpSrch); LWSTDAPI_(LPWSTR) StrDupW(LPCWSTR lpSrch);
// StrFormatByteSizeEx takes a ULONGLONG as a byte count and formats a string
// representing that number of bytes in an appropriately concise manner, where
// "appropriate manner" is determine by several factors:
//
// 1) order - is this most appropriately expressed as KB? MB? GB?
// for example: 1039 -> "1.01 KB", 5454608466 -> "5.08 GB", etc
//
// 2) number of whole number places shown - if there are more than a few whole
// number places to display, decimal places are omitted.
// for example: 1024 -> "1.00 KB", 12288 -> "12.0 KB", 125952 -> "123 KB"
//
// 3) the caller can specify whether the result should involve rounding to the
// nearest displayed digit, or truncation of undisplayed digits. the caller
// must specify either rounding or truncation when calling the API.
// for example: with rounding, 2147483647 -> "2.00 GB"
// with truncation, 2147483647 -> "1.99 GB"
enum tagSFBS_FLAGS
{
SFBS_FLAGS_ROUND_TO_NEAREST_DISPLAYED_DIGIT = 0x0001, // round to the
nearest displayed digit
SFBS_FLAGS_TRUNCATE_UNDISPLAYED_DECIMAL_DIGITS = 0x0002, // discard undis
played digits
};
typedef int SFBS_FLAGS;
LWSTDAPI StrFormatByteSizeEx(__in ULONGLONG ull, __in SFBS_FLAGS flag
s, __out_ecount(cchBuf) LPWSTR pszBuf, __in_range(>,0) UINT cchBuf);
LWSTDAPI_(LPSTR) StrFormatByteSizeA(DWORD dw, __out_ecount(cchBuf) LPSTR pszB uf, UINT cchBuf); LWSTDAPI_(LPSTR) StrFormatByteSizeA(DWORD dw, __out_ecount(cchBuf) LPSTR pszB uf, UINT cchBuf);
LWSTDAPI_(LPSTR) StrFormatByteSize64A(LONGLONG qdw, __out_ecount(cchBuf) LPST R pszBuf, UINT cchBuf); LWSTDAPI_(LPSTR) StrFormatByteSize64A(LONGLONG qdw, __out_ecount(cchBuf) LPST R pszBuf, UINT cchBuf);
LWSTDAPI_(LPWSTR) StrFormatByteSizeW(LONGLONG qdw, __out_ecount(cchBuf) LPWSTR pszBuf, UINT cchBuf); LWSTDAPI_(LPWSTR) StrFormatByteSizeW(LONGLONG qdw, __out_ecount(cchBuf) LPWSTR pszBuf, UINT cchBuf);
LWSTDAPI_(LPWSTR) StrFormatKBSizeW(LONGLONG qdw, __out_ecount(cchBuf) LPWSTR p szBuf, UINT cchBuf); LWSTDAPI_(LPWSTR) StrFormatKBSizeW(LONGLONG qdw, __out_ecount(cchBuf) LPWSTR p szBuf, UINT cchBuf);
LWSTDAPI_(LPSTR) StrFormatKBSizeA(LONGLONG qdw, __out_ecount(cchBuf) LPSTR ps zBuf, UINT cchBuf); LWSTDAPI_(LPSTR) StrFormatKBSizeA(LONGLONG qdw, __out_ecount(cchBuf) LPSTR ps zBuf, UINT cchBuf);
LWSTDAPI_(int) StrFromTimeIntervalA(__out_ecount(cchMax) LPSTR pszOut, UINT cchMax, DWORD dwTimeMS, int digits); LWSTDAPI_(int) StrFromTimeIntervalA(__out_ecount(cchMax) LPSTR pszOut, UINT cchMax, DWORD dwTimeMS, int digits);
LWSTDAPI_(int) StrFromTimeIntervalW(__out_ecount(cchMax) LPWSTR pwszOut, UI NT cchMax, DWORD dwTimeMS, int digits); LWSTDAPI_(int) StrFromTimeIntervalW(__out_ecount(cchMax) LPWSTR pwszOut, UI NT cchMax, DWORD dwTimeMS, int digits);
LWSTDAPI_(BOOL) StrIsIntlEqualA(__in BOOL fCaseSens, __in LPCSTR lpString1, __in LPCSTR lpString2, __in int nChar); LWSTDAPI_(BOOL) StrIsIntlEqualA(__in BOOL fCaseSens, __in LPCSTR lpString1, __in LPCSTR lpString2, __in int nChar);
LWSTDAPI_(BOOL) StrIsIntlEqualW(__in BOOL fCaseSens, __in LPCWSTR lpString1, __in LPCWSTR lpString2, __in int nChar); LWSTDAPI_(BOOL) StrIsIntlEqualW(__in BOOL fCaseSens, __in LPCWSTR lpString1, __in LPCWSTR lpString2, __in int nChar);
LWSTDAPI_(LPSTR) StrNCatA(__inout_ecount(cchMax) LPSTR psz1, LPCSTR psz2, int cchMax); LWSTDAPI_(LPSTR) StrNCatA(__inout_ecount(cchMax) LPSTR psz1, LPCSTR psz2, int cchMax);
skipping to change at line 169 skipping to change at line 195
typedef int STIF_FLAGS; typedef int STIF_FLAGS;
LWSTDAPI_(int) StrToIntA(__in LPCSTR lpSrc); LWSTDAPI_(int) StrToIntA(__in LPCSTR lpSrc);
LWSTDAPI_(int) StrToIntW(__in LPCWSTR lpSrc); LWSTDAPI_(int) StrToIntW(__in LPCWSTR lpSrc);
LWSTDAPI_(BOOL) StrToIntExA(__in LPCSTR pszString, __in STIF_FLAGS dwFlags, __out int * piRet); LWSTDAPI_(BOOL) StrToIntExA(__in LPCSTR pszString, __in STIF_FLAGS dwFlags, __out int * piRet);
LWSTDAPI_(BOOL) StrToIntExW(__in LPCWSTR pszString, __in STIF_FLAGS dwFlags, __out int * piRet); LWSTDAPI_(BOOL) StrToIntExW(__in LPCWSTR pszString, __in STIF_FLAGS dwFlags, __out int * piRet);
#if (_WIN32_IE >= _WIN32_IE_IE60) #if (_WIN32_IE >= _WIN32_IE_IE60)
LWSTDAPI_(BOOL) StrToInt64ExA(__in LPCSTR pszString, __in STIF_FLAGS dwFlags , __out LONGLONG * pllRet); LWSTDAPI_(BOOL) StrToInt64ExA(__in LPCSTR pszString, __in STIF_FLAGS dwFlags , __out LONGLONG * pllRet);
LWSTDAPI_(BOOL) StrToInt64ExW(__in LPCWSTR pszString, __in STIF_FLAGS dwFlag s, __out LONGLONG * pllRet); LWSTDAPI_(BOOL) StrToInt64ExW(__in LPCWSTR pszString, __in STIF_FLAGS dwFlag s, __out LONGLONG * pllRet);
#endif // _WIN32_IE_IE60 #endif // _WIN32_IE_IE60
LWSTDAPI_(BOOL) StrTrimA(__inout LPSTR psz, LPCSTR pszTrimChars); LWSTDAPI_(BOOL) StrTrimA(__inout LPSTR psz, __in LPCSTR pszTrimChars);
LWSTDAPI_(BOOL) StrTrimW(__inout LPWSTR psz, LPCWSTR pszTrimChars); LWSTDAPI_(BOOL) StrTrimW(__inout LPWSTR psz, __in LPCWSTR pszTrimChars);
LWSTDAPI_(LPWSTR) StrCatW(__inout LPWSTR psz1, LPCWSTR psz2); LWSTDAPI_(LPWSTR) StrCatW(__inout LPWSTR psz1, LPCWSTR psz2);
LWSTDAPI_(int) StrCmpW(__in LPCWSTR psz1, __in LPCWSTR psz2); LWSTDAPI_(int) StrCmpW(__in LPCWSTR psz1, __in LPCWSTR psz2);
LWSTDAPI_(int) StrCmpIW(__in LPCWSTR psz1, __in LPCWSTR psz2); LWSTDAPI_(int) StrCmpIW(__in LPCWSTR psz1, __in LPCWSTR psz2);
LWSTDAPI_(LPWSTR) StrCpyW(__out LPWSTR psz1, LPCWSTR psz2); LWSTDAPI_(LPWSTR) StrCpyW(__out LPWSTR psz1, LPCWSTR psz2);
LWSTDAPI_(LPWSTR) StrCpyNW(__out_ecount(cchMax) LPWSTR psz1, LPCWSTR psz2, int cchMax); LWSTDAPI_(LPWSTR) StrCpyNW(__out_ecount(cchMax) LPWSTR psz1, __in LPCWSTR psz2 , __in int cchMax);
LWSTDAPI_(LPWSTR) StrCatBuffW(__inout_ecount(cchDestBuffSize) LPWSTR pszDest, LWSTDAPI_(LPWSTR) StrCatBuffW(__inout_ecount(cchDestBuffSize) LPWSTR pszDest,
LPCWSTR pszSrc, int cchDestBuffSize); __in LPCWSTR pszSrc, __in int cchDestBuffSize);
LWSTDAPI_(LPSTR) StrCatBuffA(__inout_ecount(cchDestBuffSize) LPSTR pszDest, L LWSTDAPI_(LPSTR) StrCatBuffA(__inout_ecount(cchDestBuffSize) LPSTR pszDest, _
PCSTR pszSrc, int cchDestBuffSize); _in LPCSTR pszSrc, __in int cchDestBuffSize);
LWSTDAPI_(BOOL) ChrCmpIA(__in WORD w1, __in WORD w2); LWSTDAPI_(BOOL) ChrCmpIA(WORD w1, WORD w2);
LWSTDAPI_(BOOL) ChrCmpIW(__in WCHAR w1, __in WCHAR w2); LWSTDAPI_(BOOL) ChrCmpIW(WCHAR w1, WCHAR w2);
LWSTDAPI_(int) wvnsprintfA(__out_ecount(cchLimitIn) LPSTR lpOut, int cchLim LWSTDAPI_(int) wvnsprintfA(__out_ecount(cchDest) LPSTR pszDest, __in int cc
itIn, LPCSTR lpFmt, __in va_list arglist); hDest, __in __format_string LPCSTR pszFmt, __in va_list arglist);
LWSTDAPI_(int) wvnsprintfW(__out_ecount(cchLimitIn) LPWSTR lpOut, int cchLi LWSTDAPI_(int) wvnsprintfW(__out_ecount(cchDest) LPWSTR pszDest, __in int c
mitIn, LPCWSTR lpFmt, __in va_list arglist); chDest, __in __format_string LPCWSTR pszFmt, __in va_list arglist);
LWSTDAPIV_(int) wnsprintfA(__out_ecount(cchLimitIn) LPSTR lpOut, int cchLimi LWSTDAPIV_(int) wnsprintfA(__out_ecount(cchDest) LPSTR pszDest, __in int cch
tIn, LPCSTR lpFmt, ...); Dest, __in __format_string LPCSTR pszFmt, ...);
LWSTDAPIV_(int) wnsprintfW(__out_ecount(cchLimitIn) LPWSTR lpOut, int cchLim LWSTDAPIV_(int) wnsprintfW(__out_ecount(cchDest) LPWSTR pszDest, __in int cc
itIn, LPCWSTR lpFmt, ...); hDest, __in __format_string LPCWSTR pszFmt, ...);
#define StrIntlEqNA( s1, s2, nChar) StrIsIntlEqualA( TRUE, s1, s2, nChar) #define StrIntlEqNA( s1, s2, nChar) StrIsIntlEqualA( TRUE, s1, s2, nChar)
#define StrIntlEqNW( s1, s2, nChar) StrIsIntlEqualW( TRUE, s1, s2, nChar) #define StrIntlEqNW( s1, s2, nChar) StrIsIntlEqualW( TRUE, s1, s2, nChar)
#define StrIntlEqNIA(s1, s2, nChar) StrIsIntlEqualA(FALSE, s1, s2, nChar) #define StrIntlEqNIA(s1, s2, nChar) StrIsIntlEqualA(FALSE, s1, s2, nChar)
#define StrIntlEqNIW(s1, s2, nChar) StrIsIntlEqualW(FALSE, s1, s2, nChar) #define StrIntlEqNIW(s1, s2, nChar) StrIsIntlEqualW(FALSE, s1, s2, nChar)
LWSTDAPI StrRetToStrA(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __out LWSTDAPI StrRetToStrA(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __der
LPSTR *ppsz); ef_out LPSTR *ppsz);
LWSTDAPI StrRetToStrW(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __out LWSTDAPI StrRetToStrW(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __der
LPWSTR *ppsz); ef_out LPWSTR *ppsz);
#ifdef UNICODE #ifdef UNICODE
#define StrRetToStr StrRetToStrW #define StrRetToStr StrRetToStrW
#else #else
#define StrRetToStr StrRetToStrA #define StrRetToStr StrRetToStrA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI StrRetToBufA(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __out _ecount(cchBuf) LPSTR pszBuf, UINT cchBuf); LWSTDAPI StrRetToBufA(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __out _ecount(cchBuf) LPSTR pszBuf, UINT cchBuf);
LWSTDAPI StrRetToBufW(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __out _ecount(cchBuf) LPWSTR pszBuf, UINT cchBuf); LWSTDAPI StrRetToBufW(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __out _ecount(cchBuf) LPWSTR pszBuf, UINT cchBuf);
#ifdef UNICODE #ifdef UNICODE
#define StrRetToBuf StrRetToBufW #define StrRetToBuf StrRetToBufW
#else #else
skipping to change at line 239 skipping to change at line 265
} }
#ifdef UNICODE #ifdef UNICODE
#define SHLocalStrDup SHLocalStrDupW #define SHLocalStrDup SHLocalStrDupW
#else #else
#define SHLocalStrDup SHLocalStrDupA #define SHLocalStrDup SHLocalStrDupA
#endif #endif
#endif // __cplusplus #endif // __cplusplus
#if (_WIN32_IE >= _WIN32_IE_IE55) #if (_WIN32_IE >= _WIN32_IE_IE55)
LWSTDAPI_(int) StrCmpLogicalW(__in LPCWSTR psz1, __in LPCWSTR psz2); LWSTDAPI_(int) StrCmpLogicalW(__in LPCWSTR psz1, __in LPCWSTR psz2);
LWSTDAPI_(DWORD) StrCatChainW(__out_ecount(cchDst) LPWSTR pszDst, DWORD cchDst, LWSTDAPI_(DWORD) StrCatChainW(__out_ecount(cchDst) LPWSTR pszDst, __in DWORD cch
DWORD ichAt, LPCWSTR pszSrc); Dst, __in DWORD ichAt, __in LPCWSTR pszSrc);
LWSTDAPI StrRetToBSTR(__inout STRRET *pstr, __in PCUITEMID_CHILD pidl, __out BST LWSTDAPI StrRetToBSTR(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __der
R *pbstr); ef_out BSTR *pbstr);
LWSTDAPI SHLoadIndirectString(LPCWSTR pszSource, __out_ecount(cchOutBuf) LPWSTR LWSTDAPI SHLoadIndirectString(__in LPCWSTR pszSource, __out_ecount(cchOutBuf) LP
pszOutBuf, UINT cchOutBuf, __in_opt void **ppvReserved); WSTR pszOutBuf, __in UINT cchOutBuf, __reserved void **ppvReserved);
#endif // _WIN32_IE_IE55 #endif // _WIN32_IE_IE55
#if (_WIN32_IE >= _WIN32_IE_IE60SP2) #if (_WIN32_IE >= _WIN32_IE_IE60SP2)
LWSTDAPI_(BOOL) IsCharSpaceA(__in CHAR wch); LWSTDAPI_(BOOL) IsCharSpaceA(__in CHAR wch);
LWSTDAPI_(BOOL) IsCharSpaceW(__in WCHAR wch); LWSTDAPI_(BOOL) IsCharSpaceW(__in WCHAR wch);
#ifdef UNICODE #ifdef UNICODE
#define IsCharSpace IsCharSpaceW #define IsCharSpace IsCharSpaceW
#else #else
#define IsCharSpace IsCharSpaceA #define IsCharSpace IsCharSpaceA
#endif // !UNICODE #endif // !UNICODE
skipping to change at line 436 skipping to change at line 462
//=============== Path Routines =================================== //=============== Path Routines ===================================
// //
LWSTDAPI_(LPSTR) PathAddBackslashA(__inout_ecount(MAX_PATH) LPSTR pszPath); LWSTDAPI_(LPSTR) PathAddBackslashA(__inout_ecount(MAX_PATH) LPSTR pszPath);
LWSTDAPI_(LPWSTR) PathAddBackslashW(__inout_ecount(MAX_PATH) LPWSTR pszPath); LWSTDAPI_(LPWSTR) PathAddBackslashW(__inout_ecount(MAX_PATH) LPWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathAddBackslash PathAddBackslashW #define PathAddBackslash PathAddBackslashW
#else #else
#define PathAddBackslash PathAddBackslashA #define PathAddBackslash PathAddBackslashA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathAddExtensionA(__inout_ecount(MAX_PATH) LPSTR pszPath, LP LWSTDAPI_(BOOL) PathAddExtensionA(__inout_ecount(MAX_PATH) LPSTR pszPath, __
CSTR pszExt); in_opt LPCSTR pszExt);
LWSTDAPI_(BOOL) PathAddExtensionW(__inout_ecount(MAX_PATH) LPWSTR pszPath, L LWSTDAPI_(BOOL) PathAddExtensionW(__inout_ecount(MAX_PATH) LPWSTR pszPath, _
PCWSTR pszExt); _in_opt LPCWSTR pszExt);
#ifdef UNICODE #ifdef UNICODE
#define PathAddExtension PathAddExtensionW #define PathAddExtension PathAddExtensionW
#else #else
#define PathAddExtension PathAddExtensionA #define PathAddExtension PathAddExtensionA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathAppendA(__inout_ecount(MAX_PATH) LPSTR pszPath, LPCSTR p LWSTDAPI_(BOOL) PathAppendA(__inout_ecount(MAX_PATH) LPSTR pszPath, __in LPC
More); STR pMore);
LWSTDAPI_(BOOL) PathAppendW(__inout_ecount(MAX_PATH) LPWSTR pszPath, LPCWSTR LWSTDAPI_(BOOL) PathAppendW(__inout_ecount(MAX_PATH) LPWSTR pszPath, __in LP
pMore); CWSTR pMore);
LWSTDAPI_(LPSTR) PathBuildRootA(__out_ecount(4) LPSTR pszRoot, int iDrive); LWSTDAPI_(LPSTR) PathBuildRootA(__out_ecount(4) LPSTR pszRoot, int iDrive);
LWSTDAPI_(LPWSTR) PathBuildRootW(__out_ecount(4) LPWSTR pszRoot, int iDrive); LWSTDAPI_(LPWSTR) PathBuildRootW(__out_ecount(4) LPWSTR pszRoot, int iDrive);
#ifdef UNICODE #ifdef UNICODE
#define PathBuildRoot PathBuildRootW #define PathBuildRoot PathBuildRootW
#else #else
#define PathBuildRoot PathBuildRootA #define PathBuildRoot PathBuildRootA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathCanonicalizeA(__out_ecount(MAX_PATH) LPSTR pszBuf, LPCST LWSTDAPI_(BOOL) PathCanonicalizeA(__out_ecount(MAX_PATH) LPSTR pszBuf, __in
R pszPath); LPCSTR pszPath);
LWSTDAPI_(BOOL) PathCanonicalizeW(__out_ecount(MAX_PATH) LPWSTR pszBuf, LPCW LWSTDAPI_(BOOL) PathCanonicalizeW(__out_ecount(MAX_PATH) LPWSTR pszBuf, __in
STR pszPath); LPCWSTR pszPath);
LWSTDAPI_(LPSTR) PathCombineA(__out_ecount(MAX_PATH) LPSTR pszDest, LPCSTR pszD LWSTDAPI_(LPSTR) PathCombineA(__out_ecount(MAX_PATH) LPSTR pszDest, __in_opt LP
ir, LPCSTR pszFile); CSTR pszDir, __in_opt LPCSTR pszFile);
LWSTDAPI_(LPWSTR) PathCombineW(__out_ecount(MAX_PATH) LPWSTR pszDest, LPCWSTR p LWSTDAPI_(LPWSTR) PathCombineW(__out_ecount(MAX_PATH) LPWSTR pszDest, __in_opt
szDir, LPCWSTR pszFile); LPCWSTR pszDir, __in_opt LPCWSTR pszFile);
#ifdef UNICODE #ifdef UNICODE
#define PathCombine PathCombineW #define PathCombine PathCombineW
#else #else
#define PathCombine PathCombineA #define PathCombine PathCombineA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathCompactPathA(HDC hDC, __inout_ecount(MAX_PATH) LPSTR psz LWSTDAPI_(BOOL) PathCompactPathA(__in_opt HDC hDC, __inout_ecount(MAX_PATH)
Path, UINT dx); LPSTR pszPath, __in UINT dx);
LWSTDAPI_(BOOL) PathCompactPathW(HDC hDC, __inout_ecount(MAX_PATH) LPWSTR ps LWSTDAPI_(BOOL) PathCompactPathW(__in_opt HDC hDC, __inout_ecount(MAX_PATH)
zPath, UINT dx); LPWSTR pszPath, __in UINT dx);
LWSTDAPI_(BOOL) PathCompactPathExA(__out_ecount(cchMax) LPSTR pszOut, LPCSTR LWSTDAPI_(BOOL) PathCompactPathExA(__out_ecount(cchMax) LPSTR pszOut, __in L
pszSrc, UINT cchMax, DWORD dwFlags); PCSTR pszSrc, __in UINT cchMax, __in DWORD dwFlags);
LWSTDAPI_(BOOL) PathCompactPathExW(__out_ecount(cchMax) LPWSTR pszOut, LPCWS LWSTDAPI_(BOOL) PathCompactPathExW(__out_ecount(cchMax) LPWSTR pszOut, __in
TR pszSrc, UINT cchMax, DWORD dwFlags); LPCWSTR pszSrc, __in UINT cchMax, __in DWORD dwFlags);
LWSTDAPI_(int) PathCommonPrefixA(LPCSTR pszFile1, LPCSTR pszFile2, __out_ec LWSTDAPI_(int) PathCommonPrefixA(__in LPCSTR pszFile1, __in LPCSTR pszFile2
ount_opt(MAX_PATH) LPSTR achPath); , __out_ecount_opt(MAX_PATH) LPSTR achPath);
LWSTDAPI_(int) PathCommonPrefixW(LPCWSTR pszFile1, LPCWSTR pszFile2, __out_ LWSTDAPI_(int) PathCommonPrefixW(__in LPCWSTR pszFile1, __in LPCWSTR pszFil
ecount_opt(MAX_PATH) LPWSTR achPath); e2, __out_ecount_opt(MAX_PATH) LPWSTR achPath);
LWSTDAPI_(BOOL) PathFileExistsA(__in LPCSTR pszPath); LWSTDAPI_(BOOL) PathFileExistsA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathFileExistsW(__in LPCWSTR pszPath); LWSTDAPI_(BOOL) PathFileExistsW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathFileExists PathFileExistsW #define PathFileExists PathFileExistsW
#else #else
#define PathFileExists PathFileExistsA #define PathFileExists PathFileExistsA
#endif // !UNICODE #endif // !UNICODE
#ifdef USE_STRICT_CONST #ifdef USE_STRICT_CONST
LWSTDAPI_(LPCSTR) PathFindExtensionA(__in LPCSTR pszPath); LWSTDAPI_(LPCSTR) PathFindExtensionA(__in LPCSTR pszPath);
LWSTDAPI_(LPCWSTR) PathFindExtensionW(__in LPCWSTR pszPath); LWSTDAPI_(LPCWSTR) PathFindExtensionW(__in LPCWSTR pszPath);
skipping to change at line 519 skipping to change at line 545
#define PathFindFileName PathFindFileNameA #define PathFindFileName PathFindFileNameA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(LPSTR) PathFindNextComponentA(__in LPCSTR pszPath); LWSTDAPI_(LPSTR) PathFindNextComponentA(__in LPCSTR pszPath);
LWSTDAPI_(LPWSTR) PathFindNextComponentW(__in LPCWSTR pszPath); LWSTDAPI_(LPWSTR) PathFindNextComponentW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathFindNextComponent PathFindNextComponentW #define PathFindNextComponent PathFindNextComponentW
#else #else
#define PathFindNextComponent PathFindNextComponentA #define PathFindNextComponent PathFindNextComponentA
#endif // !UNICODE #endif // !UNICODE
#endif #endif
LWSTDAPI_(BOOL) PathFindOnPathA(__inout_ecount(MAX_PATH) LPSTR pszPath, __in LWSTDAPI_(BOOL) PathFindOnPathA(__inout_ecount(MAX_PATH) LPSTR pszPath, __in
_opt __nullterminated LPCSTR * ppszOtherDirs); _opt PZPCSTR ppszOtherDirs);
LWSTDAPI_(BOOL) PathFindOnPathW(__inout_ecount(MAX_PATH) LPWSTR pszPath, __i LWSTDAPI_(BOOL) PathFindOnPathW(__inout_ecount(MAX_PATH) LPWSTR pszPath, __i
n_opt __nullterminated LPCWSTR * ppszOtherDirs); n_opt PZPCWSTR ppszOtherDirs);
LWSTDAPI_(LPCSTR) PathFindSuffixArrayA(LPCSTR pszPath, __in_ecount(iArraySize) c LWSTDAPI_(LPCSTR) PathFindSuffixArrayA(__in LPCSTR pszPath, __in_ecount(iArraySi
onst LPCSTR *apszSuffix, int iArraySize); ze) const LPCSTR *apszSuffix, __in int iArraySize);
LWSTDAPI_(LPCWSTR) PathFindSuffixArrayW(LPCWSTR pszPath, __in_ecount(iArraySize) LWSTDAPI_(LPCWSTR) PathFindSuffixArrayW(__in LPCWSTR pszPath, __in_ecount(iArray
const LPCWSTR *apszSuffix, int iArraySize); Size) const LPCWSTR *apszSuffix, __in int iArraySize);
#ifdef UNICODE #ifdef UNICODE
#define PathFindSuffixArray PathFindSuffixArrayW #define PathFindSuffixArray PathFindSuffixArrayW
#else #else
#define PathFindSuffixArray PathFindSuffixArrayA #define PathFindSuffixArray PathFindSuffixArrayA
#endif // !UNICODE #endif // !UNICODE
#ifdef USE_STRICT_CONST #ifdef USE_STRICT_CONST
LWSTDAPI_(LPCSTR) PathGetArgsA(__in LPCSTR pszPath); LWSTDAPI_(LPCSTR) PathGetArgsA(__in LPCSTR pszPath);
LWSTDAPI_(LPCWSTR) PathGetArgsW(__in LPCWSTR pszPath); LWSTDAPI_(LPCWSTR) PathGetArgsW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathGetArgs PathGetArgsW #define PathGetArgs PathGetArgsW
skipping to change at line 545 skipping to change at line 571
#endif // !UNICODE #endif // !UNICODE
#else #else
LWSTDAPI_(LPSTR) PathGetArgsA(__in LPCSTR pszPath); LWSTDAPI_(LPSTR) PathGetArgsA(__in LPCSTR pszPath);
LWSTDAPI_(LPWSTR) PathGetArgsW(__in LPCWSTR pszPath); LWSTDAPI_(LPWSTR) PathGetArgsW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathGetArgs PathGetArgsW #define PathGetArgs PathGetArgsW
#else #else
#define PathGetArgs PathGetArgsA #define PathGetArgs PathGetArgsA
#endif // !UNICODE #endif // !UNICODE
#endif #endif
LWSTDAPI_(BOOL) PathIsLFNFileSpecA(LPCSTR lpName); LWSTDAPI_(BOOL) PathIsLFNFileSpecA(__in LPCSTR lpName);
LWSTDAPI_(BOOL) PathIsLFNFileSpecW(LPCWSTR lpName); LWSTDAPI_(BOOL) PathIsLFNFileSpecW(__in LPCWSTR lpName);
#ifdef UNICODE #ifdef UNICODE
#define PathIsLFNFileSpec PathIsLFNFileSpecW #define PathIsLFNFileSpec PathIsLFNFileSpecW
#else #else
#define PathIsLFNFileSpec PathIsLFNFileSpecA #define PathIsLFNFileSpec PathIsLFNFileSpecA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(UINT) PathGetCharTypeA(__in UCHAR ch); LWSTDAPI_(UINT) PathGetCharTypeA(__in UCHAR ch);
LWSTDAPI_(UINT) PathGetCharTypeW(__in WCHAR ch); LWSTDAPI_(UINT) PathGetCharTypeW(__in WCHAR ch);
// Return flags for PathGetCharType // Return flags for PathGetCharType
#define GCT_INVALID 0x0000 #define GCT_INVALID 0x0000
skipping to change at line 666 skipping to change at line 692
LWSTDAPI_(BOOL) PathMakePrettyW(__inout LPWSTR pszPath); LWSTDAPI_(BOOL) PathMakePrettyW(__inout LPWSTR pszPath);
LWSTDAPI_(BOOL) PathMatchSpecA(__in LPCSTR pszFile, __in LPCSTR pszSpec); LWSTDAPI_(BOOL) PathMatchSpecA(__in LPCSTR pszFile, __in LPCSTR pszSpec);
LWSTDAPI_(BOOL) PathMatchSpecW(__in LPCWSTR pszFile, __in LPCWSTR pszSpec); LWSTDAPI_(BOOL) PathMatchSpecW(__in LPCWSTR pszFile, __in LPCWSTR pszSpec);
#if (_WIN32_IE >= _WIN32_IE_IE70) #if (_WIN32_IE >= _WIN32_IE_IE70)
// Flags for PathMatchSpecEx // Flags for PathMatchSpecEx
#define PMSF_NORMAL 0x00000000 #define PMSF_NORMAL 0x00000000
#define PMSF_MULTIPLE 0x00000001 #define PMSF_MULTIPLE 0x00000001
#define PMSF_DONT_STRIP_SPACES 0x00010000 // modifies either of the above #define PMSF_DONT_STRIP_SPACES 0x00010000 // modifies either of the above
LWSTDAPI PathMatchSpecExA(LPCSTR pszFile, LPCSTR pszSpec, DWORD dwFlags); LWSTDAPI PathMatchSpecExA(__in LPCSTR pszFile, __in LPCSTR pszSpec, __in DWORD d
LWSTDAPI PathMatchSpecExW(LPCWSTR pszFile, LPCWSTR pszSpec, DWORD dwFlags); wFlags);
LWSTDAPI PathMatchSpecExW(__in LPCWSTR pszFile, __in LPCWSTR pszSpec, __in DWORD
dwFlags);
#endif // _WIN32_IE_IE70 #endif // _WIN32_IE_IE70
LWSTDAPI_(int) PathParseIconLocationA(__inout LPSTR pszIconFile); LWSTDAPI_(int) PathParseIconLocationA(__inout LPSTR pszIconFile);
LWSTDAPI_(int) PathParseIconLocationW(__inout LPWSTR pszIconFile); LWSTDAPI_(int) PathParseIconLocationW(__inout LPWSTR pszIconFile);
LWSTDAPI_(BOOL) PathQuoteSpacesA(__inout_ecount(MAX_PATH) LPSTR lpsz); LWSTDAPI_(BOOL) PathQuoteSpacesA(__inout_ecount(MAX_PATH) LPSTR lpsz);
LWSTDAPI_(BOOL) PathQuoteSpacesW(__inout_ecount(MAX_PATH) LPWSTR lpsz); LWSTDAPI_(BOOL) PathQuoteSpacesW(__inout_ecount(MAX_PATH) LPWSTR lpsz);
LWSTDAPI_(BOOL) PathRelativePathToA(__out_ecount(MAX_PATH) LPSTR pszPath, LP LWSTDAPI_(BOOL) PathRelativePathToA(__out_ecount(MAX_PATH) LPSTR pszPath, __
CSTR pszFrom, DWORD dwAttrFrom, LPCSTR pszTo, DWORD dwAttrTo); in LPCSTR pszFrom, __in DWORD dwAttrFrom, __in LPCSTR pszTo, __in DWORD dwAttrTo
LWSTDAPI_(BOOL) PathRelativePathToW(__out_ecount(MAX_PATH) LPWSTR pszPath, L );
PCWSTR pszFrom, DWORD dwAttrFrom, LPCWSTR pszTo, DWORD dwAttrTo); LWSTDAPI_(BOOL) PathRelativePathToW(__out_ecount(MAX_PATH) LPWSTR pszPath, _
_in LPCWSTR pszFrom, __in DWORD dwAttrFrom, __in LPCWSTR pszTo, __in DWORD dwAtt
rTo);
LWSTDAPI_(void) PathRemoveArgsA(__inout LPSTR pszPath); LWSTDAPI_(void) PathRemoveArgsA(__inout LPSTR pszPath);
LWSTDAPI_(void) PathRemoveArgsW(__inout LPWSTR pszPath); LWSTDAPI_(void) PathRemoveArgsW(__inout LPWSTR pszPath);
LWSTDAPI_(LPSTR) PathRemoveBackslashA(__inout LPSTR pszPath); LWSTDAPI_(LPSTR) PathRemoveBackslashA(__inout LPSTR pszPath);
LWSTDAPI_(LPWSTR) PathRemoveBackslashW(__inout LPWSTR pszPath); LWSTDAPI_(LPWSTR) PathRemoveBackslashW(__inout LPWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathRemoveBackslash PathRemoveBackslashW #define PathRemoveBackslash PathRemoveBackslashW
#else #else
#define PathRemoveBackslash PathRemoveBackslashA #define PathRemoveBackslash PathRemoveBackslashA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(void) PathRemoveBlanksA(__inout LPSTR pszPath); LWSTDAPI_(void) PathRemoveBlanksA(__inout LPSTR pszPath);
LWSTDAPI_(void) PathRemoveBlanksW(__inout LPWSTR pszPath); LWSTDAPI_(void) PathRemoveBlanksW(__inout LPWSTR pszPath);
LWSTDAPI_(void) PathRemoveExtensionA(__inout LPSTR pszPath); LWSTDAPI_(void) PathRemoveExtensionA(__inout LPSTR pszPath);
LWSTDAPI_(void) PathRemoveExtensionW(__inout LPWSTR pszPath); LWSTDAPI_(void) PathRemoveExtensionW(__inout LPWSTR pszPath);
LWSTDAPI_(BOOL) PathRemoveFileSpecA(__inout LPSTR pszPath); LWSTDAPI_(BOOL) PathRemoveFileSpecA(__inout LPSTR pszPath);
LWSTDAPI_(BOOL) PathRemoveFileSpecW(__inout LPWSTR pszPath); LWSTDAPI_(BOOL) PathRemoveFileSpecW(__inout LPWSTR pszPath);
LWSTDAPI_(BOOL) PathRenameExtensionA(__inout_ecount(MAX_PATH) LPSTR pszPath, LWSTDAPI_(BOOL) PathRenameExtensionA(__inout_ecount(MAX_PATH) LPSTR pszPath,
LPCSTR pszExt); __in LPCSTR pszExt);
LWSTDAPI_(BOOL) PathRenameExtensionW(__inout_ecount(MAX_PATH) LPWSTR pszPath LWSTDAPI_(BOOL) PathRenameExtensionW(__inout_ecount(MAX_PATH) LPWSTR pszPath
, LPCWSTR pszExt); , __in LPCWSTR pszExt);
LWSTDAPI_(BOOL) PathSearchAndQualifyA(LPCSTR pszPath, __out_ecount(cchBuf) L LWSTDAPI_(BOOL) PathSearchAndQualifyA(__in LPCSTR pszPath, __out_ecount(cchB
PSTR pszBuf, UINT cchBuf); uf) LPSTR pszBuf, UINT __in cchBuf);
LWSTDAPI_(BOOL) PathSearchAndQualifyW(LPCWSTR pszPath, __out_ecount(cchBuf) LWSTDAPI_(BOOL) PathSearchAndQualifyW(__in LPCWSTR pszPath, __out_ecount(cch
LPWSTR pszBuf, UINT cchBuf); Buf) LPWSTR pszBuf, __in UINT cchBuf);
LWSTDAPI_(void) PathSetDlgItemPathA(__in HWND hDlg, int id, LPCSTR pszPath); LWSTDAPI_(void) PathSetDlgItemPathA(__in HWND hDlg, int id, LPCSTR pszPath);
LWSTDAPI_(void) PathSetDlgItemPathW(__in HWND hDlg, int id, LPCWSTR pszPath) ; LWSTDAPI_(void) PathSetDlgItemPathW(__in HWND hDlg, int id, LPCWSTR pszPath) ;
#ifdef USE_STRICT_CONST #ifdef USE_STRICT_CONST
LWSTDAPI_(LPCSTR) PathSkipRootA(LPCSTR pszPath); LWSTDAPI_(LPCSTR) PathSkipRootA(__in LPCSTR pszPath);
LWSTDAPI_(LPCWSTR) PathSkipRootW(LPCWSTR pszPath); LWSTDAPI_(LPCWSTR) PathSkipRootW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathSkipRoot PathSkipRootW #define PathSkipRoot PathSkipRootW
#else #else
#define PathSkipRoot PathSkipRootA #define PathSkipRoot PathSkipRootA
#endif // !UNICODE #endif // !UNICODE
#else #else
LWSTDAPI_(LPSTR) PathSkipRootA(LPCSTR pszPath); LWSTDAPI_(LPSTR) PathSkipRootA(__in LPCSTR pszPath);
LWSTDAPI_(LPWSTR) PathSkipRootW(LPCWSTR pszPath); LWSTDAPI_(LPWSTR) PathSkipRootW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathSkipRoot PathSkipRootW #define PathSkipRoot PathSkipRootW
#else #else
#define PathSkipRoot PathSkipRootA #define PathSkipRoot PathSkipRootA
#endif // !UNICODE #endif // !UNICODE
#endif #endif
LWSTDAPI_(void) PathStripPathA(__inout LPSTR pszPath); LWSTDAPI_(void) PathStripPathA(__inout LPSTR pszPath);
LWSTDAPI_(void) PathStripPathW(__inout LPWSTR pszPath); LWSTDAPI_(void) PathStripPathW(__inout LPWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathStripPath PathStripPathW #define PathStripPath PathStripPathW
skipping to change at line 730 skipping to change at line 756
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathStripToRootA(__inout LPSTR pszPath); LWSTDAPI_(BOOL) PathStripToRootA(__inout LPSTR pszPath);
LWSTDAPI_(BOOL) PathStripToRootW(__inout LPWSTR pszPath); LWSTDAPI_(BOOL) PathStripToRootW(__inout LPWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathStripToRoot PathStripToRootW #define PathStripToRoot PathStripToRootW
#else #else
#define PathStripToRoot PathStripToRootA #define PathStripToRoot PathStripToRootA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathUnquoteSpacesA(__inout LPSTR lpsz); LWSTDAPI_(BOOL) PathUnquoteSpacesA(__inout LPSTR lpsz);
LWSTDAPI_(BOOL) PathUnquoteSpacesW(__inout LPWSTR lpsz); LWSTDAPI_(BOOL) PathUnquoteSpacesW(__inout LPWSTR lpsz);
LWSTDAPI_(BOOL) PathMakeSystemFolderA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathMakeSystemFolderA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathMakeSystemFolderW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathMakeSystemFolderW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathMakeSystemFolder PathMakeSystemFolderW #define PathMakeSystemFolder PathMakeSystemFolderW
#else #else
#define PathMakeSystemFolder PathMakeSystemFolderA #define PathMakeSystemFolder PathMakeSystemFolderA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathUnmakeSystemFolderA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathUnmakeSystemFolderA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathUnmakeSystemFolderW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathUnmakeSystemFolderW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathUnmakeSystemFolder PathUnmakeSystemFolderW #define PathUnmakeSystemFolder PathUnmakeSystemFolderW
#else #else
#define PathUnmakeSystemFolder PathUnmakeSystemFolderA #define PathUnmakeSystemFolder PathUnmakeSystemFolderA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsSystemFolderA(LPCSTR pszPath, DWORD dwAttrb); LWSTDAPI_(BOOL) PathIsSystemFolderA(__in_opt LPCSTR pszPath, __in DWORD dwAt
LWSTDAPI_(BOOL) PathIsSystemFolderW(LPCWSTR pszPath, DWORD dwAttrb); trb);
LWSTDAPI_(BOOL) PathIsSystemFolderW(__in_opt LPCWSTR pszPath, __in DWORD dwA
ttrb);
#ifdef UNICODE #ifdef UNICODE
#define PathIsSystemFolder PathIsSystemFolderW #define PathIsSystemFolder PathIsSystemFolderW
#else #else
#define PathIsSystemFolder PathIsSystemFolderA #define PathIsSystemFolder PathIsSystemFolderA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(void) PathUndecorateA(__inout LPSTR pszPath); LWSTDAPI_(void) PathUndecorateA(__inout LPSTR pszPath);
LWSTDAPI_(void) PathUndecorateW(__inout LPWSTR pszPath); LWSTDAPI_(void) PathUndecorateW(__inout LPWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathUndecorate PathUndecorateW #define PathUndecorate PathUndecorateW
#else #else
#define PathUndecorate PathUndecorateA #define PathUndecorate PathUndecorateA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathUnExpandEnvStringsA(LPCSTR pszPath, __out_ecount(cchBuf) LWSTDAPI_(BOOL) PathUnExpandEnvStringsA(__in LPCSTR pszPath, __out_ecount(cc
LPSTR pszBuf, UINT cchBuf); hBuf) LPSTR pszBuf, __in UINT cchBuf);
LWSTDAPI_(BOOL) PathUnExpandEnvStringsW(LPCWSTR pszPath, __out_ecount(cchBuf LWSTDAPI_(BOOL) PathUnExpandEnvStringsW(__in LPCWSTR pszPath, __out_ecount(c
) LPWSTR pszBuf, UINT cchBuf); chBuf) LPWSTR pszBuf, __in UINT cchBuf);
#ifdef UNICODE #ifdef UNICODE
#define PathUnExpandEnvStrings PathUnExpandEnvStringsW #define PathUnExpandEnvStrings PathUnExpandEnvStringsW
#else #else
#define PathUnExpandEnvStrings PathUnExpandEnvStringsA #define PathUnExpandEnvStrings PathUnExpandEnvStringsA
#endif // !UNICODE #endif // !UNICODE
#ifdef UNICODE #ifdef UNICODE
#define PathAppend PathAppendW #define PathAppend PathAppendW
#define PathCanonicalize PathCanonicalizeW #define PathCanonicalize PathCanonicalizeW
#define PathCompactPath PathCompactPathW #define PathCompactPath PathCompactPathW
skipping to change at line 820 skipping to change at line 846
#define PathRemoveArgs PathRemoveArgsA #define PathRemoveArgs PathRemoveArgsA
#define PathRemoveBlanks PathRemoveBlanksA #define PathRemoveBlanks PathRemoveBlanksA
#define PathRemoveExtension PathRemoveExtensionA #define PathRemoveExtension PathRemoveExtensionA
#define PathRemoveFileSpec PathRemoveFileSpecA #define PathRemoveFileSpec PathRemoveFileSpecA
#define PathRenameExtension PathRenameExtensionA #define PathRenameExtension PathRenameExtensionA
#define PathSearchAndQualify PathSearchAndQualifyA #define PathSearchAndQualify PathSearchAndQualifyA
#define PathSetDlgItemPath PathSetDlgItemPathA #define PathSetDlgItemPath PathSetDlgItemPathA
#define PathUnquoteSpaces PathUnquoteSpacesA #define PathUnquoteSpaces PathUnquoteSpacesA
#endif #endif
typedef enum { typedef enum
{
URL_SCHEME_INVALID = -1, URL_SCHEME_INVALID = -1,
URL_SCHEME_UNKNOWN = 0, URL_SCHEME_UNKNOWN = 0,
URL_SCHEME_FTP, URL_SCHEME_FTP,
URL_SCHEME_HTTP, URL_SCHEME_HTTP,
URL_SCHEME_GOPHER, URL_SCHEME_GOPHER,
URL_SCHEME_MAILTO, URL_SCHEME_MAILTO,
URL_SCHEME_NEWS, URL_SCHEME_NEWS,
URL_SCHEME_NNTP, URL_SCHEME_NNTP,
URL_SCHEME_TELNET, URL_SCHEME_TELNET,
URL_SCHEME_WAIS, URL_SCHEME_WAIS,
skipping to change at line 850 skipping to change at line 877
URL_SCHEME_RES, URL_SCHEME_RES,
#if (_WIN32_IE >= _WIN32_IE_IE60) #if (_WIN32_IE >= _WIN32_IE_IE60)
URL_SCHEME_MSSHELLROOTED, URL_SCHEME_MSSHELLROOTED,
URL_SCHEME_MSSHELLIDLIST, URL_SCHEME_MSSHELLIDLIST,
URL_SCHEME_MSHELP, URL_SCHEME_MSHELP,
#endif // _WIN32_IE_IE60 #endif // _WIN32_IE_IE60
#if (_WIN32_IE >= _WIN32_IE_IE70) #if (_WIN32_IE >= _WIN32_IE_IE70)
URL_SCHEME_MSSHELLDEVICE, URL_SCHEME_MSSHELLDEVICE,
URL_SCHEME_WILDCARD, URL_SCHEME_WILDCARD,
#endif // _WIN32_IE_IE70 #endif // _WIN32_IE_IE70
#if (NTDDI_VERSION >= NTDDI_VISTA)
URL_SCHEME_SEARCH_MS, URL_SCHEME_SEARCH_MS,
#endif
#if (NTDDI_VERSION >= NTDDI_VISTASP1)
URL_SCHEME_SEARCH,
#endif
#if (NTDDI_VERSION >= NTDDI_WIN7)
URL_SCHEME_KNOWNFOLDER,
#endif
URL_SCHEME_MAXVALUE, URL_SCHEME_MAXVALUE,
} URL_SCHEME; } URL_SCHEME;
typedef enum { typedef enum
{
URL_PART_NONE = 0, URL_PART_NONE = 0,
URL_PART_SCHEME = 1, URL_PART_SCHEME = 1,
URL_PART_HOSTNAME, URL_PART_HOSTNAME,
URL_PART_USERNAME, URL_PART_USERNAME,
URL_PART_PASSWORD, URL_PART_PASSWORD,
URL_PART_PORT, URL_PART_PORT,
URL_PART_QUERY, URL_PART_QUERY,
} URL_PART; } URL_PART;
typedef enum { typedef enum
{
URLIS_URL, URLIS_URL,
URLIS_OPAQUE, URLIS_OPAQUE,
URLIS_NOHISTORY, URLIS_NOHISTORY,
URLIS_FILEURL, URLIS_FILEURL,
URLIS_APPLIABLE, URLIS_APPLIABLE,
URLIS_DIRECTORY, URLIS_DIRECTORY,
URLIS_HASQUERY, URLIS_HASQUERY,
} URLIS; } URLIS;
#define URL_UNESCAPE 0x10000000 #define URL_UNESCAPE 0x10000000
skipping to change at line 892 skipping to change at line 929
#define URL_DONT_SIMPLIFY 0x08000000 #define URL_DONT_SIMPLIFY 0x08000000
#define URL_NO_META URL_DONT_SIMPLIFY #define URL_NO_META URL_DONT_SIMPLIFY
#define URL_UNESCAPE_INPLACE 0x00100000 #define URL_UNESCAPE_INPLACE 0x00100000
#define URL_CONVERT_IF_DOSPATH 0x00200000 #define URL_CONVERT_IF_DOSPATH 0x00200000
#define URL_UNESCAPE_HIGH_ANSI_ONLY 0x00400000 #define URL_UNESCAPE_HIGH_ANSI_ONLY 0x00400000
#define URL_INTERNAL_PATH 0x00800000 // Will escape #'s in paths #define URL_INTERNAL_PATH 0x00800000 // Will escape #'s in paths
#define URL_FILE_USE_PATHURL 0x00010000 #define URL_FILE_USE_PATHURL 0x00010000
#if (_WIN32_IE >= _WIN32_IE_IE60SP2) #if (_WIN32_IE >= _WIN32_IE_IE60SP2)
#define URL_DONT_UNESCAPE 0x00020000 // Do not unescape the path/ url at all #define URL_DONT_UNESCAPE 0x00020000 // Do not unescape the path/ url at all
#endif // _WIN32_IE_IE60SP2 #endif // _WIN32_IE_IE60SP2
#if (NTDDI_VERSION >= NTDDI_WIN7)
#define URL_ESCAPE_AS_UTF8 0x00040000 // Percent-encode all non-AS
CII characters as their UTF-8 equivalents.
#endif // (NTDDI_VERSION >= NTDDI_WIN7)
#define URL_ESCAPE_PERCENT 0x00001000 #define URL_ESCAPE_PERCENT 0x00001000
#define URL_ESCAPE_SEGMENT_ONLY 0x00002000 // Treat the entire URL para m as one URL segment. #define URL_ESCAPE_SEGMENT_ONLY 0x00002000 // Treat the entire URL para m as one URL segment.
#define URL_PARTFLAG_KEEPSCHEME 0x00000001 #define URL_PARTFLAG_KEEPSCHEME 0x00000001
#define URL_APPLY_DEFAULT 0x00000001 #define URL_APPLY_DEFAULT 0x00000001
#define URL_APPLY_GUESSSCHEME 0x00000002 #define URL_APPLY_GUESSSCHEME 0x00000002
#define URL_APPLY_GUESSFILE 0x00000004 #define URL_APPLY_GUESSFILE 0x00000004
#define URL_APPLY_FORCEAPPLY 0x00000008 #define URL_APPLY_FORCEAPPLY 0x00000008
LWSTDAPI_(int) UrlCompareA(__in LPCSTR psz1, __in LPCSTR psz2, __in BOO L fIgnoreSlash); LWSTDAPI_(int) UrlCompareA(__in LPCSTR psz1, __in LPCSTR psz2, __in BOO L fIgnoreSlash);
LWSTDAPI_(int) UrlCompareW(__in LPCWSTR psz1, __in LPCWSTR psz2, __in BOOL fIgnoreSlash); LWSTDAPI_(int) UrlCompareW(__in LPCWSTR psz1, __in LPCWSTR psz2, __in BOOL fIgnoreSlash);
LWSTDAPI UrlCombineA(LPCSTR pszBase, LPCSTR pszRelative, __out_ec ount_opt(*pcchCombined) LPSTR pszCombined, __inout LPDWORD pcchCombined, DWORD d wFlags); LWSTDAPI UrlCombineA(LPCSTR pszBase, LPCSTR pszRelative, __out_ec ount_opt(*pcchCombined) LPSTR pszCombined, __inout LPDWORD pcchCombined, DWORD d wFlags);
LWSTDAPI UrlCombineW(LPCWSTR pszBase, LPCWSTR pszRelative, __out_ ecount_opt(*pcchCombined) LPWSTR pszCombined, __inout LPDWORD pcchCombined, DWOR D dwFlags); LWSTDAPI UrlCombineW(LPCWSTR pszBase, LPCWSTR pszRelative, __out_ ecount_opt(*pcchCombined) LPWSTR pszCombined, __inout LPDWORD pcchCombined, DWOR D dwFlags);
LWSTDAPI UrlCanonicalizeA(LPCSTR pszUrl, __out_ecount(*pcchCanoni LWSTDAPI UrlCanonicalizeA(__in LPCSTR pszUrl, __out_ecount(*pcchC
calized) LPSTR pszCanonicalized, __inout LPDWORD pcchCanonicalized, DWORD dwFlag anonicalized) LPSTR pszCanonicalized, __inout LPDWORD pcchCanonicalized, __in DW
s); ORD dwFlags);
LWSTDAPI UrlCanonicalizeW(LPCWSTR pszUrl, __out_ecount(*pcchCanon LWSTDAPI UrlCanonicalizeW(__in LPCWSTR pszUrl, __out_ecount(*pcch
icalized) LPWSTR pszCanonicalized, __inout LPDWORD pcchCanonicalized, DWORD dwFl Canonicalized) LPWSTR pszCanonicalized, __inout LPDWORD pcchCanonicalized, __in
ags); DWORD dwFlags);
LWSTDAPI_(BOOL) UrlIsOpaqueA(LPCSTR pszURL); LWSTDAPI_(BOOL) UrlIsOpaqueA(LPCSTR pszURL);
LWSTDAPI_(BOOL) UrlIsOpaqueW(LPCWSTR pszURL); LWSTDAPI_(BOOL) UrlIsOpaqueW(LPCWSTR pszURL);
LWSTDAPI_(BOOL) UrlIsNoHistoryA(LPCSTR pszURL); LWSTDAPI_(BOOL) UrlIsNoHistoryA(LPCSTR pszURL);
LWSTDAPI_(BOOL) UrlIsNoHistoryW(LPCWSTR pszURL); LWSTDAPI_(BOOL) UrlIsNoHistoryW(LPCWSTR pszURL);
#define UrlIsFileUrlA(pszURL) UrlIsA(pszURL, URLIS_FILEURL) #define UrlIsFileUrlA(pszURL) UrlIsA(pszURL, URLIS_FILEURL)
#define UrlIsFileUrlW(pszURL) UrlIsW(pszURL, URLIS_FILEURL) #define UrlIsFileUrlW(pszURL) UrlIsW(pszURL, URLIS_FILEURL)
LWSTDAPI_(BOOL) UrlIsA(LPCSTR pszUrl, __in URLIS UrlIs); LWSTDAPI_(BOOL) UrlIsA(LPCSTR pszUrl, __in URLIS UrlIs);
LWSTDAPI_(BOOL) UrlIsW(LPCWSTR pszUrl, __in URLIS UrlIs); LWSTDAPI_(BOOL) UrlIsW(LPCWSTR pszUrl, __in URLIS UrlIs);
LWSTDAPI_(LPCSTR) UrlGetLocationA(LPCSTR psz1); LWSTDAPI_(LPCSTR) UrlGetLocationA(LPCSTR psz1);
LWSTDAPI_(LPCWSTR) UrlGetLocationW(LPCWSTR psz1); LWSTDAPI_(LPCWSTR) UrlGetLocationW(LPCWSTR psz1);
LWSTDAPI UrlUnescapeA(__inout LPSTR pszUrl, __out_ecount_opt(*pcc hUnescaped) LPSTR pszUnescaped, __inout_opt LPDWORD pcchUnescaped, DWORD dwFlags ); LWSTDAPI UrlUnescapeA(__inout LPSTR pszUrl, __out_ecount_opt(*pcc hUnescaped) LPSTR pszUnescaped, __inout_opt LPDWORD pcchUnescaped, DWORD dwFlags );
LWSTDAPI UrlUnescapeW(__inout LPWSTR pszUrl, __out_ecount_opt(*pc chUnescaped) LPWSTR pszUnescaped, __inout_opt LPDWORD pcchUnescaped, DWORD dwFla gs); LWSTDAPI UrlUnescapeW(__inout LPWSTR pszUrl, __out_ecount_opt(*pc chUnescaped) LPWSTR pszUnescaped, __inout_opt LPDWORD pcchUnescaped, DWORD dwFla gs);
LWSTDAPI UrlEscapeA(LPCSTR pszUrl, __out_ecount(*pcchEscaped) LPS LWSTDAPI UrlEscapeA(__in LPCSTR pszUrl, __out_ecount(*pcchEscaped
TR pszEscaped, __inout LPDWORD pcchEscaped, DWORD dwFlags); ) LPSTR pszEscaped, __inout LPDWORD pcchEscaped, __in DWORD dwFlags);
LWSTDAPI UrlEscapeW(LPCWSTR pszUrl, __out_ecount(*pcchEscaped) LP LWSTDAPI UrlEscapeW(__in LPCWSTR pszUrl, __out_ecount(*pcchEscape
WSTR pszEscaped, __inout LPDWORD pcchEscaped, DWORD dwFlags); d) LPWSTR pszEscaped, __inout LPDWORD pcchEscaped, __in DWORD dwFlags);
LWSTDAPI UrlCreateFromPathA(LPCSTR pszPath, __out_ecount(*pcchUrl ) LPSTR pszUrl, __inout LPDWORD pcchUrl, DWORD dwFlags); LWSTDAPI UrlCreateFromPathA(LPCSTR pszPath, __out_ecount(*pcchUrl ) LPSTR pszUrl, __inout LPDWORD pcchUrl, DWORD dwFlags);
LWSTDAPI UrlCreateFromPathW(LPCWSTR pszPath, __out_ecount(*pcchUr l) LPWSTR pszUrl, __inout LPDWORD pcchUrl, DWORD dwFlags); LWSTDAPI UrlCreateFromPathW(LPCWSTR pszPath, __out_ecount(*pcchUr l) LPWSTR pszUrl, __inout LPDWORD pcchUrl, DWORD dwFlags);
LWSTDAPI PathCreateFromUrlA(LPCSTR pszUrl, __out_ecount(*pcchPath ) LPSTR pszPath, __inout LPDWORD pcchPath, DWORD dwFlags); LWSTDAPI PathCreateFromUrlA(LPCSTR pszUrl, __out_ecount(*pcchPath ) LPSTR pszPath, __inout LPDWORD pcchPath, DWORD dwFlags);
LWSTDAPI PathCreateFromUrlW(LPCWSTR pszUrl, __out_ecount(*pcchPat h) LPWSTR pszPath, __inout LPDWORD pcchPath, DWORD dwFlags); LWSTDAPI PathCreateFromUrlW(LPCWSTR pszUrl, __out_ecount(*pcchPat h) LPWSTR pszPath, __inout LPDWORD pcchPath, DWORD dwFlags);
#if (_WIN32_IE >= _WIN32_IE_IE70) #if (_WIN32_IE >= _WIN32_IE_IE70)
LWSTDAPI PathCreateFromUrlAlloc(LPCWSTR pszIn, __out LPWSTR *ppsz Out, DWORD dwFlags); LWSTDAPI PathCreateFromUrlAlloc(LPCWSTR pszIn, __out LPWSTR *ppsz Out, DWORD dwFlags);
#endif // _WIN32_IE_IE70 #endif // _WIN32_IE_IE70
LWSTDAPI UrlHashA(LPCSTR pszUrl, __out_ecount(cbHash) LPBYTE pbHa sh, DWORD cbHash); LWSTDAPI UrlHashA(LPCSTR pszUrl, __out_ecount(cbHash) LPBYTE pbHa sh, DWORD cbHash);
LWSTDAPI UrlHashW(LPCWSTR pszUrl, __out_ecount(cbHash) LPBYTE pbH ash, DWORD cbHash); LWSTDAPI UrlHashW(LPCWSTR pszUrl, __out_ecount(cbHash) LPBYTE pbH ash, DWORD cbHash);
LWSTDAPI UrlGetPartW(LPCWSTR pszIn, __out_ecount(*pcchOut) LPWSTR LWSTDAPI UrlGetPartW(__in LPCWSTR pszIn, __out_ecount(*pcchOut) L
pszOut, __inout LPDWORD pcchOut, DWORD dwPart, DWORD dwFlags); PWSTR pszOut, __inout LPDWORD pcchOut, __in DWORD dwPart, __in DWORD dwFlags);
LWSTDAPI UrlGetPartA(LPCSTR pszIn, __out_ecount(*pcchOut) LPSTR p LWSTDAPI UrlGetPartA(__in LPCSTR pszIn, __out_ecount(*pcchOut) LP
szOut, __inout LPDWORD pcchOut, DWORD dwPart, DWORD dwFlags); STR pszOut, __inout LPDWORD pcchOut, __in DWORD dwPart, __in DWORD dwFlags);
LWSTDAPI UrlApplySchemeA(LPCSTR pszIn, __out_ecount(*pcchOut) LPS TR pszOut, __inout LPDWORD pcchOut, DWORD dwFlags); LWSTDAPI UrlApplySchemeA(LPCSTR pszIn, __out_ecount(*pcchOut) LPS TR pszOut, __inout LPDWORD pcchOut, DWORD dwFlags);
LWSTDAPI UrlApplySchemeW(LPCWSTR pszIn, __out_ecount(*pcchOut) LP WSTR pszOut, __inout LPDWORD pcchOut, DWORD dwFlags); LWSTDAPI UrlApplySchemeW(LPCWSTR pszIn, __out_ecount(*pcchOut) LP WSTR pszOut, __inout LPDWORD pcchOut, DWORD dwFlags);
LWSTDAPI HashData(__in_ecount(cbData) LPBYTE pbData, DWORD cbData , __out_ecount(cbHash) LPBYTE pbHash, DWORD cbHash); LWSTDAPI HashData(__in_ecount(cbData) LPBYTE pbData, DWORD cbData , __out_ecount(cbHash) LPBYTE pbHash, DWORD cbHash);
LWSTDAPI UrlFixupW(LPCWSTR pszIn, __out_ecount(cchOut) LPWSTR psz Out, DWORD cchOut); LWSTDAPI UrlFixupW(LPCWSTR pszIn, __out_ecount(cchOut) LPWSTR psz Out, DWORD cchOut);
#ifdef UNICODE #ifdef UNICODE
#define UrlCompare UrlCompareW #define UrlCompare UrlCompareW
#define UrlCombine UrlCombineW #define UrlCombine UrlCombineW
#define UrlCanonicalize UrlCanonicalizeW #define UrlCanonicalize UrlCanonicalizeW
#define UrlIsOpaque UrlIsOpaqueW #define UrlIsOpaque UrlIsOpaqueW
skipping to change at line 1069 skipping to change at line 1109
__in_opt LPCWSTR pszValue, __in_opt LPCWSTR pszValue,
__out_opt DWORD *pdwType, __out_opt DWORD *pdwType,
__out_bcount_opt(*pcbData) void *pvData, __out_bcount_opt(*pcbData) void *pvData,
__inout_opt DWORD *pcbData); __inout_opt DWORD *pcbData);
#ifdef UNICODE #ifdef UNICODE
#define SHGetValue SHGetValueW #define SHGetValue SHGetValueW
#else #else
#define SHGetValue SHGetValueA #define SHGetValue SHGetValueA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(LSTATUS) SHSetValueA(__in HKEY hkey, __in_opt LPCSTR pszSubKey, __i n_opt LPCSTR pszValue, __in DWORD dwType, LWSTDAPI_(LSTATUS) SHSetValueA(__in HKEY hkey, __in_opt LPCSTR pszSubKey, __i n_opt LPCSTR pszValue, __in DWORD dwType,
__typefix(LPBYTE) __in_bcount_opt(cbData) LPCVOID pvData, __in_opt DWORD cbD ata); __in_bcount_opt(cbData) LPCVOID pvData, __in DWORD cbData);
LWSTDAPI_(LSTATUS) SHSetValueW(__in HKEY hkey, __in_opt LPCWSTR pszSubKey, __ in_opt LPCWSTR pszValue, __in DWORD dwType, LWSTDAPI_(LSTATUS) SHSetValueW(__in HKEY hkey, __in_opt LPCWSTR pszSubKey, __ in_opt LPCWSTR pszValue, __in DWORD dwType,
__typefix(LPBYTE) __in_bcount_opt(cbData) LPCVOID pvData, __in_opt DWORD cbD ata); __in_bcount_opt(cbData) LPCVOID pvData, __in DWORD cbData);
#ifdef UNICODE #ifdef UNICODE
#define SHSetValue SHSetValueW #define SHSetValue SHSetValueW
#else #else
#define SHSetValue SHSetValueA #define SHSetValue SHSetValueA
#endif // !UNICODE #endif // !UNICODE
#if (_WIN32_IE >= 0x0602) #if (_WIN32_IE >= 0x0602)
// //
// SRRF - Shell Registry Routine Flags (for SHRegGetValue) // SRRF - Shell Registry Routine Flags (for SHRegGetValue)
// //
skipping to change at line 1392 skipping to change at line 1432
#define SHQueryInfoKey SHQueryInfoKeyA #define SHQueryInfoKey SHQueryInfoKeyA
#define SHCopyKey SHCopyKeyA #define SHCopyKey SHCopyKeyA
#define SHRegGetPath SHRegGetPathA #define SHRegGetPath SHRegGetPathA
#define SHRegSetPath SHRegSetPathA #define SHRegSetPath SHRegSetPathA
#endif #endif
////////////////////////////////////////////// //////////////////////////////////////////////
// User Specific Registry Access Functions // User Specific Registry Access Functions
////////////////////////////////////////////// //////////////////////////////////////////////
//
// Type definitions.
//
typedef enum typedef enum
{ {
SHREGDEL_DEFAULT = 0x00000000, // Delete's HKCU, or HKLM if HKCU is no t found. SHREGDEL_DEFAULT = 0x00000000, // Delete's HKCU, or HKLM if HKCU is no t found.
SHREGDEL_HKCU = 0x00000001, // Delete HKCU only SHREGDEL_HKCU = 0x00000001, // Delete HKCU only
SHREGDEL_HKLM = 0x00000010, // Delete HKLM only. SHREGDEL_HKLM = 0x00000010, // Delete HKLM only.
SHREGDEL_BOTH = 0x00000011, // Delete both HKCU and HKLM. SHREGDEL_BOTH = 0x00000011, // Delete both HKCU and HKLM.
} SHREGDEL_FLAGS; } SHREGDEL_FLAGS;
typedef enum typedef enum
{ {
skipping to change at line 1454 skipping to change at line 1490
LWSTDAPI_(LSTATUS) SHRegWriteUSValueA(__in HUSKEY hUSKey, __in LPCSTR pszVal ue, __in DWORD dwType, __in_bcount(cbData) const void *pvData, __in DWORD cbData , __in DWORD dwFlags); LWSTDAPI_(LSTATUS) SHRegWriteUSValueA(__in HUSKEY hUSKey, __in LPCSTR pszVal ue, __in DWORD dwType, __in_bcount(cbData) const void *pvData, __in DWORD cbData , __in DWORD dwFlags);
LWSTDAPI_(LSTATUS) SHRegWriteUSValueW(__in HUSKEY hUSKey, __in LPCWSTR pwzVa lue, __in DWORD dwType, __in_bcount(cbData) const void *pvData, __in DWORD cbDat a, __in DWORD dwFlags); LWSTDAPI_(LSTATUS) SHRegWriteUSValueW(__in HUSKEY hUSKey, __in LPCWSTR pwzVa lue, __in DWORD dwType, __in_bcount(cbData) const void *pvData, __in DWORD cbDat a, __in DWORD dwFlags);
LWSTDAPI_(LSTATUS) SHRegDeleteUSValueA(__in HUSKEY hUSKey, __in LPCSTR pszVa lue, __in SHREGDEL_FLAGS delRegFlags); LWSTDAPI_(LSTATUS) SHRegDeleteUSValueA(__in HUSKEY hUSKey, __in LPCSTR pszVa lue, __in SHREGDEL_FLAGS delRegFlags);
LWSTDAPI_(LSTATUS) SHRegDeleteUSValueW(__in HUSKEY hUSKey, __in LPCWSTR pwzV alue, __in SHREGDEL_FLAGS delRegFlags); LWSTDAPI_(LSTATUS) SHRegDeleteUSValueW(__in HUSKEY hUSKey, __in LPCWSTR pwzV alue, __in SHREGDEL_FLAGS delRegFlags);
LWSTDAPI_(LSTATUS) SHRegDeleteEmptyUSKeyW(__in HUSKEY hUSKey, __in LPCWSTR p wzSubKey, __in SHREGDEL_FLAGS delRegFlags); LWSTDAPI_(LSTATUS) SHRegDeleteEmptyUSKeyW(__in HUSKEY hUSKey, __in LPCWSTR p wzSubKey, __in SHREGDEL_FLAGS delRegFlags);
LWSTDAPI_(LSTATUS) SHRegDeleteEmptyUSKeyA(__in HUSKEY hUSKey, __in LPCSTR ps zSubKey, __in SHREGDEL_FLAGS delRegFlags); LWSTDAPI_(LSTATUS) SHRegDeleteEmptyUSKeyA(__in HUSKEY hUSKey, __in LPCSTR ps zSubKey, __in SHREGDEL_FLAGS delRegFlags);
LWSTDAPI_(LSTATUS) SHRegEnumUSKeyA(__in HUSKEY hUSKey, __in DWORD dwIndex, _ _out_ecount_part(*pcchName,*pcchName) LPSTR pszName, __inout LPDWORD pcchName, _ _in SHREGENUM_FLAGS enumRegFlags); LWSTDAPI_(LSTATUS) SHRegEnumUSKeyA(__in HUSKEY hUSKey, __in DWORD dwIndex, _ _out_ecount_part(*pcchName,*pcchName) LPSTR pszName, __inout LPDWORD pcchName, _ _in SHREGENUM_FLAGS enumRegFlags);
LWSTDAPI_(LSTATUS) SHRegEnumUSKeyW(__in HUSKEY hUSKey, __in DWORD dwIndex, _ _out_ecount_part(*pcchName,*pcchName) LPWSTR pwzName, __inout LPDWORD pcchName, __in SHREGENUM_FLAGS enumRegFlags); LWSTDAPI_(LSTATUS) SHRegEnumUSKeyW(__in HUSKEY hUSKey, __in DWORD dwIndex, _ _out_ecount_part(*pcchName,*pcchName) LPWSTR pwzName, __inout LPDWORD pcchName, __in SHREGENUM_FLAGS enumRegFlags);
LWSTDAPI_(LSTATUS) SHRegEnumUSValueA(__in HUSKEY hUSkey, __in DWORD dwIndex, LWSTDAPI_(LSTATUS) SHRegEnumUSValueA(__in HUSKEY hUSkey, __in DWORD dwIndex,
__out_ecount_part(*pcchValueName,*pcchValueName) LPSTR pszValueName, __inout LPDWORD pcchValueName, __out_opt LPDWORD pdwType, __out_ecount_part(*pcchValueName,*pcchValueName) LPSTR pszValueName, __inout LPDWORD pcchValueName, __out_opt LPDWORD pdwType,
__out_bcount_opt(*pcbData) void *pvData, __inout_opt LPDWORD pcbData, __in S HREGENUM_FLAGS enumRegFlags); __out_bcount_part_opt(*pcbData, *pcbData) void *pvData, __inout_opt LPDWORD pcbData, __in SHREGENUM_FLAGS enumRegFlags);
LWSTDAPI_(LSTATUS) SHRegEnumUSValueW(__in HUSKEY hUSkey, __in DWORD dwIndex, LWSTDAPI_(LSTATUS) SHRegEnumUSValueW(__in HUSKEY hUSkey, __in DWORD dwIndex,
__out_ecount_part(*pcchValueName,*pcchValueName) LPWSTR pszValueName, __inou t LPDWORD pcchValueName, __out_opt LPDWORD pdwType, __out_ecount_part(*pcchValueName,*pcchValueName) LPWSTR pszValueName, __inou t LPDWORD pcchValueName, __out_opt LPDWORD pdwType,
__out_bcount_opt(*pcbData) void *pvData, __inout_opt LPDWORD pcbData, __in S HREGENUM_FLAGS enumRegFlags); __out_bcount_part_opt(*pcbData, *pcbData) void *pvData, __inout_opt LPDWORD pcbData, __in SHREGENUM_FLAGS enumRegFlags);
LWSTDAPI_(LSTATUS) SHRegQueryInfoUSKeyA(__in HUSKEY hUSKey, __out_opt LPDWOR D pcSubKeys, __out_opt LPDWORD pcchMaxSubKeyLen, __out_opt LPDWORD pcValues, __o ut_opt LPDWORD pcchMaxValueNameLen, __in SHREGENUM_FLAGS enumRegFlags); LWSTDAPI_(LSTATUS) SHRegQueryInfoUSKeyA(__in HUSKEY hUSKey, __out_opt LPDWOR D pcSubKeys, __out_opt LPDWORD pcchMaxSubKeyLen, __out_opt LPDWORD pcValues, __o ut_opt LPDWORD pcchMaxValueNameLen, __in SHREGENUM_FLAGS enumRegFlags);
LWSTDAPI_(LSTATUS) SHRegQueryInfoUSKeyW(__in HUSKEY hUSKey, __out_opt LPDWOR D pcSubKeys, __out_opt LPDWORD pcchMaxSubKeyLen, __out_opt LPDWORD pcValues, __o ut_opt LPDWORD pcchMaxValueNameLen, __in SHREGENUM_FLAGS enumRegFlags); LWSTDAPI_(LSTATUS) SHRegQueryInfoUSKeyW(__in HUSKEY hUSKey, __out_opt LPDWOR D pcSubKeys, __out_opt LPDWORD pcchMaxSubKeyLen, __out_opt LPDWORD pcValues, __o ut_opt LPDWORD pcchMaxValueNameLen, __in SHREGENUM_FLAGS enumRegFlags);
LWSTDAPI_(LSTATUS) SHRegCloseUSKey(__in HUSKEY hUSKey); LWSTDAPI_(LSTATUS) SHRegCloseUSKey(__in HUSKEY hUSKey);
// These calls are equal to an SHRegOpenUSKey, SHRegQueryUSValue, and then a SHR egCloseUSKey. // These calls are equal to an SHRegOpenUSKey, SHRegQueryUSValue, and then a SHR egCloseUSKey.
STDAPI_(LSTATUS) SHRegGetUSValueA( STDAPI_(LSTATUS) SHRegGetUSValueA(
__in LPCSTR pszSubKey, __in LPCSTR pszSubKey,
__in_opt LPCSTR pszValue, __in_opt LPCSTR pszValue,
__inout_opt DWORD *pdwType, __inout_opt DWORD *pdwType,
__out_bcount_part_opt(*pcbData, *pcbData) void *pvData, __out_bcount_part_opt(*pcbData, *pcbData) void *pvData,
__inout_opt DWORD *pcbData, __inout_opt DWORD *pcbData,
__in BOOL fIgnoreHKCU, __in BOOL fIgnoreHKCU,
__in_bcount_opt(dwDefaultDataSize) void *pvDefaultData, __in_bcount_opt(dwDefaultDataSize) void *pvDefaultData,
__in_opt DWORD dwDefaultDataSize); __in DWORD dwDefaultDataSize);
STDAPI_(LSTATUS) SHRegGetUSValueW( STDAPI_(LSTATUS) SHRegGetUSValueW(
__in LPCWSTR pszSubKey, __in LPCWSTR pszSubKey,
__in_opt LPCWSTR pszValue, __in_opt LPCWSTR pszValue,
__inout_opt DWORD *pdwType, __inout_opt DWORD *pdwType,
__out_bcount_part_opt(*pcbData, *pcbData) void *pvData, __out_bcount_part_opt(*pcbData, *pcbData) void *pvData,
__inout_opt DWORD *pcbData, __inout_opt DWORD *pcbData,
__in BOOL fIgnoreHKCU, __in BOOL fIgnoreHKCU,
__in_bcount_opt(dwDefaultDataSize) void *pvDefaultData, __in_bcount_opt(dwDefaultDataSize) void *pvDefaultData,
__in_opt DWORD dwDefaultDataSize); __in DWORD dwDefaultDataSize);
LWSTDAPI_(LSTATUS) SHRegSetUSValueA(__in LPCSTR pszSubKey, __in LPCSTR pszVa lue, __in DWORD dwType, __in_bcount_opt(cbData) const void *pvData, __in_opt DWO RD cbData, __in_opt DWORD dwFlags); LWSTDAPI_(LSTATUS) SHRegSetUSValueA(__in LPCSTR pszSubKey, __in LPCSTR pszVa lue, __in DWORD dwType, __in_bcount_opt(cbData) const void *pvData, __in_opt DWO RD cbData, __in_opt DWORD dwFlags);
LWSTDAPI_(LSTATUS) SHRegSetUSValueW(__in LPCWSTR pwzSubKey, __in LPCWSTR pwz Value, __in DWORD dwType, __in_bcount_opt(cbData) const void *pvData, __in_opt D WORD cbData, __in_opt DWORD dwFlags); LWSTDAPI_(LSTATUS) SHRegSetUSValueW(__in LPCWSTR pwzSubKey, __in LPCWSTR pwz Value, __in DWORD dwType, __in_bcount_opt(cbData) const void *pvData, __in_opt D WORD cbData, __in_opt DWORD dwFlags);
LWSTDAPI_(int) SHRegGetIntW(__in HKEY hk, __in_opt PCWSTR pwzKey, __in i nt iDefault); LWSTDAPI_(int) SHRegGetIntW(__in HKEY hk, __in_opt PCWSTR pwzKey, __in i nt iDefault);
#ifdef UNICODE #ifdef UNICODE
#define SHRegCreateUSKey SHRegCreateUSKeyW #define SHRegCreateUSKey SHRegCreateUSKeyW
#define SHRegOpenUSKey SHRegOpenUSKeyW #define SHRegOpenUSKey SHRegOpenUSKeyW
#define SHRegQueryUSValue SHRegQueryUSValueW #define SHRegQueryUSValue SHRegQueryUSValueW
#define SHRegWriteUSValue SHRegWriteUSValueW #define SHRegWriteUSValue SHRegWriteUSValueW
#define SHRegDeleteUSValue SHRegDeleteUSValueW #define SHRegDeleteUSValue SHRegDeleteUSValueW
skipping to change at line 1512 skipping to change at line 1548
#define SHRegWriteUSValue SHRegWriteUSValueA #define SHRegWriteUSValue SHRegWriteUSValueA
#define SHRegDeleteUSValue SHRegDeleteUSValueA #define SHRegDeleteUSValue SHRegDeleteUSValueA
#define SHRegDeleteEmptyUSKey SHRegDeleteEmptyUSKeyA #define SHRegDeleteEmptyUSKey SHRegDeleteEmptyUSKeyA
#define SHRegEnumUSKey SHRegEnumUSKeyA #define SHRegEnumUSKey SHRegEnumUSKeyA
#define SHRegEnumUSValue SHRegEnumUSValueA #define SHRegEnumUSValue SHRegEnumUSValueA
#define SHRegQueryInfoUSKey SHRegQueryInfoUSKeyA #define SHRegQueryInfoUSKey SHRegQueryInfoUSKeyA
#define SHRegGetUSValue SHRegGetUSValueA #define SHRegGetUSValue SHRegGetUSValueA
#define SHRegSetUSValue SHRegSetUSValueA #define SHRegSetUSValue SHRegSetUSValueA
#endif #endif
LWSTDAPI_(BOOL) SHRegGetBoolUSValueA(__in LPCSTR pszSubKey, __in LPCSTR pszValue LWSTDAPI_(BOOL) SHRegGetBoolUSValueA(__in LPCSTR pszSubKey, __in_opt LPCSTR pszV
, __in BOOL fIgnoreHKCU, __in BOOL fDefault); alue, __in BOOL fIgnoreHKCU, __in BOOL fDefault);
LWSTDAPI_(BOOL) SHRegGetBoolUSValueW(__in LPCWSTR pszSubKey, __in LPCWSTR pszVal LWSTDAPI_(BOOL) SHRegGetBoolUSValueW(__in LPCWSTR pszSubKey, __in_opt LPCWSTR ps
ue, __in BOOL fIgnoreHKCU, __in BOOL fDefault); zValue, __in BOOL fIgnoreHKCU, __in BOOL fDefault);
#ifdef UNICODE #ifdef UNICODE
#define SHRegGetBoolUSValue SHRegGetBoolUSValueW #define SHRegGetBoolUSValue SHRegGetBoolUSValueW
#else #else
#define SHRegGetBoolUSValue SHRegGetBoolUSValueA #define SHRegGetBoolUSValue SHRegGetBoolUSValueA
#endif // !UNICODE #endif // !UNICODE
// //
// Association APIs // Association APIs
// //
// these APIs are to assist in accessing the data in HKCR // these APIs are to assist in accessing the data in HKCR
// getting the Command strings and exe paths // getting the Command strings and exe paths
// for different verbs and extensions are simplified this way // for different verbs and extensions are simplified this way
// //
enum { enum
{
ASSOCF_INIT_NOREMAPCLSID = 0x00000001, // do not remap clsids to progids ASSOCF_INIT_NOREMAPCLSID = 0x00000001, // do not remap clsids to progids
ASSOCF_INIT_BYEXENAME = 0x00000002, // executable is being pa ssed in ASSOCF_INIT_BYEXENAME = 0x00000002, // executable is being pa ssed in
ASSOCF_OPEN_BYEXENAME = 0x00000002, // executable is being pa ssed in ASSOCF_OPEN_BYEXENAME = 0x00000002, // executable is being pa ssed in
ASSOCF_INIT_DEFAULTTOSTAR = 0x00000004, // treat "*" as the BaseC lass ASSOCF_INIT_DEFAULTTOSTAR = 0x00000004, // treat "*" as the BaseC lass
ASSOCF_INIT_DEFAULTTOFOLDER = 0x00000008, // treat "Folder" as the BaseClass ASSOCF_INIT_DEFAULTTOFOLDER = 0x00000008, // treat "Folder" as the BaseClass
ASSOCF_NOUSERSETTINGS = 0x00000010, // dont use HKCU ASSOCF_NOUSERSETTINGS = 0x00000010, // dont use HKCU
ASSOCF_NOTRUNCATE = 0x00000020, // dont truncate the retu rn string ASSOCF_NOTRUNCATE = 0x00000020, // dont truncate the retu rn string
ASSOCF_VERIFY = 0x00000040, // verify data is accurat e (DISK HITS) ASSOCF_VERIFY = 0x00000040, // verify data is accurat e (DISK HITS)
ASSOCF_REMAPRUNDLL = 0x00000080, // actually gets info abo ut rundlls target if applicable ASSOCF_REMAPRUNDLL = 0x00000080, // actually gets info abo ut rundlls target if applicable
ASSOCF_NOFIXUPS = 0x00000100, // attempt to fix errors if found ASSOCF_NOFIXUPS = 0x00000100, // attempt to fix errors if found
skipping to change at line 1542 skipping to change at line 1579
ASSOCF_INIT_DEFAULTTOSTAR = 0x00000004, // treat "*" as the BaseC lass ASSOCF_INIT_DEFAULTTOSTAR = 0x00000004, // treat "*" as the BaseC lass
ASSOCF_INIT_DEFAULTTOFOLDER = 0x00000008, // treat "Folder" as the BaseClass ASSOCF_INIT_DEFAULTTOFOLDER = 0x00000008, // treat "Folder" as the BaseClass
ASSOCF_NOUSERSETTINGS = 0x00000010, // dont use HKCU ASSOCF_NOUSERSETTINGS = 0x00000010, // dont use HKCU
ASSOCF_NOTRUNCATE = 0x00000020, // dont truncate the retu rn string ASSOCF_NOTRUNCATE = 0x00000020, // dont truncate the retu rn string
ASSOCF_VERIFY = 0x00000040, // verify data is accurat e (DISK HITS) ASSOCF_VERIFY = 0x00000040, // verify data is accurat e (DISK HITS)
ASSOCF_REMAPRUNDLL = 0x00000080, // actually gets info abo ut rundlls target if applicable ASSOCF_REMAPRUNDLL = 0x00000080, // actually gets info abo ut rundlls target if applicable
ASSOCF_NOFIXUPS = 0x00000100, // attempt to fix errors if found ASSOCF_NOFIXUPS = 0x00000100, // attempt to fix errors if found
ASSOCF_IGNOREBASECLASS = 0x00000200, // dont recurse into the baseclass ASSOCF_IGNOREBASECLASS = 0x00000200, // dont recurse into the baseclass
ASSOCF_INIT_IGNOREUNKNOWN = 0x00000400, // dont use the "Unknown" progid, instead fail ASSOCF_INIT_IGNOREUNKNOWN = 0x00000400, // dont use the "Unknown" progid, instead fail
}; };
typedef DWORD ASSOCF; typedef DWORD ASSOCF;
typedef enum { typedef enum
{
ASSOCSTR_COMMAND = 1, // shell\verb\command string ASSOCSTR_COMMAND = 1, // shell\verb\command string
ASSOCSTR_EXECUTABLE, // the executable part of command string ASSOCSTR_EXECUTABLE, // the executable part of command string
ASSOCSTR_FRIENDLYDOCNAME, // friendly name of the document type ASSOCSTR_FRIENDLYDOCNAME, // friendly name of the document type
ASSOCSTR_FRIENDLYAPPNAME, // friendly name of executable ASSOCSTR_FRIENDLYAPPNAME, // friendly name of executable
ASSOCSTR_NOOPEN, // noopen value ASSOCSTR_NOOPEN, // noopen value
ASSOCSTR_SHELLNEWVALUE, // query values under the shellnew key ASSOCSTR_SHELLNEWVALUE, // query values under the shellnew key
ASSOCSTR_DDECOMMAND, // template for DDE commands ASSOCSTR_DDECOMMAND, // template for DDE commands
ASSOCSTR_DDEIFEXEC, // DDECOMMAND to use if just create a process ASSOCSTR_DDEIFEXEC, // DDECOMMAND to use if just create a process
ASSOCSTR_DDEAPPLICATION, // Application name in DDE broadcast ASSOCSTR_DDEAPPLICATION, // Application name in DDE broadcast
ASSOCSTR_DDETOPIC, // Topic Name in DDE broadcast ASSOCSTR_DDETOPIC, // Topic Name in DDE broadcast
ASSOCSTR_INFOTIP, // info tip for an item, or list of properties to create info tip from ASSOCSTR_INFOTIP, // info tip for an item, or list of properties to create info tip from
#if (_WIN32_IE >= _WIN32_IE_IE60) #if (_WIN32_IE >= _WIN32_IE_IE60)
ASSOCSTR_QUICKTIP, // same as ASSOCSTR_INFOTIP, except, this list contains only quickly retrievable properties ASSOCSTR_QUICKTIP, // same as ASSOCSTR_INFOTIP, except, this list contains only quickly retrievable properties
ASSOCSTR_TILEINFO, // similar to ASSOCSTR_INFOTIP - lists importan t properties for tileview ASSOCSTR_TILEINFO, // similar to ASSOCSTR_INFOTIP - lists importan t properties for tileview
ASSOCSTR_CONTENTTYPE, // MIME Content type ASSOCSTR_CONTENTTYPE, // MIME Content type
ASSOCSTR_DEFAULTICON, // Default icon source ASSOCSTR_DEFAULTICON, // Default icon source
ASSOCSTR_SHELLEXTENSION, // Guid string pointing to the Shellex\Shellext ensionhandler value. ASSOCSTR_SHELLEXTENSION, // Guid string pointing to the Shellex\Shellext ensionhandler value.
#endif // _WIN32_IE_IE60 #endif // _WIN32_IE_IE60
#if (_WIN32_IE >= _WIN32_IE_IE80)
ASSOCSTR_DROPTARGET, // The CLSID of DropTarget
ASSOCSTR_DELEGATEEXECUTE, // The CLSID of DelegateExecute
#endif // _WIN32_IE_IE80
ASSOCSTR_MAX // last item in enum... ASSOCSTR_MAX // last item in enum...
} ASSOCSTR; } ASSOCSTR;
typedef enum { typedef enum
{
ASSOCKEY_SHELLEXECCLASS = 1, // the key that should be passed to ShellExec (hkeyClass) ASSOCKEY_SHELLEXECCLASS = 1, // the key that should be passed to ShellExec (hkeyClass)
ASSOCKEY_APP, // the "Application" key for the association ASSOCKEY_APP, // the "Application" key for the association
ASSOCKEY_CLASS, // the progid or class key ASSOCKEY_CLASS, // the progid or class key
ASSOCKEY_BASECLASS, // the BaseClass key ASSOCKEY_BASECLASS, // the BaseClass key
ASSOCKEY_MAX // last item in enum... ASSOCKEY_MAX // last item in enum...
} ASSOCKEY; } ASSOCKEY;
typedef enum { typedef enum
{
ASSOCDATA_MSIDESCRIPTOR = 1, // Component Descriptor to pass to MSI APIs ASSOCDATA_MSIDESCRIPTOR = 1, // Component Descriptor to pass to MSI APIs
ASSOCDATA_NOACTIVATEHANDLER, // restrict attempts to activate window ASSOCDATA_NOACTIVATEHANDLER, // restrict attempts to activate window
ASSOCDATA_QUERYCLASSSTORE, // should check with the NT Class Store ASSOCDATA_QUERYCLASSSTORE, // should check with the NT Class Store
ASSOCDATA_HASPERUSERASSOC, // defaults to user specified association ASSOCDATA_HASPERUSERASSOC, // defaults to user specified association
#if (_WIN32_IE >= _WIN32_IE_IE60) #if (_WIN32_IE >= _WIN32_IE_IE60)
ASSOCDATA_EDITFLAGS, // Edit flags. ASSOCDATA_EDITFLAGS, // Edit flags.
ASSOCDATA_VALUE, // use pszExtra as the Value name ASSOCDATA_VALUE, // use pszExtra as the Value name
#endif // _WIN32_IE_IE60 #endif // _WIN32_IE_IE60
ASSOCDATA_MAX ASSOCDATA_MAX
} ASSOCDATA; } ASSOCDATA;
typedef enum { typedef enum
{
ASSOCENUM_NONE ASSOCENUM_NONE
} ASSOCENUM; } ASSOCENUM;
#undef INTERFACE #undef INTERFACE
#define INTERFACE IQueryAssociations #define INTERFACE IQueryAssociations
DECLARE_INTERFACE_IID_( IQueryAssociations, IUnknown, "c46ca590-3c3f-11d2-bee6-0 000f805ca57" ) DECLARE_INTERFACE_IID_( IQueryAssociations, IUnknown, "c46ca590-3c3f-11d2-bee6-0 000f805ca57" )
{ {
// IUnknown methods // IUnknown methods
STDMETHOD (QueryInterface)(THIS_ REFIID riid, void **ppv) PURE; STDMETHOD (QueryInterface)(THIS_ __in REFIID riid, __deref_out void **ppv) P URE;
STDMETHOD_(ULONG, AddRef) ( THIS ) PURE; STDMETHOD_(ULONG, AddRef) ( THIS ) PURE;
STDMETHOD_(ULONG, Release) ( THIS ) PURE; STDMETHOD_(ULONG, Release) ( THIS ) PURE;
// IQueryAssociations methods // IQueryAssociations methods
STDMETHOD (Init)(THIS_ ASSOCF flags, LPCWSTR pszAssoc, HKEY hkProgid, HWND h STDMETHOD (Init)(THIS_ __in ASSOCF flags, __in_opt LPCWSTR pszAssoc, __in_op
wnd) PURE; t HKEY hkProgid, __in_opt HWND hwnd) PURE;
STDMETHOD (GetString)(THIS_ ASSOCF flags, ASSOCSTR str, LPCWSTR pszExtra, __ STDMETHOD (GetString)(THIS_ __in ASSOCF flags, __in ASSOCSTR str, __in_opt L
out_ecount_opt(*pcchOut) LPWSTR pszOut, __inout DWORD *pcchOut) PURE; PCWSTR pszExtra, __out_ecount_opt(*pcchOut) LPWSTR pszOut, __inout DWORD *pcchOu
STDMETHOD (GetKey)(THIS_ ASSOCF flags, ASSOCKEY key, LPCWSTR pszExtra, __out t) PURE;
HKEY *phkeyOut) PURE; STDMETHOD (GetKey)(THIS_ __in ASSOCF flags, __in ASSOCKEY key, __in_opt LPCW
STDMETHOD (GetData)(THIS_ ASSOCF flags, ASSOCDATA data, LPCWSTR pszExtra, __ STR pszExtra, __out HKEY *phkeyOut) PURE;
out_bcount_opt(*pcbOut) void * pvOut, __inout_opt DWORD *pcbOut) PURE; STDMETHOD (GetData)(THIS_ __in ASSOCF flags, __in ASSOCDATA data, __in_opt L
STDMETHOD (GetEnum)(THIS_ ASSOCF flags, ASSOCENUM assocenum, LPCWSTR pszExtr PCWSTR pszExtra, __out_bcount_opt(*pcbOut) void * pvOut, __inout_opt DWORD *pcbO
a, REFIID riid, __out void **ppvOut) PURE; ut) PURE;
STDMETHOD (GetEnum)(THIS_ __in ASSOCF flags, __in ASSOCENUM assocenum, __in_
opt LPCWSTR pszExtra, __in REFIID riid, __deref_out void **ppvOut) PURE;
}; };
// use CLSID_QueryAssociations for clsid, object implements IQueryAssociations // use CLSID_QueryAssociations for clsid, object implements IQueryAssociations
// AssocCreateForClasses() is the more functional version of this API // AssocCreateForClasses() is the more functional version of this API
LWSTDAPI AssocCreate(__in CLSID clsid, __in REFIID riid, __out void **ppv); LWSTDAPI AssocCreate(__in CLSID clsid, __in REFIID riid, __deref_out void **ppv) ;
// wrappers for the interface // wrappers for the interface
LWSTDAPI AssocQueryStringA(__in ASSOCF flags, __in ASSOCSTR str, __in LPCSTR psz Assoc, __in_opt LPCSTR pszExtra, __out_ecount(*pcchOut) LPSTR pszOut, __inout DW ORD *pcchOut); LWSTDAPI AssocQueryStringA(__in ASSOCF flags, __in ASSOCSTR str, __in LPCSTR psz Assoc, __in_opt LPCSTR pszExtra, __out_ecount_opt(*pcchOut) LPSTR pszOut, __inou t DWORD *pcchOut);
// wrappers for the interface // wrappers for the interface
LWSTDAPI AssocQueryStringW(__in ASSOCF flags, __in ASSOCSTR str, __in LPCWSTR ps zAssoc, __in_opt LPCWSTR pszExtra, __out_ecount(*pcchOut) LPWSTR pszOut, __inout DWORD *pcchOut); LWSTDAPI AssocQueryStringW(__in ASSOCF flags, __in ASSOCSTR str, __in LPCWSTR ps zAssoc, __in_opt LPCWSTR pszExtra, __out_ecount_opt(*pcchOut) LPWSTR pszOut, __i nout DWORD *pcchOut);
#ifdef UNICODE #ifdef UNICODE
#define AssocQueryString AssocQueryStringW #define AssocQueryString AssocQueryStringW
#else #else
#define AssocQueryString AssocQueryStringA #define AssocQueryString AssocQueryStringA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI AssocQueryStringByKeyA(__in ASSOCF flags, __in ASSOCSTR str, __in HKEY LWSTDAPI AssocQueryStringByKeyA(__in ASSOCF flags, __in ASSOCSTR str, __in HKEY
hkAssoc, __in_opt LPCSTR pszExtra, __out_ecount(*pcchOut) LPSTR pszOut, __inout hkAssoc, __in_opt LPCSTR pszExtra, __out_ecount_opt(*pcchOut) LPSTR pszOut, __in
DWORD *pcchOut); out DWORD *pcchOut);
LWSTDAPI AssocQueryStringByKeyW(__in ASSOCF flags, __in ASSOCSTR str, __in HKEY LWSTDAPI AssocQueryStringByKeyW(__in ASSOCF flags, __in ASSOCSTR str, __in HKEY
hkAssoc, __in_opt LPCWSTR pszExtra, __out_ecount(*pcchOut) LPWSTR pszOut, __inou hkAssoc, __in_opt LPCWSTR pszExtra, __out_ecount_opt(*pcchOut) LPWSTR pszOut, __
t DWORD *pcchOut); inout DWORD *pcchOut);
#ifdef UNICODE #ifdef UNICODE
#define AssocQueryStringByKey AssocQueryStringByKeyW #define AssocQueryStringByKey AssocQueryStringByKeyW
#else #else
#define AssocQueryStringByKey AssocQueryStringByKeyA #define AssocQueryStringByKey AssocQueryStringByKeyA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI AssocQueryKeyA(__in ASSOCF flags, __in ASSOCKEY key, __in LPCSTR pszAss oc, __in_opt LPCSTR pszExtra, __out HKEY *phkeyOut); LWSTDAPI AssocQueryKeyA(__in ASSOCF flags, __in ASSOCKEY key, __in LPCSTR pszAss oc, __in_opt LPCSTR pszExtra, __out HKEY *phkeyOut);
LWSTDAPI AssocQueryKeyW(__in ASSOCF flags, __in ASSOCKEY key, __in LPCWSTR pszAs soc, __in_opt LPCWSTR pszExtra, __out HKEY *phkeyOut); LWSTDAPI AssocQueryKeyW(__in ASSOCF flags, __in ASSOCKEY key, __in LPCWSTR pszAs soc, __in_opt LPCWSTR pszExtra, __out HKEY *phkeyOut);
#ifdef UNICODE #ifdef UNICODE
#define AssocQueryKey AssocQueryKeyW #define AssocQueryKey AssocQueryKeyW
#else #else
skipping to change at line 1667 skipping to change at line 1711
LWSTDAPI AssocGetPerceivedType(__in LPCWSTR pszExt, __out PERCEIVED *ptype, __ou t PERCEIVEDFLAG *pflag, __out_opt LPWSTR *ppszType); LWSTDAPI AssocGetPerceivedType(__in LPCWSTR pszExt, __out PERCEIVED *ptype, __ou t PERCEIVEDFLAG *pflag, __out_opt LPWSTR *ppszType);
#endif #endif
#endif // NO_SHLWAPI_REG #endif // NO_SHLWAPI_REG
#ifndef NO_SHLWAPI_STREAM #ifndef NO_SHLWAPI_STREAM
// //
//=============== Stream Routines =================================== //=============== Stream Routines ===================================
// //
LWSTDAPI_(struct IStream *) SHOpenRegStreamA(__in HKEY hkey, LPCSTR pszSubkey, L // objidl.h
PCSTR pszValue, DWORD grfMode); #ifndef __IStream_FWD_DEFINED__
LWSTDAPI_(struct IStream *) SHOpenRegStreamW(__in HKEY hkey, LPCWSTR pszSubkey, #define __IStream_FWD_DEFINED__
LPCWSTR pszValue, DWORD grfMode); typedef interface IStream IStream;
#endif /* __IStream_FWD_DEFINED__ */
LWSTDAPI_(IStream *) SHOpenRegStreamA(__in HKEY hkey, __in_opt LPCSTR pszSubkey,
__in_opt LPCSTR pszValue, __in DWORD grfMode);
LWSTDAPI_(IStream *) SHOpenRegStreamW(__in HKEY hkey, __in_opt LPCWSTR pszSubkey
, __in_opt LPCWSTR pszValue, __in DWORD grfMode);
#ifdef UNICODE #ifdef UNICODE
#define SHOpenRegStream SHOpenRegStreamW #define SHOpenRegStream SHOpenRegStreamW
#else #else
#define SHOpenRegStream SHOpenRegStreamA #define SHOpenRegStream SHOpenRegStreamA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(struct IStream *) SHOpenRegStream2A(__in HKEY hkey, LPCSTR pszSubkey, LWSTDAPI_(IStream *) SHOpenRegStream2A(__in HKEY hkey, __in_opt LPCSTR pszSubkey
LPCSTR pszValue, DWORD grfMode); , __in_opt LPCSTR pszValue, __in DWORD grfMode);
LWSTDAPI_(struct IStream *) SHOpenRegStream2W(__in HKEY hkey, LPCWSTR pszSubkey, LWSTDAPI_(IStream *) SHOpenRegStream2W(__in HKEY hkey, __in_opt LPCWSTR pszSubke
LPCWSTR pszValue, DWORD grfMode); y, __in_opt LPCWSTR pszValue, __in DWORD grfMode);
#ifdef UNICODE #ifdef UNICODE
#define SHOpenRegStream2 SHOpenRegStream2W #define SHOpenRegStream2 SHOpenRegStream2W
#else #else
#define SHOpenRegStream2 SHOpenRegStream2A #define SHOpenRegStream2 SHOpenRegStream2A
#endif // !UNICODE #endif // !UNICODE
// New code always wants new implementation... // New code always wants new implementation...
#undef SHOpenRegStream #undef SHOpenRegStream
#define SHOpenRegStream SHOpenRegStream2 #define SHOpenRegStream SHOpenRegStream2
LWSTDAPI SHCreateStreamOnFileA(LPCSTR pszFile, DWORD grfMode, __out struct IStre LWSTDAPI SHCreateStreamOnFileA(__in LPCSTR pszFile, __in DWORD grfMode, __deref_
am **ppstm); out IStream **ppstm);
LWSTDAPI SHCreateStreamOnFileW(LPCWSTR pszFile, DWORD grfMode, __out struct IStr LWSTDAPI SHCreateStreamOnFileW(__in LPCWSTR pszFile, __in DWORD grfMode, __deref
eam **ppstm); _out IStream **ppstm);
#ifdef UNICODE #ifdef UNICODE
#define SHCreateStreamOnFile SHCreateStreamOnFileW #define SHCreateStreamOnFile SHCreateStreamOnFileW
#else #else
#define SHCreateStreamOnFile SHCreateStreamOnFileA #define SHCreateStreamOnFile SHCreateStreamOnFileA
#endif // !UNICODE #endif // !UNICODE
#if (_WIN32_IE >= 0x0600) #if (_WIN32_IE >= 0x0600)
LWSTDAPI SHCreateStreamOnFileEx(LPCWSTR pszFile, DWORD grfMode, DWORD dwAttribut es, BOOL fCreate, __in_opt struct IStream * pstmTemplate, __out struct IStream * *ppstm); LWSTDAPI SHCreateStreamOnFileEx(__in LPCWSTR pszFile, __in DWORD grfMode, __in D WORD dwAttributes, __in BOOL fCreate, __in_opt IStream *pstmTemplate, __deref_ou t IStream **ppstm);
#endif // (_WIN32_IE >= 0x0600) #endif // (_WIN32_IE >= 0x0600)
#if (_WIN32_IE >= _WIN32_IE_IE501) #if (_WIN32_IE >= _WIN32_IE_IE501)
LWSTDAPI_(struct IStream *) SHCreateMemStream(__in_bcount_opt(cbInit) const BYTE *pInit, UINT cbInit); LWSTDAPI_(IStream *) SHCreateMemStream(__in_bcount_opt(cbInit) const BYTE *pInit , __in UINT cbInit);
#endif // (_WIN32_IE >= _WIN32_IE_IE501) #endif // (_WIN32_IE >= _WIN32_IE_IE501)
#endif // NO_SHLWAPI_STREAM #endif // NO_SHLWAPI_STREAM
#ifndef NO_SHLWAPI_MLUI
//
//=============== Multi Language UI Routines ===================================
//
#if (_WIN32_IE >= _WIN32_IE_IE501)
LWSTDAPI_(HINSTANCE) MLLoadLibraryA(LPCSTR lpLibFileName, __in HMODULE hModule,
DWORD dwCrossCodePage);
LWSTDAPI_(HINSTANCE) MLLoadLibraryW(LPCWSTR lpLibFileName, __in HMODULE hModule,
DWORD dwCrossCodePage);
#ifdef UNICODE
#define MLLoadLibrary MLLoadLibraryW
#else
#define MLLoadLibrary MLLoadLibraryA
#endif // !UNICODE
LWSTDAPI_(BOOL) MLFreeLibrary(__in HMODULE hModule);
#define ML_NO_CROSSCODEPAGE 0
#define ML_CROSSCODEPAGE_NT 1
#define ML_CROSSCODEPAGE 2
#define ML_SHELL_LANGUAGE 4
#define ML_CROSSCODEPAGE_MASK 7
#endif // (_WIN32_IE >= _WIN32_IE_IE501)
#endif // NO_SHLWAPI_MLUI
#ifndef NO_SHLWAPI_HTTP #ifndef NO_SHLWAPI_HTTP
// //
//=============== HTTP helper Routines =================================== //=============== HTTP helper Routines ===================================
// //
#if (_WIN32_IE >= 0x0603) #if (_WIN32_IE >= 0x0603)
LWSTDAPI GetAcceptLanguagesA(__out_ecount(*pcch) LPSTR psz, LPDWORD pcch); LWSTDAPI GetAcceptLanguagesA(__out_ecount_part(*pcch, *pcch) LPSTR psz, __inout
LWSTDAPI GetAcceptLanguagesW(__out_ecount(*pcch) LPWSTR psz, LPDWORD pcch); DWORD *pcch);
LWSTDAPI GetAcceptLanguagesW(__out_ecount_part(*pcch, *pcch) LPWSTR psz, __inout
DWORD *pcch);
#ifdef UNICODE #ifdef UNICODE
#define GetAcceptLanguages GetAcceptLanguagesW #define GetAcceptLanguages GetAcceptLanguagesW
#else #else
#define GetAcceptLanguages GetAcceptLanguagesA #define GetAcceptLanguages GetAcceptLanguagesA
#endif // !UNICODE #endif // !UNICODE
#endif // (_WIN32_IE >= 0x0603) #endif // (_WIN32_IE >= 0x0603)
#endif // NO_SHLWAPI_HTTP #endif // NO_SHLWAPI_HTTP
#if (_WIN32_IE < _WIN32_IE_IE70) && !defined(NO_SHLWAPI_STOPWATCH) #if (_WIN32_IE < _WIN32_IE_IE70) && !defined(NO_SHLWAPI_STOPWATCH)
skipping to change at line 1776 skipping to change at line 1800
#define SPMODE_MULTISTOP 0x00004000 #define SPMODE_MULTISTOP 0x00004000
#ifndef NO_ETW_TRACING #ifndef NO_ETW_TRACING
#define SPMODE_EVENTTRACE 0x00008000 // Event Tracing for Windows Enabled #define SPMODE_EVENTTRACE 0x00008000 // Event Tracing for Windows Enabled
#endif #endif
DWORD WINAPI StopWatchMode(void); DWORD WINAPI StopWatchMode(void);
DWORD WINAPI StopWatchFlush(void); DWORD WINAPI StopWatchFlush(void);
#endif // (_WIN32_IE < _WIN32_IE_IE70) && !defined(NO_SHLWAPI_STOPWATCH) #endif // (_WIN32_IE < _WIN32_IE_IE70) && !defined(NO_SHLWAPI_STOPWATCH)
#ifndef __IConnectionPoint_FWD_DEFINED__
#define __IConnectionPoint_FWD_DEFINED__
typedef struct IConnectionPoint IConnectionPoint;
#endif /* __IConnectionPoint_FWD_DEFINED__ */
#if (_WIN32_IE >= _WIN32_IE_IE501) #if (_WIN32_IE >= _WIN32_IE_IE501)
LWSTDAPI_(void) IUnknown_Set(__deref_inout IUnknown ** ppunk, __in_opt IUnkn own * punk); LWSTDAPI_(void) IUnknown_Set(__deref_inout IUnknown ** ppunk, __in_opt IUnkn own * punk);
LWSTDAPI_(void) IUnknown_AtomicRelease(__inout_opt void ** ppunk); LWSTDAPI_(void) IUnknown_AtomicRelease(__deref_opt_inout void ** ppunk);
LWSTDAPI IUnknown_GetWindow(__in IUnknown* punk, __out HWND* phwnd); LWSTDAPI IUnknown_GetWindow(__in_opt IUnknown* punk, __out HWND* phwnd);
LWSTDAPI IUnknown_SetSite(__in IUnknown *punk, __in_opt IUnknown *punkSite); LWSTDAPI IUnknown_SetSite(__in IUnknown *punk, __in_opt IUnknown *punkSite);
LWSTDAPI IUnknown_GetSite(__in IUnknown *punk, __in REFIID riid, __deref_out void **ppv); LWSTDAPI IUnknown_GetSite(__in IUnknown *punk, __in REFIID riid, __deref_out void **ppv);
LWSTDAPI IUnknown_QueryService(__in_opt IUnknown* punk, __in REFGUID guidSer vice, __in REFIID riid, __deref_out void ** ppvOut); LWSTDAPI IUnknown_QueryService(__in IUnknown* punk, __in REFGUID guidService , __in REFIID riid, __deref_out void ** ppvOut);
#endif // (_WIN32_IE >= _WIN32_IE_IE501) #endif // (_WIN32_IE >= _WIN32_IE_IE501)
#if (_WIN32_IE >= _WIN32_IE_IE501) #if (_WIN32_IE >= _WIN32_IE_IE501)
#if !defined(__cplusplus) && defined(COBJMACROS) #if !defined(__cplusplus) && defined(COBJMACROS)
#undef IStream_Read #undef IStream_Read
#undef IStream_Write #undef IStream_Write
#endif #endif
LWSTDAPI IStream_Read(__in IStream *pstm, __out_bcount_full(cb) void *pv, __in U LONG cb); LWSTDAPI IStream_Read(__in IStream *pstm, __out_bcount_full(cb) void *pv, __in U LONG cb);
LWSTDAPI IStream_Write(__in IStream *pstm, __in_bcount(cb) const void *pv, __in ULONG cb); LWSTDAPI IStream_Write(__in IStream *pstm, __in_bcount(cb) const void *pv, __in ULONG cb);
LWSTDAPI IStream_Reset(__in IStream *pstm); LWSTDAPI IStream_Reset(__in IStream *pstm);
LWSTDAPI IStream_Size(__in IStream *pstm, __out ULARGE_INTEGER *pui); LWSTDAPI IStream_Size(__in IStream *pstm, __out ULARGE_INTEGER *pui);
LWSTDAPI ConnectToConnectionPoint(__in_opt IUnknown* punk, __in REFIID riidEvent // ocidl.h
, __in BOOL fConnect, __in IUnknown* punkTarget, __out DWORD* pdwCookie, __deref #ifndef __IConnectionPoint_FWD_DEFINED__
_out_opt IConnectionPoint** ppcpOut); #define __IConnectionPoint_FWD_DEFINED__
typedef interface IConnectionPoint IConnectionPoint;
#endif /* __IConnectionPoint_FWD_DEFINED__ */
LWSTDAPI ConnectToConnectionPoint(__in_opt IUnknown* punk, __in REFIID riidEvent
, __in BOOL fConnect, __in IUnknown* punkTarget, __out DWORD* pdwCookie, __deref
_opt_out IConnectionPoint** ppcpOut);
#endif // (_WIN32_IE >= _WIN32_IE_IE501) #endif // (_WIN32_IE >= _WIN32_IE_IE501)
#if (_WIN32_IE >= _WIN32_IE_IE60) #if (_WIN32_IE >= _WIN32_IE_IE60)
LWSTDAPI IStream_ReadPidl(__in IStream *pstm, __deref_out PIDLIST_RELATIVE *ppid lOut); LWSTDAPI IStream_ReadPidl(__in IStream *pstm, __deref_out PIDLIST_RELATIVE *ppid lOut);
LWSTDAPI IStream_WritePidl(__in IStream *pstm, __in PCUIDLIST_RELATIVE pidlWrite ); LWSTDAPI IStream_WritePidl(__in IStream *pstm, __in PCUIDLIST_RELATIVE pidlWrite );
#endif // (_WIN32_IE >= _WIN32_IE_IE60) #endif // (_WIN32_IE >= _WIN32_IE_IE60)
skipping to change at line 1836 skipping to change at line 1861
#define SHGVSPB_ALLUSERS 0x00000002 #define SHGVSPB_ALLUSERS 0x00000002
#define SHGVSPB_PERFOLDER 0x00000004 // must have one of PERFOLDER ALL FOLDERS or INHERIT #define SHGVSPB_PERFOLDER 0x00000004 // must have one of PERFOLDER ALL FOLDERS or INHERIT
#define SHGVSPB_ALLFOLDERS 0x00000008 #define SHGVSPB_ALLFOLDERS 0x00000008
#define SHGVSPB_INHERIT 0x00000010 #define SHGVSPB_INHERIT 0x00000010
#define SHGVSPB_ROAM 0x00000020 // modifies the above #define SHGVSPB_ROAM 0x00000020 // modifies the above
#define SHGVSPB_NOAUTODEFAULTS 0x80000000 // turns off read delegation to m ore general property bags #define SHGVSPB_NOAUTODEFAULTS 0x80000000 // turns off read delegation to m ore general property bags
#define SHGVSPB_FOLDER (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER) #define SHGVSPB_FOLDER (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER)
#define SHGVSPB_FOLDERNODEFAULTS (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER | SHGVS PB_NOAUTODEFAULTS) #define SHGVSPB_FOLDERNODEFAULTS (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER | SHGVS PB_NOAUTODEFAULTS)
#define SHGVSPB_USERDEFAULTS (SHGVSPB_PERUSER | SHGVSPB_ALLFOLDERS) #define SHGVSPB_USERDEFAULTS (SHGVSPB_PERUSER | SHGVSPB_ALLFOLDERS)
#define SHGVSPB_GLOBALDEAFAULTS (SHGVSPB_ALLUSERS | SHGVSPB_ALLFOLDERS) #define SHGVSPB_GLOBALDEFAULTS (SHGVSPB_ALLUSERS | SHGVSPB_ALLFOLDERS)
LWSTDAPI SHGetViewStatePropertyBag(__in_opt PCIDLIST_ABSOLUTE pidl, __in_opt LPC WSTR pszBagName, __in DWORD dwFlags, __in REFIID riid, __deref_out void** ppv); LWSTDAPI SHGetViewStatePropertyBag(__in_opt PCIDLIST_ABSOLUTE pidl, __in_opt LPC WSTR pszBagName, __in DWORD dwFlags, __in REFIID riid, __deref_out void** ppv);
#endif // (_WIN32_IE >= 0x0600) #endif // (_WIN32_IE >= 0x0600)
// SHFormatDateTime flags // SHFormatDateTime flags
// (FDTF_SHORTDATE and FDTF_LONGDATE are mutually exclusive, as is // (FDTF_SHORTDATE and FDTF_LONGDATE are mutually exclusive, as is
// FDTF_SHORTIME and FDTF_LONGTIME.) // FDTF_SHORTIME and FDTF_LONGTIME.)
// //
#define FDTF_SHORTTIME 0x00000001 // eg, "7:48 PM" #define FDTF_SHORTTIME 0x00000001 // eg, "7:48 PM"
#define FDTF_SHORTDATE 0x00000002 // eg, "3/29/98" #define FDTF_SHORTDATE 0x00000002 // eg, "3/29/98"
skipping to change at line 1865 skipping to change at line 1890
LWSTDAPI_(int) SHFormatDateTimeA(const FILETIME UNALIGNED * pft, __inout_opt DW ORD * pdwFlags, __out_ecount(cchBuf) LPSTR pszBuf, UINT cchBuf); LWSTDAPI_(int) SHFormatDateTimeA(const FILETIME UNALIGNED * pft, __inout_opt DW ORD * pdwFlags, __out_ecount(cchBuf) LPSTR pszBuf, UINT cchBuf);
LWSTDAPI_(int) SHFormatDateTimeW(const FILETIME UNALIGNED * pft, __inout_opt DW ORD * pdwFlags, __out_ecount(cchBuf) LPWSTR pszBuf, UINT cchBuf); LWSTDAPI_(int) SHFormatDateTimeW(const FILETIME UNALIGNED * pft, __inout_opt DW ORD * pdwFlags, __out_ecount(cchBuf) LPWSTR pszBuf, UINT cchBuf);
#ifdef UNICODE #ifdef UNICODE
#define SHFormatDateTime SHFormatDateTimeW #define SHFormatDateTime SHFormatDateTimeW
#else #else
#define SHFormatDateTime SHFormatDateTimeA #define SHFormatDateTime SHFormatDateTimeA
#endif // !UNICODE #endif // !UNICODE
#if (_WIN32_IE >= _WIN32_IE_IE501) #if (_WIN32_IE >= _WIN32_IE_IE501)
__success(return > 0)
LWSTDAPI_(int) SHAnsiToUnicode(LPCSTR pszSrc, __out_ecount(cwchBuf) LPWSTR pwsz Dst, int cwchBuf); LWSTDAPI_(int) SHAnsiToUnicode(LPCSTR pszSrc, __out_ecount(cwchBuf) LPWSTR pwsz Dst, int cwchBuf);
__success(return > 0)
LWSTDAPI_(int) SHAnsiToAnsi(LPCSTR pszSrc, __out_ecount(cchBuf) LPSTR pszDst, i nt cchBuf); LWSTDAPI_(int) SHAnsiToAnsi(LPCSTR pszSrc, __out_ecount(cchBuf) LPSTR pszDst, i nt cchBuf);
__success(return > 0)
LWSTDAPI_(int) SHUnicodeToAnsi(LPCWSTR pwszSrc, __out_ecount(cchBuf) LPSTR pszD st, int cchBuf); LWSTDAPI_(int) SHUnicodeToAnsi(LPCWSTR pwszSrc, __out_ecount(cchBuf) LPSTR pszD st, int cchBuf);
__success(return > 0)
LWSTDAPI_(int) SHUnicodeToUnicode(LPCWSTR pwzSrc, __out_ecount(cwchBuf) LPWSTR pwzDst, int cwchBuf); LWSTDAPI_(int) SHUnicodeToUnicode(LPCWSTR pwzSrc, __out_ecount(cwchBuf) LPWSTR pwzDst, int cwchBuf);
// The return value from all SH<Type>To<Type> is the size of szDest including th e terminater. // The return value from all SH<Type>To<Type> is the size of szDest including th e terminater.
#ifdef UNICODE #ifdef UNICODE
#define SHTCharToUnicode(wzSrc, wzDest, cchSize) SHUnicodeToUnico de(wzSrc, wzDest, cchSize) #define SHTCharToUnicode(wzSrc, wzDest, cchSize) SHUnicodeToUnico de(wzSrc, wzDest, cchSize)
#define SHTCharToAnsi(wzSrc, szDest, cchSize) SHUnicodeToAnsi( wzSrc, szDest, cchSize) #define SHTCharToAnsi(wzSrc, szDest, cchSize) SHUnicodeToAnsi( wzSrc, szDest, cchSize)
#define SHUnicodeToTChar(wzSrc, wzDest, cchSize) SHUnicodeToUnico de(wzSrc, wzDest, cchSize) #define SHUnicodeToTChar(wzSrc, wzDest, cchSize) SHUnicodeToUnico de(wzSrc, wzDest, cchSize)
#define SHAnsiToTChar(szSrc, wzDest, cchSize) SHAnsiToUnicode( szSrc, wzDest, cchSize) #define SHAnsiToTChar(szSrc, wzDest, cchSize) SHAnsiToUnicode( szSrc, wzDest, cchSize)
#else // UNICODE #else // UNICODE
#define SHTCharToUnicode(szSrc, wzDest, cchSize) SHAnsiToUnicode( szSrc, wzDest, cchSize) #define SHTCharToUnicode(szSrc, wzDest, cchSize) SHAnsiToUnicode( szSrc, wzDest, cchSize)
skipping to change at line 1900 skipping to change at line 1929
#define SHMessageBoxCheck SHMessageBoxCheckW #define SHMessageBoxCheck SHMessageBoxCheckW
#else #else
#define SHMessageBoxCheck SHMessageBoxCheckA #define SHMessageBoxCheck SHMessageBoxCheckA
#endif // !UNICODE #endif // !UNICODE
#endif // (_WIN32_IE >= _WIN32_IE_IE501) #endif // (_WIN32_IE >= _WIN32_IE_IE501)
#if (_WIN32_IE >= _WIN32_IE_IE501) #if (_WIN32_IE >= _WIN32_IE_IE501)
// Prevents hang do to hung window on broadcast // Prevents hang do to hung window on broadcast
LWSTDAPI_(LRESULT) SHSendMessageBroadcastA(UINT uMsg, __in WPARAM wParam, __in L PARAM lParam); LWSTDAPI_(LRESULT) SHSendMessageBroadcastA(__in UINT uMsg, __in WPARAM wParam, _ _in LPARAM lParam);
// Prevents hang do to hung window on broadcast // Prevents hang do to hung window on broadcast
LWSTDAPI_(LRESULT) SHSendMessageBroadcastW(UINT uMsg, __in WPARAM wParam, __in L PARAM lParam); LWSTDAPI_(LRESULT) SHSendMessageBroadcastW(__in UINT uMsg, __in WPARAM wParam, _ _in LPARAM lParam);
#ifdef UNICODE #ifdef UNICODE
#define SHSendMessageBroadcast SHSendMessageBroadcastW #define SHSendMessageBroadcast SHSendMessageBroadcastW
#else #else
#define SHSendMessageBroadcast SHSendMessageBroadcastA #define SHSendMessageBroadcast SHSendMessageBroadcastA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(CHAR) SHStripMneumonicA(__inout LPSTR pszMenu); LWSTDAPI_(CHAR) SHStripMneumonicA(__inout LPSTR pszMenu);
LWSTDAPI_(WCHAR) SHStripMneumonicW(__inout LPWSTR pszMenu); LWSTDAPI_(WCHAR) SHStripMneumonicW(__inout LPWSTR pszMenu);
#ifdef UNICODE #ifdef UNICODE
#define SHStripMneumonic SHStripMneumonicW #define SHStripMneumonic SHStripMneumonicW
#else #else
#define SHStripMneumonic SHStripMneumonicA #define SHStripMneumonic SHStripMneumonicA
#endif // !UNICODE #endif // !UNICODE
#ifndef NO_SHLWAPI_ISOS
// Returns TRUE/FALSE depending on question // Returns TRUE/FALSE depending on question
#define OS_WINDOWS 0 // Windows 9x vs. NT #define OS_WINDOWS 0 // Windows 9x vs. NT
#define OS_NT 1 // Windows 9x vs. NT #define OS_NT 1 // Windows 9x vs. NT
#define OS_WIN95ORGREATER 2 // Win95 or greater #define OS_WIN95ORGREATER 2 // Win95 or greater
#define OS_NT4ORGREATER 3 // NT4 or greater #define OS_NT4ORGREATER 3 // NT4 or greater
#define OS_WIN98ORGREATER 5 // Win98 or greater #define OS_WIN98ORGREATER 5 // Win98 or greater
#define OS_WIN98_GOLD 6 // Win98 Gold (Version 4.10 buil d 1998) #define OS_WIN98_GOLD 6 // Win98 Gold (Version 4.10 buil d 1998)
#define OS_WIN2000ORGREATER 7 // Some derivative of Win2000 #define OS_WIN2000ORGREATER 7 // Some derivative of Win2000
// NOTE: these flags check explicitly for (dwMajorVersion == 5) // NOTE: these flags check explicitly for (dwMajorVersion == 5)
skipping to change at line 1960 skipping to change at line 1991
#define OS_WOW6432 30 // Is this process a 32-bit proc ess running on an 64-bit platform? #define OS_WOW6432 30 // Is this process a 32-bit proc ess running on an 64-bit platform?
#define OS_WEBSERVER 31 // Web Edition Server #define OS_WEBSERVER 31 // Web Edition Server
#define OS_SMALLBUSINESSSERVER 32 // SBS Server #define OS_SMALLBUSINESSSERVER 32 // SBS Server
#define OS_TABLETPC 33 // Are we running on a TabletPC? #define OS_TABLETPC 33 // Are we running on a TabletPC?
#define OS_SERVERADMINUI 34 // Should defaults lean towards those preferred by server administrators? #define OS_SERVERADMINUI 34 // Should defaults lean towards those preferred by server administrators?
#define OS_MEDIACENTER 35 // eHome Freestyle Project #define OS_MEDIACENTER 35 // eHome Freestyle Project
#define OS_APPLIANCE 36 // Windows .NET Appliance Server #define OS_APPLIANCE 36 // Windows .NET Appliance Server
LWSTDAPI_(BOOL) IsOS(DWORD dwOS); LWSTDAPI_(BOOL) IsOS(DWORD dwOS);
#endif // NO_SHLWAPI_ISOS
#endif // (_WIN32_IE >= _WIN32_IE_IE501) #endif // (_WIN32_IE >= _WIN32_IE_IE501)
typedef enum
{
GLOBALCOUNTER_SEARCHMANAGER,
GLOBALCOUNTER_SEARCHOPTIONS,
GLOBALCOUNTER_FOLDERSETTINGSCHANGE,
GLOBALCOUNTER_RATINGS,
GLOBALCOUNTER_APPROVEDSITES,
GLOBALCOUNTER_RESTRICTIONS,
GLOBALCOUNTER_SHELLSETTINGSCHANGED,
GLOBALCOUNTER_SYSTEMPIDLCHANGE,
GLOBALCOUNTER_OVERLAYMANAGER,
GLOBALCOUNTER_QUERYASSOCIATIONS,
GLOBALCOUNTER_IESESSIONS,
GLOBALCOUNTER_IEONLY_SESSIONS,
GLOBALCOUNTER_APPLICATION_DESTINATIONS,
__UNUSED_RECYCLE_WAS_GLOBALCOUNTER_CSCSYNCINPROGRESS,
GLOBALCOUNTER_BITBUCKETNUMDELETERS,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_SHARES,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_A,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_B,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_C,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_D,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_E,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_F,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_G,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_H,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_I,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_J,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_K,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_L,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_M,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_N,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_O,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_P,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_Q,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_R,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_S,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_T,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_U,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_V,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_W,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_X,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_Y,
GLOBALCOUNTER_RECYCLEDIRTYCOUNT_DRIVE_Z,
__UNUSED_RECYCLE_WAS_GLOBALCOUNTER_RECYCLEDIRTYCOUNT_SERVERDRIVE,
__UNUSED_RECYCLE_WAS_GLOBALCOUNTER_RECYCLEGLOBALDIRTYCOUNT,
GLOBALCOUNTER_RECYCLEBINENUM,
GLOBALCOUNTER_RECYCLEBINCORRUPTED,
GLOBALCOUNTER_RATINGS_STATECOUNTER,
GLOBALCOUNTER_PRIVATE_PROFILE_CACHE,
GLOBALCOUNTER_INTERNETTOOLBAR_LAYOUT,
GLOBALCOUNTER_FOLDERDEFINITION_CACHE,
GLOBALCOUNTER_COMMONPLACES_LIST_CACHE,
GLOBALCOUNTER_PRIVATE_PROFILE_CACHE_MACHINEWIDE,
GLOBALCOUNTER_ASSOCCHANGED, // throttles reading of the registry value "Glo
balAssocChangedCounter" from HKLM\Software\Microsoft\Windows\CurrentVersion\Expl
orer
GLOBALCOUNTER_MAXIMUMVALUE // should always be last value
} SHGLOBALCOUNTER;
LWSTDAPI_(long) SHGlobalCounterGetValue(const SHGLOBALCOUNTER id);
LWSTDAPI_(long) SHGlobalCounterIncrement(const SHGLOBALCOUNTER id);
LWSTDAPI_(long) SHGlobalCounterDecrement(const SHGLOBALCOUNTER id);
// Shared memory apis // Shared memory apis
#if (_WIN32_IE >= 0x0603) #if (_WIN32_IE >= 0x0603)
LWSTDAPI_(HANDLE) SHAllocShared(__in_bcount(dwSize) const void *pvData, __in D WORD dwSize, __in DWORD dwProcessId); LWSTDAPI_(HANDLE) SHAllocShared(__in_bcount_opt(dwSize) const void *pvData, __ in DWORD dwSize, __in DWORD dwProcessId);
LWSTDAPI_(BOOL) SHFreeShared(__in HANDLE hData, __in DWORD dwProcessId); LWSTDAPI_(BOOL) SHFreeShared(__in HANDLE hData, __in DWORD dwProcessId);
LWSTDAPI_(void *) SHLockShared(__in HANDLE hData, __in DWORD dwProcessId); LWSTDAPI_(void *) SHLockShared(__in HANDLE hData, __in DWORD dwProcessId);
LWSTDAPI_(BOOL) SHUnlockShared(__in void *pvData); LWSTDAPI_(BOOL) SHUnlockShared(__in_xcount("header-preceded") void *pvData);
#endif // _WIN32_IE >= 0x0603 #endif // _WIN32_IE >= 0x0603
#if (_WIN32_IE >= _WIN32_IE_IE501) #if (_WIN32_IE >= _WIN32_IE_IE501)
LWSTDAPI_(UINT) WhichPlatform(void); LWSTDAPI_(UINT) WhichPlatform(void);
// Return values of WhichPlatform // Return values of WhichPlatform
#define PLATFORM_UNKNOWN 0 #define PLATFORM_UNKNOWN 0
#define PLATFORM_IE3 1 // obsolete: use PLATFORM_BROWSERONLY #define PLATFORM_IE3 1 // obsolete: use PLATFORM_BROWSERONLY
#define PLATFORM_BROWSERONLY 1 // browser-only (no new shell) #define PLATFORM_BROWSERONLY 1 // browser-only (no new shell)
skipping to change at line 2133 skipping to change at line 2228
#define SHACF_AUTOSUGGEST_FORCE_ON 0x10000000 // Ignore the registry defau lt and force the feature on. #define SHACF_AUTOSUGGEST_FORCE_ON 0x10000000 // Ignore the registry defau lt and force the feature on.
#define SHACF_AUTOSUGGEST_FORCE_OFF 0x20000000 // Ignore the registry defau lt and force the feature off. #define SHACF_AUTOSUGGEST_FORCE_OFF 0x20000000 // Ignore the registry defau lt and force the feature off.
#define SHACF_AUTOAPPEND_FORCE_ON 0x40000000 // Ignore the registry defau lt and force the feature on. (Also know as AutoComplete) #define SHACF_AUTOAPPEND_FORCE_ON 0x40000000 // Ignore the registry defau lt and force the feature on. (Also know as AutoComplete)
#define SHACF_AUTOAPPEND_FORCE_OFF 0x80000000 // Ignore the registry defau lt and force the feature off. (Also know as AutoComplete) #define SHACF_AUTOAPPEND_FORCE_OFF 0x80000000 // Ignore the registry defau lt and force the feature off. (Also know as AutoComplete)
LWSTDAPI SHAutoComplete(HWND hwndEdit, DWORD dwFlags); LWSTDAPI SHAutoComplete(HWND hwndEdit, DWORD dwFlags);
#if (_WIN32_IE >= _WIN32_IE_IE60SP2) #if (_WIN32_IE >= _WIN32_IE_IE60SP2)
LWSTDAPI SHCreateThreadRef(__inout LONG *pcRef, __deref_out IUnknown **ppunk); LWSTDAPI SHCreateThreadRef(__inout LONG *pcRef, __deref_out IUnknown **ppunk);
#endif // _WIN32_IE_IE60SP2 #endif // _WIN32_IE_IE60SP2
LWSTDAPI SHSetThreadRef(__in IUnknown *punk); LWSTDAPI SHSetThreadRef(__in_opt IUnknown *punk);
LWSTDAPI SHGetThreadRef(__deref_out IUnknown **ppunk); LWSTDAPI SHGetThreadRef(__deref_out IUnknown **ppunk);
LWSTDAPI_(BOOL) SHSkipJunction(__in_opt struct IBindCtx* pbc, const CLSID *pclsi d); LWSTDAPI_(BOOL) SHSkipJunction(__in_opt IBindCtx* pbc, __in const CLSID *pclsid) ;
#endif // (_WIN32_IE >= 0x0500) #endif // (_WIN32_IE >= 0x0500)
#define CTF_INSIST 0x00000001 // SHCreateThread() dwFl enum
ags - call pfnThreadProc synchronously if CreateThread() fails {
#define CTF_THREAD_REF 0x00000002 // hold a reference to t CTF_INSIST = 0x00000001, // call pfnThreadProc synchronously
he creating thread if CreateThread() fails
#define CTF_PROCESS_REF 0x00000004 // hold a reference to t CTF_THREAD_REF = 0x00000002, // hold a reference to the creating
he creating process thread
#define CTF_COINIT_STA 0x00000008 // init COM as STA for t CTF_PROCESS_REF = 0x00000004, // hold a reference to the creating
he created thread process
#define CTF_COINIT CTF_COINIT_STA // init COM as STA for t CTF_COINIT_STA = 0x00000008, // init COM as STA for the created t
he created thread hread
CTF_COINIT = 0x00000008, // init COM as STA for the created t
hread
#if (_WIN32_IE >= _WIN32_IE_IE60) #if (_WIN32_IE >= _WIN32_IE_IE60)
#define CTF_FREELIBANDEXIT 0x00000010 // hold a ref to the DLL CTF_FREELIBANDEXIT = 0x00000010, // hold a ref to the DLL and call Fr
and call FreeLibraryAndExitThread() when done eeLibraryAndExitThread() when done
#define CTF_REF_COUNTED 0x00000020 // thread supports ref c CTF_REF_COUNTED = 0x00000020, // thread supports ref counting via
ounting via SHGetThreadRef() or CTF_THREAD_REF so that child threads can keep th SHGetThreadRef() or CTF_THREAD_REF so that child threads can keep this thread al
is thread alive ive
#define CTF_WAIT_ALLOWCOM 0x00000040 // while waiting for pfn CTF_WAIT_ALLOWCOM = 0x00000040, // while waiting for pfnCallback, al
Callback, allow COM marshaling to the blocked calling thread low COM marshaling to the blocked calling thread
#endif // _WIN32_IE_IE60 #endif // _WIN32_IE_IE60
#if (_WIN32_IE >= _WIN32_IE_IE70) #if (_WIN32_IE >= _WIN32_IE_IE70)
#define CTF_UNUSED 0x00000080 CTF_UNUSED = 0x00000080,
#define CTF_INHERITWOW64 0x00000100 // new thread should inh CTF_INHERITWOW64 = 0x00000100, // new thread should inherit the wow
erit the wow64 disable state for the file system redirector 64 disable state for the file system redirector
#endif // _WIN32_IE_IE70 #endif // _WIN32_IE_IE70
#if (NTDDI_VERSION >= NTDDI_LONGHORN) #if (NTDDI_VERSION >= NTDDI_VISTA)
#define CTF_WAIT_NO_REENTRANCY 0x00000200 // don't allow re-entran CTF_WAIT_NO_REENTRANCY = 0x00000200, // don't allow re-entrancy when wait
cy when waiting for the sync proc, this won't work with marshalled objects or Se ing for the sync proc, this won't work with marshalled objects or SendMessages()
ndMessages() from the sync proc from the sync proc
#endif // (NTDDI_VERSION >= NTDDI_LONGHORN) #endif // (NTDDI_VERSION >= NTDDI_VISTA)
#if (NTDDI_VERSION >= NTDDI_WIN7)
CTF_KEYBOARD_LOCALE = 0x00000400, // carry the keyboard locale from cr
eating to created thread
CTF_OLEINITIALIZE = 0x00000800, // init OLE on the created thread (t
his will also init COM as STA)
CTF_COINIT_MTA = 0x00001000, // init COM as MTA for the created t
hread
CTF_NOADDREFLIB = 0x00002000, // this flag is the opposite of CTF_
FREELIBANDEXIT that is now implicit as of Vista
// this avoids the LoadLibrary/FreeL
ibraryAndExitThread calls that result in contention for the loader lock
// only use this when the thread bei
ng created has some other means to ensure that the code
// of the thread proc will remain lo
aded. This should not be used in the context of COM objects as those
// need to ensure that the DLL stays
loaded as COM will unload DLLs
//#define CTF_COINIT_MTA 0x00000800 // init COM as STA for the created #endif // (NTDDI_VERSION >= NTDDI_WIN7)
thread };
typedef DWORD SHCT_FLAGS; // SHCreateThread flags values
LWSTDAPI_(BOOL) SHCreateThread(__in LPTHREAD_START_ROUTINE pfnThreadProc, __in_o LWSTDAPI_(BOOL) SHCreateThread(__in LPTHREAD_START_ROUTINE pfnThreadProc, __in_o
pt void *pData, DWORD dwFlags, __in_opt LPTHREAD_START_ROUTINE pfnCallback); pt void *pData, SHCT_FLAGS flags, __in_opt LPTHREAD_START_ROUTINE pfnCallback);
LWSTDAPI_(BOOL) SHCreateThreadWithHandle(__in LPTHREAD_START_ROUTINE pfnThreadPr
oc, __in_opt void *pData, SHCT_FLAGS flags, __in_opt LPTHREAD_START_ROUTINE pfnC
allback, __out_opt HANDLE *pHandle);
#if (_WIN32_IE >= _WIN32_IE_IE60) #if (_WIN32_IE >= _WIN32_IE_IE60)
LWSTDAPI SHReleaseThreadRef(); // release a CTF_THREAD_REF reference earlier tha n the return of pfnThreadProc LWSTDAPI SHReleaseThreadRef(); // release a CTF_THREAD_REF reference earlier tha n the return of pfnThreadProc
#endif // _WIN32_IE_IE60 #endif // _WIN32_IE_IE60
#ifndef NO_SHLWAPI_GDI #ifndef NO_SHLWAPI_GDI
// //
//====== GDI helper functions ================================================ //====== GDI helper functions ================================================
// //
 End of changes. 85 change blocks. 
247 lines changed or deleted 379 lines changed or added

This html diff was produced by rfcdiff 1.41.