Headers diff for shlwapi.dll between 6.00.3790.3959-Windows 5.0 and 6.0.6002.18005-Windows 6.0 versions



 shlwapi.h (6.00.3790.3959-Windows 5.0)   shlwapi.h (6.0.6002.18005-Windows 6.0) 
skipping to change at line 17 skipping to change at line 17
* * * *
* Copyright (c) Microsoft Corporation. All rights reserved. * * Copyright (c) Microsoft Corporation. All rights reserved. *
* * * *
\*****************************************************************************/ \*****************************************************************************/
#ifndef _INC_SHLWAPI #ifndef _INC_SHLWAPI
#define _INC_SHLWAPI #define _INC_SHLWAPI
#ifndef NOSHLWAPI #ifndef NOSHLWAPI
#include <SpecStrings.h>
#include <objbase.h> #include <objbase.h>
#include <shtypes.h> #include <shtypes.h>
#ifndef _WINRESRC_
#ifndef _WIN32_IE
#define _WIN32_IE 0x0501
#else
#if (_WIN32_IE < 0x0400) && defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0500)
#error _WIN32_IE setting conflicts with _WIN32_WINNT setting
#endif
#endif
#endif
#ifdef UNIX #ifdef UNIX
typedef interface IInternetSecurityMgrSite IInternetSecurityMgrSite; typedef interface IInternetSecurityMgrSite IInternetSecurityMgrSite;
typedef interface IInternetSecurityManager IInternetSecurityManager; typedef interface IInternetSecurityManager IInternetSecurityManager;
typedef interface IInternetHostSecurityManager IInternetHostSecurityManager; typedef interface IInternetHostSecurityManager IInternetHostSecurityManager;
#endif #endif
// //
// Define API decoration for direct importing of DLL references. // Define API decoration for direct importing of DLL references.
// //
#ifndef WINSHLWAPI #ifndef WINSHLWAPI
skipping to change at line 57 skipping to change at line 48
#define LWSTDAPI_(type) STDAPI_(type) #define LWSTDAPI_(type) STDAPI_(type)
#define LWSTDAPIV STDAPIV #define LWSTDAPIV STDAPIV
#define LWSTDAPIV_(type) STDAPIV_(type) #define LWSTDAPIV_(type) STDAPIV_(type)
#endif #endif
#endif // WINSHLWAPI #endif // WINSHLWAPI
#ifdef _WIN32 #ifdef _WIN32
#include <pshpack8.h> #include <pshpack8.h>
#endif #endif
#if defined(DEPRECATE_SUPPORTED)
#pragma warning(push)
#pragma warning(disable:4995)
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#if defined(__cplusplus) && defined(STRICT_CONST)
#define USE_STRICT_CONST
#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.
// //
// NO_SHLWAPI_STRFCNS String functions // NO_SHLWAPI_STRFCNS String functions
// NO_SHLWAPI_PATH Path functions // NO_SHLWAPI_PATH Path functions
// NO_SHLWAPI_REG Registry functions // NO_SHLWAPI_REG Registry functions
// NO_SHLWAPI_STREAM Stream functions // NO_SHLWAPI_STREAM Stream functions
// NO_SHLWAPI_GDI GDI helper functions // NO_SHLWAPI_GDI GDI helper functions
#ifndef NO_SHLWAPI_STRFCNS #ifndef NO_SHLWAPI_STRFCNS
// //
//=============== String Routines =================================== //=============== String Routines ===================================
// //
#ifdef USE_STRICT_CONST
LWSTDAPI_(LPCSTR) StrChrA(LPCSTR lpStart, WORD wMatch);
LWSTDAPI_(LPCWSTR) StrChrW(LPCWSTR lpStart, WCHAR wMatch);
LWSTDAPI_(LPCSTR) StrChrIA(LPCSTR lpStart, WORD wMatch);
LWSTDAPI_(LPCWSTR) StrChrIW(LPCWSTR lpStart, WCHAR wMatch);
#if (_WIN32_IE >= _WIN32_IE_IE60)
LWSTDAPI_(LPCWSTR) StrChrNW(LPCWSTR lpStart, WCHAR wMatch, UINT cchMax);
LWSTDAPI_(LPCWSTR) StrChrNIW(LPCWSTR lpStart, WCHAR wMatch, UINT cchMax);
#endif // _WIN32_IE_IE60
#else
LWSTDAPI_(LPSTR) StrChrA(LPCSTR lpStart, WORD wMatch); LWSTDAPI_(LPSTR) StrChrA(LPCSTR lpStart, WORD wMatch);
LWSTDAPI_(LPWSTR) StrChrW(LPCWSTR lpStart, WCHAR wMatch); LWSTDAPI_(LPWSTR) StrChrW(LPCWSTR lpStart, WCHAR wMatch);
LWSTDAPI_(LPSTR) StrChrIA(LPCSTR lpStart, WORD wMatch); LWSTDAPI_(LPSTR) StrChrIA(LPCSTR lpStart, WORD wMatch);
LWSTDAPI_(LPWSTR) StrChrIW(LPCWSTR lpStart, WCHAR wMatch); LWSTDAPI_(LPWSTR) StrChrIW(LPCWSTR lpStart, WCHAR wMatch);
LWSTDAPI_(int) StrCmpNA(LPCSTR lpStr1, LPCSTR lpStr2, int nChar); #if (_WIN32_IE >= _WIN32_IE_IE60)
LWSTDAPI_(int) StrCmpNW(LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar); LWSTDAPI_(LPWSTR) StrChrNW(LPCWSTR lpStart, WCHAR wMatch, UINT cchMax);
LWSTDAPI_(int) StrCmpNIA(LPCSTR lpStr1, LPCSTR lpStr2, int nChar); LWSTDAPI_(LPWSTR) StrChrNIW(LPCWSTR lpStart, WCHAR wMatch, UINT cchMax);
LWSTDAPI_(int) StrCmpNIW(LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar); #endif // _WIN32_IE_IE60
#endif
LWSTDAPI_(int) StrCmpNA(__in LPCSTR lpStr1, __in LPCSTR 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) 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);
LWSTDAPI_(LPSTR) StrFormatByteSizeA(DWORD dw, LPSTR szBuf, UINT uiBufSize);
LWSTDAPI_(LPSTR) StrFormatByteSize64A(LONGLONG qdw, LPSTR szBuf, UINT uiBufSi LWSTDAPI_(LPSTR) StrFormatByteSizeA(DWORD dw, __out_ecount(cchBuf) LPSTR pszB
ze); uf, UINT cchBuf);
LWSTDAPI_(LPWSTR) StrFormatByteSizeW(LONGLONG qdw, LPWSTR szBuf, UINT uiBufSiz LWSTDAPI_(LPSTR) StrFormatByteSize64A(LONGLONG qdw, __out_ecount(cchBuf) LPST
e); R pszBuf, UINT cchBuf);
LWSTDAPI_(LPWSTR) StrFormatKBSizeW(LONGLONG qdw, LPWSTR szBuf, UINT uiBufSize) LWSTDAPI_(LPWSTR) StrFormatByteSizeW(LONGLONG qdw, __out_ecount(cchBuf) LPWSTR
; pszBuf, UINT cchBuf);
LWSTDAPI_(LPSTR) StrFormatKBSizeA(LONGLONG qdw, LPSTR szBuf, UINT uiBufSize); LWSTDAPI_(LPWSTR) StrFormatKBSizeW(LONGLONG qdw, __out_ecount(cchBuf) LPWSTR p
LWSTDAPI_(int) StrFromTimeIntervalA(LPSTR pszOut, UINT cchMax, DWORD dwTime szBuf, UINT cchBuf);
MS, int digits); LWSTDAPI_(LPSTR) StrFormatKBSizeA(LONGLONG qdw, __out_ecount(cchBuf) LPSTR ps
LWSTDAPI_(int) StrFromTimeIntervalW(LPWSTR pszOut, UINT cchMax, DWORD dwTim zBuf, UINT cchBuf);
eMS, int digits); LWSTDAPI_(int) StrFromTimeIntervalA(__out_ecount(cchMax) LPSTR pszOut, UINT
LWSTDAPI_(BOOL) StrIsIntlEqualA(BOOL fCaseSens, LPCSTR lpString1, LPCSTR lpS cchMax, DWORD dwTimeMS, int digits);
tring2, int nChar); LWSTDAPI_(int) StrFromTimeIntervalW(__out_ecount(cchMax) LPWSTR pwszOut, UI
LWSTDAPI_(BOOL) StrIsIntlEqualW(BOOL fCaseSens, LPCWSTR lpString1, LPCWSTR l NT cchMax, DWORD dwTimeMS, int digits);
pString2, int nChar); LWSTDAPI_(BOOL) StrIsIntlEqualA(__in BOOL fCaseSens, __in LPCSTR lpString1,
LWSTDAPI_(LPSTR) StrNCatA(LPSTR psz1, LPCSTR psz2, int cchMax); __in LPCSTR lpString2, __in int nChar);
LWSTDAPI_(LPWSTR) StrNCatW(LPWSTR psz1, LPCWSTR psz2, int cchMax); LWSTDAPI_(BOOL) StrIsIntlEqualW(__in BOOL fCaseSens, __in LPCWSTR lpString1,
LWSTDAPI_(LPSTR) StrPBrkA(LPCSTR psz, LPCSTR pszSet); __in LPCWSTR lpString2, __in int nChar);
LWSTDAPI_(LPWSTR) StrPBrkW(LPCWSTR psz, LPCWSTR pszSet); LWSTDAPI_(LPSTR) StrNCatA(__inout_ecount(cchMax) LPSTR psz1, LPCSTR psz2, int
LWSTDAPI_(LPSTR) StrRChrA(LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch); cchMax);
LWSTDAPI_(LPWSTR) StrRChrW(LPCWSTR lpStart, LPCWSTR lpEnd, WCHAR wMatch); LWSTDAPI_(LPWSTR) StrNCatW(__inout_ecount(cchMax) LPWSTR psz1, LPCWSTR psz2, i
LWSTDAPI_(LPSTR) StrRChrIA(LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch); nt cchMax);
LWSTDAPI_(LPWSTR) StrRChrIW(LPCWSTR lpStart, LPCWSTR lpEnd, WCHAR wMatch); #ifdef USE_STRICT_CONST
LWSTDAPI_(LPSTR) StrRStrIA(LPCSTR lpSource, LPCSTR lpLast, LPCSTR lpSrch); LWSTDAPI_(LPCSTR) StrPBrkA(__in LPCSTR psz, __in LPCSTR pszSet);
LWSTDAPI_(LPWSTR) StrRStrIW(LPCWSTR lpSource, LPCWSTR lpLast, LPCWSTR lpSrch); LWSTDAPI_(LPCWSTR) StrPBrkW(__in LPCWSTR psz, __in LPCWSTR pszSet);
LWSTDAPI_(int) StrSpnA(LPCSTR psz, LPCSTR pszSet); LWSTDAPI_(LPCSTR) StrRChrA(__in LPCSTR lpStart, __in_opt LPCSTR lpEnd, __in W
LWSTDAPI_(int) StrSpnW(LPCWSTR psz, LPCWSTR pszSet); ORD wMatch);
LWSTDAPI_(LPSTR) StrStrA(LPCSTR lpFirst, LPCSTR lpSrch); LWSTDAPI_(LPCWSTR) StrRChrW(__in LPCWSTR lpStart, __in_opt LPCWSTR lpEnd, __in
LWSTDAPI_(LPWSTR) StrStrW(LPCWSTR lpFirst, LPCWSTR lpSrch); WCHAR wMatch);
LWSTDAPI_(LPSTR) StrStrIA(LPCSTR lpFirst, LPCSTR lpSrch); LWSTDAPI_(LPCSTR) StrRChrIA(__in LPCSTR lpStart, __in_opt LPCSTR lpEnd, __in
LWSTDAPI_(LPWSTR) StrStrIW(LPCWSTR lpFirst, LPCWSTR lpSrch); WORD wMatch);
LWSTDAPI_(int) StrToIntA(LPCSTR lpSrc); LWSTDAPI_(LPCWSTR) StrRChrIW(__in LPCWSTR lpStart, __in_opt LPCWSTR lpEnd, __i
LWSTDAPI_(int) StrToIntW(LPCWSTR lpSrc); n WCHAR wMatch);
LWSTDAPI_(BOOL) StrToIntExA(LPCSTR pszString, DWORD dwFlags, int * piRet); LWSTDAPI_(LPCSTR) StrRStrIA(__in LPCSTR lpSource, __in_opt LPCSTR lpLast, __i
LWSTDAPI_(BOOL) StrToIntExW(LPCWSTR pszString, DWORD dwFlags, int * piRet); n LPCSTR lpSrch);
#if (_WIN32_IE >= 0x0600) LWSTDAPI_(LPCWSTR) StrRStrIW(__in LPCWSTR lpSource, __in_opt LPCWSTR lpLast, _
LWSTDAPI_(BOOL) StrToInt64ExA(LPCSTR pszString, DWORD dwFlags, LONGLONG * pl _in LPCWSTR lpSrch);
lRet); #else
LWSTDAPI_(BOOL) StrToInt64ExW(LPCWSTR pszString, DWORD dwFlags, LONGLONG * p LWSTDAPI_(LPSTR) StrPBrkA(__in LPCSTR psz, __in LPCSTR pszSet);
llRet); LWSTDAPI_(LPWSTR) StrPBrkW(__in LPCWSTR psz, __in LPCWSTR pszSet);
LWSTDAPI_(LPSTR) StrRChrA(__in LPCSTR lpStart, __in_opt LPCSTR lpEnd, __in WO
RD wMatch);
LWSTDAPI_(LPWSTR) StrRChrW(__in LPCWSTR lpStart, __in_opt LPCWSTR lpEnd, __in
WCHAR wMatch);
LWSTDAPI_(LPSTR) StrRChrIA(__in LPCSTR lpStart, __in_opt LPCSTR lpEnd, __in W
ORD wMatch);
LWSTDAPI_(LPWSTR) StrRChrIW(__in LPCWSTR lpStart, __in_opt LPCWSTR lpEnd, __in
WCHAR wMatch);
LWSTDAPI_(LPSTR) StrRStrIA(__in LPCSTR lpSource, __in_opt LPCSTR lpLast, __in
LPCSTR lpSrch);
LWSTDAPI_(LPWSTR) StrRStrIW(__in LPCWSTR lpSource, __in_opt LPCWSTR lpLast, __
in LPCWSTR lpSrch);
#endif
LWSTDAPI_(int) StrSpnA(__in LPCSTR psz, __in LPCSTR pszSet);
LWSTDAPI_(int) StrSpnW(__in LPCWSTR psz, __in LPCWSTR pszSet);
#ifdef USE_STRICT_CONST
LWSTDAPI_(LPCSTR) StrStrA(__in LPCSTR lpFirst, __in LPCSTR lpSrch);
LWSTDAPI_(LPCWSTR) StrStrW(__in LPCWSTR lpFirst, __in LPCWSTR lpSrch);
LWSTDAPI_(LPCSTR) StrStrIA(__in LPCSTR lpFirst, __in LPCSTR lpSrch);
LWSTDAPI_(LPCWSTR) StrStrIW(__in LPCWSTR lpFirst, __in LPCWSTR lpSrch);
#if (_WIN32_IE >= _WIN32_IE_IE6)
LWSTDAPI_(LPCWSTR) StrStrNW(__in LPCWSTR lpFirst, __in LPCWSTR lpSrch, __in UI
NT cchMax);
LWSTDAPI_(LPCWSTR) StrStrNIW(__in LPCWSTR lpFirst, __in LPCWSTR lpSrch, __in U
INT cchMax);
#endif // _WIN32_IE_IE6
#else
LWSTDAPI_(LPSTR) StrStrA(__in LPCSTR lpFirst, __in LPCSTR lpSrch);
LWSTDAPI_(LPWSTR) StrStrW(__in LPCWSTR lpFirst, __in LPCWSTR lpSrch);
LWSTDAPI_(LPSTR) StrStrIA(__in LPCSTR lpFirst, __in LPCSTR lpSrch);
LWSTDAPI_(LPWSTR) StrStrIW(__in LPCWSTR lpFirst, __in LPCWSTR lpSrch);
#if (_WIN32_IE >= _WIN32_IE_IE60)
LWSTDAPI_(LPWSTR) StrStrNW(__in LPCWSTR lpFirst, __in LPCWSTR lpSrch, __in UIN
T cchMax);
LWSTDAPI_(LPWSTR) StrStrNIW(__in LPCWSTR lpFirst, __in LPCWSTR lpSrch, __in UI
NT cchMax);
#endif // _WIN32_IE_IE60
#endif #endif
LWSTDAPI_(BOOL) StrTrimA(LPSTR psz, LPCSTR pszTrimChars);
LWSTDAPI_(BOOL) StrTrimW(LPWSTR psz, LPCWSTR pszTrimChars);
LWSTDAPI_(LPWSTR) StrCatW(LPWSTR psz1, LPCWSTR psz2); #define STIF_DEFAULT 0x00000000L
LWSTDAPI_(int) StrCmpW(LPCWSTR psz1, LPCWSTR psz2); #define STIF_SUPPORT_HEX 0x00000001L
LWSTDAPI_(int) StrCmpIW(LPCWSTR psz1, LPCWSTR psz2); typedef int STIF_FLAGS;
LWSTDAPI_(LPWSTR) StrCpyW(LPWSTR psz1, LPCWSTR psz2); LWSTDAPI_(int) StrToIntA(__in LPCSTR lpSrc);
LWSTDAPI_(LPWSTR) StrCpyNW(LPWSTR psz1, LPCWSTR psz2, int cchMax); LWSTDAPI_(int) StrToIntW(__in LPCWSTR lpSrc);
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);
#if (_WIN32_IE >= _WIN32_IE_IE60)
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);
#endif // _WIN32_IE_IE60
LWSTDAPI_(LPWSTR) StrCatBuffW(LPWSTR pszDest, LPCWSTR pszSrc, int cchDestBuffS LWSTDAPI_(BOOL) StrTrimA(__inout LPSTR psz, LPCSTR pszTrimChars);
ize); LWSTDAPI_(BOOL) StrTrimW(__inout LPWSTR psz, LPCWSTR pszTrimChars);
LWSTDAPI_(LPSTR) StrCatBuffA(LPSTR pszDest, LPCSTR pszSrc, int cchDestBuffSiz
e);
LWSTDAPI_(BOOL) ChrCmpIA(WORD w1, WORD w2); LWSTDAPI_(LPWSTR) StrCatW(__inout LPWSTR psz1, LPCWSTR psz2);
LWSTDAPI_(BOOL) ChrCmpIW(WCHAR w1, WCHAR w2); LWSTDAPI_(int) StrCmpW(__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) StrCpyNW(__out_ecount(cchMax) LPWSTR psz1, LPCWSTR psz2, int
cchMax);
LWSTDAPI_(int) wvnsprintfA(LPSTR lpOut, int cchLimitIn, LPCSTR lpFmt, va_li LWSTDAPI_(LPWSTR) StrCatBuffW(__inout_ecount(cchDestBuffSize) LPWSTR pszDest,
st arglist); LPCWSTR pszSrc, int cchDestBuffSize);
LWSTDAPI_(int) wvnsprintfW(LPWSTR lpOut, int cchLimitIn, LPCWSTR lpFmt, va_ LWSTDAPI_(LPSTR) StrCatBuffA(__inout_ecount(cchDestBuffSize) LPSTR pszDest, L
list arglist); PCSTR pszSrc, int cchDestBuffSize);
LWSTDAPIV_(int) wnsprintfA(LPSTR lpOut, int cchLimitIn, LPCSTR lpFmt, ...); LWSTDAPI_(BOOL) ChrCmpIA(__in WORD w1, __in WORD w2);
LWSTDAPIV_(int) wnsprintfW(LPWSTR lpOut, int cchLimitIn, LPCWSTR lpFmt, ...) LWSTDAPI_(BOOL) ChrCmpIW(__in WCHAR w1, __in WCHAR w2);
;
LWSTDAPI_(int) wvnsprintfA(__out_ecount(cchLimitIn) LPSTR lpOut, int cchLim
itIn, LPCSTR lpFmt, __in va_list arglist);
LWSTDAPI_(int) wvnsprintfW(__out_ecount(cchLimitIn) LPWSTR lpOut, int cchLi
mitIn, LPCWSTR lpFmt, __in va_list arglist);
LWSTDAPIV_(int) wnsprintfA(__out_ecount(cchLimitIn) LPSTR lpOut, int cchLimi
tIn, LPCSTR lpFmt, ...);
LWSTDAPIV_(int) wnsprintfW(__out_ecount(cchLimitIn) LPWSTR lpOut, int cchLim
itIn, LPCWSTR lpFmt, ...);
#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(STRRET *pstr, LPCITEMIDLIST pidl, LPSTR *ppsz); LWSTDAPI StrRetToStrA(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __out
LWSTDAPI StrRetToStrW(STRRET *pstr, LPCITEMIDLIST pidl, LPWSTR *ppsz); LPSTR *ppsz);
LWSTDAPI StrRetToStrW(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __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(STRRET *pstr, LPCITEMIDLIST pidl, LPSTR pszBuf, UINT cchBu LWSTDAPI StrRetToBufA(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __out
f); _ecount(cchBuf) LPSTR pszBuf, UINT cchBuf);
LWSTDAPI StrRetToBufW(STRRET *pstr, LPCITEMIDLIST pidl, LPWSTR pszBuf, UINT cchB LWSTDAPI StrRetToBufW(__inout STRRET *pstr, __in_opt PCUITEMID_CHILD pidl, __out
uf); _ecount(cchBuf) LPWSTR pszBuf, UINT cchBuf);
#ifdef UNICODE #ifdef UNICODE
#define StrRetToBuf StrRetToBufW #define StrRetToBuf StrRetToBufW
#else #else
#define StrRetToBuf StrRetToBufA #define StrRetToBuf StrRetToBufA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI StrRetToBSTR(STRRET *pstr, LPCITEMIDLIST pidl, BSTR *pbstr);
// helper to duplicate a string using the task allocator // helper to duplicate a string using the task allocator
LWSTDAPI SHStrDupA(LPCSTR psz, WCHAR **ppwsz); LWSTDAPI SHStrDupA(__in LPCSTR psz, __deref_out LPWSTR *ppwsz);
LWSTDAPI SHStrDupW(LPCWSTR psz, WCHAR **ppwsz); LWSTDAPI SHStrDupW(__in LPCWSTR psz, __deref_out LPWSTR *ppwsz);
#ifdef UNICODE #ifdef UNICODE
#define SHStrDup SHStrDupW #define SHStrDup SHStrDupW
#else #else
#define SHStrDup SHStrDupA #define SHStrDup SHStrDupA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(int) StrCmpLogicalW(LPCWSTR psz1, LPCWSTR psz2); #ifdef __cplusplus
LWSTDAPI_(DWORD) StrCatChainW(LPWSTR pszDst, DWORD cchDst, DWORD ichAt, LPCWSTR // make the above helper function a bit easier to use in the HRESULT world
pszSrc); inline HRESULT SHLocalStrDupW(LPCWSTR psz, __out LPWSTR *ppsz)
{
*ppsz = StrDupW(psz);
return *ppsz ? S_OK : E_OUTOFMEMORY;
}
inline HRESULT SHLocalStrDupA(LPCSTR psz, __out LPSTR *ppsz)
{
*ppsz = StrDupA(psz);
return *ppsz ? S_OK : E_OUTOFMEMORY;
}
#ifdef UNICODE
#define SHLocalStrDup SHLocalStrDupW
#else
#define SHLocalStrDup SHLocalStrDupA
#endif
#endif // __cplusplus
LWSTDAPI SHLoadIndirectString(LPCWSTR pszSource, LPWSTR pszOutBuf, UINT cchOutBu #if (_WIN32_IE >= _WIN32_IE_IE55)
f, void **ppvReserved); LWSTDAPI_(int) StrCmpLogicalW(__in LPCWSTR psz1, __in LPCWSTR psz2);
LWSTDAPI_(DWORD) StrCatChainW(__out_ecount(cchDst) LPWSTR pszDst, DWORD cchDst,
DWORD ichAt, LPCWSTR pszSrc);
LWSTDAPI StrRetToBSTR(__inout STRRET *pstr, __in PCUITEMID_CHILD pidl, __out BST
R *pbstr);
LWSTDAPI SHLoadIndirectString(LPCWSTR pszSource, __out_ecount(cchOutBuf) LPWSTR
pszOutBuf, UINT cchOutBuf, __in_opt void **ppvReserved);
#endif // _WIN32_IE_IE55
#if (_WIN32_IE >= 0x0603) #if (_WIN32_IE >= _WIN32_IE_IE60SP2)
LWSTDAPI_(BOOL) IsCharSpaceA(CHAR wch); LWSTDAPI_(BOOL) IsCharSpaceA(__in CHAR wch);
LWSTDAPI_(BOOL) IsCharSpaceW(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
LWSTDAPI_(int) StrCmpCA(LPCSTR pszStr1, LPCSTR pszStr2); LWSTDAPI_(int) StrCmpCA(__in LPCSTR pszStr1, __in LPCSTR pszStr2);
LWSTDAPI_(int) StrCmpCW(LPCWSTR pszStr1, LPCWSTR pszStr2); LWSTDAPI_(int) StrCmpCW(__in LPCWSTR pszStr1, __in LPCWSTR pszStr2);
#ifdef UNICODE #ifdef UNICODE
#define StrCmpC StrCmpCW #define StrCmpC StrCmpCW
#else #else
#define StrCmpC StrCmpCA #define StrCmpC StrCmpCA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(int) StrCmpICA(LPCSTR pszStr1, LPCSTR pszStr2); LWSTDAPI_(int) StrCmpICA(__in LPCSTR pszStr1, __in LPCSTR pszStr2);
LWSTDAPI_(int) StrCmpICW(LPCWSTR pszStr1, LPCWSTR pszStr2); LWSTDAPI_(int) StrCmpICW(__in LPCWSTR pszStr1, __in LPCWSTR pszStr2);
#ifdef UNICODE #ifdef UNICODE
#define StrCmpIC StrCmpICW #define StrCmpIC StrCmpICW
#else #else
#define StrCmpIC StrCmpICA #define StrCmpIC StrCmpICA
#endif // !UNICODE #endif // !UNICODE
#endif // (_WIN32_IE >= 0x0603) #endif // _WIN32_IE_IE60SP2
#ifdef UNICODE #ifdef UNICODE
#define StrChr StrChrW #define StrChr StrChrW
#define StrRChr StrRChrW #define StrRChr StrRChrW
#define StrChrI StrChrIW #define StrChrI StrChrIW
#define StrRChrI StrRChrIW #define StrRChrI StrRChrIW
#define StrCmpN StrCmpNW #define StrCmpN StrCmpNW
#define StrCmpNI StrCmpNIW #define StrCmpNI StrCmpNIW
#define StrStr StrStrW #define StrStr StrStrW
#define StrStrI StrStrIW #define StrStrI StrStrIW
skipping to change at line 274 skipping to change at line 339
#define StrFormatKBSize StrFormatKBSizeA #define StrFormatKBSize StrFormatKBSizeA
#define StrNCat StrNCatA #define StrNCat StrNCatA
#define StrTrim StrTrimA #define StrTrim StrTrimA
#define StrCatBuff StrCatBuffA #define StrCatBuff StrCatBuffA
#define ChrCmpI ChrCmpIA #define ChrCmpI ChrCmpIA
#define wvnsprintf wvnsprintfA #define wvnsprintf wvnsprintfA
#define wnsprintf wnsprintfA #define wnsprintf wnsprintfA
#define StrIsIntlEqual StrIsIntlEqualA #define StrIsIntlEqual StrIsIntlEqualA
#endif #endif
#if (_WIN32_IE >= _WIN32_IE_IE50)
// StrCmp*C* - Compare strings using C runtime collation rules.
LWSTDAPI_(int) StrCmpNCA(__in LPCSTR lpStr1, __in LPCSTR lpStr2, __in int nChar
);
// StrCmp*C* - Compare strings using C runtime collation rules.
LWSTDAPI_(int) StrCmpNCW(__in LPCWSTR lpStr1, __in LPCWSTR lpStr2, __in int nCh
ar);
#ifdef UNICODE
#define StrCmpNC StrCmpNCW
#else
#define StrCmpNC StrCmpNCA
#endif // !UNICODE
LWSTDAPI_(int) StrCmpNICA(__in LPCSTR lpStr1, __in LPCSTR lpStr2, __in int nCha
r);
LWSTDAPI_(int) StrCmpNICW(__in LPCWSTR lpStr1, __in LPCWSTR lpStr2, __in int nC
har);
#ifdef UNICODE
#define StrCmpNIC StrCmpNICW
#else
#define StrCmpNIC StrCmpNICA
#endif // !UNICODE
#endif // _WIN32_IE_IE50
// Backward compatible to NT's non-standard naming (strictly // Backward compatible to NT's non-standard naming (strictly
// for comctl32) // for comctl32)
// //
LWSTDAPI_(BOOL) IntlStrEqWorkerA(BOOL fCaseSens, LPCSTR lpString1, LPCSTR lp LWSTDAPI_(BOOL) IntlStrEqWorkerA(BOOL fCaseSens, __in_ecount(nChar) LPCSTR l
String2, int nChar); pString1, __in_ecount(nChar) LPCSTR lpString2, int nChar);
LWSTDAPI_(BOOL) IntlStrEqWorkerW(BOOL fCaseSens, LPCWSTR lpString1, LPCWSTR LWSTDAPI_(BOOL) IntlStrEqWorkerW(BOOL fCaseSens, __in_ecount(nChar) LPCWSTR
lpString2, int nChar); lpString1, __in_ecount(nChar) LPCWSTR lpString2, int nChar);
#define IntlStrEqNA( s1, s2, nChar) IntlStrEqWorkerA( TRUE, s1, s2, nChar) #define IntlStrEqNA( s1, s2, nChar) IntlStrEqWorkerA( TRUE, s1, s2, nChar)
#define IntlStrEqNW( s1, s2, nChar) IntlStrEqWorkerW( TRUE, s1, s2, nChar) #define IntlStrEqNW( s1, s2, nChar) IntlStrEqWorkerW( TRUE, s1, s2, nChar)
#define IntlStrEqNIA(s1, s2, nChar) IntlStrEqWorkerA(FALSE, s1, s2, nChar) #define IntlStrEqNIA(s1, s2, nChar) IntlStrEqWorkerA(FALSE, s1, s2, nChar)
#define IntlStrEqNIW(s1, s2, nChar) IntlStrEqWorkerW(FALSE, s1, s2, nChar) #define IntlStrEqNIW(s1, s2, nChar) IntlStrEqWorkerW(FALSE, s1, s2, nChar)
#ifdef UNICODE #ifdef UNICODE
#define IntlStrEqN IntlStrEqNW #define IntlStrEqN IntlStrEqNW
#define IntlStrEqNI IntlStrEqNIW #define IntlStrEqNI IntlStrEqNIW
#else #else
skipping to change at line 309 skipping to change at line 393
#define SZ_CONTENTTYPE_HTML SZ_CONTENTTYPE_HTMLW #define SZ_CONTENTTYPE_HTML SZ_CONTENTTYPE_HTMLW
#define SZ_CONTENTTYPE_CDF SZ_CONTENTTYPE_CDFW #define SZ_CONTENTTYPE_CDF SZ_CONTENTTYPE_CDFW
#else #else
#define SZ_CONTENTTYPE_HTML SZ_CONTENTTYPE_HTMLA #define SZ_CONTENTTYPE_HTML SZ_CONTENTTYPE_HTMLA
#define SZ_CONTENTTYPE_CDF SZ_CONTENTTYPE_CDFA #define SZ_CONTENTTYPE_CDF SZ_CONTENTTYPE_CDFA
#endif #endif
#define PathIsHTMLFileA(pszPath) PathIsContentTypeA(pszPath, SZ_CONTENTTYPE_ HTMLA) #define PathIsHTMLFileA(pszPath) PathIsContentTypeA(pszPath, SZ_CONTENTTYPE_ HTMLA)
#define PathIsHTMLFileW(pszPath) PathIsContentTypeW(pszPath, SZ_CONTENTTYPE_ HTMLW) #define PathIsHTMLFileW(pszPath) PathIsContentTypeW(pszPath, SZ_CONTENTTYPE_ HTMLW)
// Flags for StrToIntEx
#define STIF_DEFAULT 0x00000000L
#define STIF_SUPPORT_HEX 0x00000001L
#define StrCatA lstrcatA #define StrCatA lstrcatA
#define StrCmpA lstrcmpA #define StrCmpA lstrcmpA
#define StrCmpIA lstrcmpiA #define StrCmpIA lstrcmpiA
#define StrCpyA lstrcpyA #define StrCpyA lstrcpyA
#define StrCpyNA lstrcpynA #define StrCpyNA lstrcpynA
#define StrToLong StrToInt #define StrToLong StrToInt
#define StrNCmp StrCmpN #define StrNCmp StrCmpN
#define StrNCmpI StrCmpNI #define StrNCmpI StrCmpNI
#define StrNCpy StrCpyN #define StrNCpy StrCpyN
skipping to change at line 349 skipping to change at line 429
#endif #endif
#endif // NO_SHLWAPI_STRFCNS #endif // NO_SHLWAPI_STRFCNS
#ifndef NO_SHLWAPI_PATH #ifndef NO_SHLWAPI_PATH
// //
//=============== Path Routines =================================== //=============== Path Routines ===================================
// //
LWSTDAPI_(LPSTR) PathAddBackslashA(LPSTR pszPath); LWSTDAPI_(LPSTR) PathAddBackslashA(__inout_ecount(MAX_PATH) LPSTR pszPath);
LWSTDAPI_(LPWSTR) PathAddBackslashW(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(LPSTR pszPath, LPCSTR pszExt); LWSTDAPI_(BOOL) PathAddExtensionA(__inout_ecount(MAX_PATH) LPSTR pszPath, LP
LWSTDAPI_(BOOL) PathAddExtensionW(LPWSTR pszPath, LPCWSTR pszExt); CSTR pszExt);
LWSTDAPI_(BOOL) PathAddExtensionW(__inout_ecount(MAX_PATH) LPWSTR pszPath, L
PCWSTR 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(LPSTR pszPath, LPCSTR pMore); LWSTDAPI_(BOOL) PathAppendA(__inout_ecount(MAX_PATH) LPSTR pszPath, LPCSTR p
LWSTDAPI_(BOOL) PathAppendW(LPWSTR pszPath, LPCWSTR pMore); More);
LWSTDAPI_(LPSTR) PathBuildRootA(LPSTR pszRoot, int iDrive); LWSTDAPI_(BOOL) PathAppendW(__inout_ecount(MAX_PATH) LPWSTR pszPath, LPCWSTR
LWSTDAPI_(LPWSTR) PathBuildRootW(LPWSTR pszRoot, int iDrive); pMore);
LWSTDAPI_(LPSTR) PathBuildRootA(__out_ecount(4) LPSTR 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(LPSTR pszBuf, LPCSTR pszPath); LWSTDAPI_(BOOL) PathCanonicalizeA(__out_ecount(MAX_PATH) LPSTR pszBuf, LPCST
LWSTDAPI_(BOOL) PathCanonicalizeW(LPWSTR pszBuf, LPCWSTR pszPath); R pszPath);
LWSTDAPI_(LPSTR) PathCombineA(LPSTR pszDest, LPCSTR pszDir, LPCSTR pszFile); LWSTDAPI_(BOOL) PathCanonicalizeW(__out_ecount(MAX_PATH) LPWSTR pszBuf, LPCW
LWSTDAPI_(LPWSTR) PathCombineW(LPWSTR pszDest, LPCWSTR pszDir, LPCWSTR pszFile) STR pszPath);
; LWSTDAPI_(LPSTR) PathCombineA(__out_ecount(MAX_PATH) LPSTR pszDest, LPCSTR pszD
ir, LPCSTR pszFile);
LWSTDAPI_(LPWSTR) PathCombineW(__out_ecount(MAX_PATH) LPWSTR pszDest, LPCWSTR p
szDir, 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, LPSTR pszPath, UINT dx); LWSTDAPI_(BOOL) PathCompactPathA(HDC hDC, __inout_ecount(MAX_PATH) LPSTR psz
LWSTDAPI_(BOOL) PathCompactPathW(HDC hDC, LPWSTR pszPath, UINT dx); Path, UINT dx);
LWSTDAPI_(BOOL) PathCompactPathExA(LPSTR pszOut, LPCSTR pszSrc, UINT cchMax, LWSTDAPI_(BOOL) PathCompactPathW(HDC hDC, __inout_ecount(MAX_PATH) LPWSTR ps
DWORD dwFlags); zPath, UINT dx);
LWSTDAPI_(BOOL) PathCompactPathExW(LPWSTR pszOut, LPCWSTR pszSrc, UINT cchMa LWSTDAPI_(BOOL) PathCompactPathExA(__out_ecount(cchMax) LPSTR pszOut, LPCSTR
x, DWORD dwFlags); pszSrc, UINT cchMax, DWORD dwFlags);
LWSTDAPI_(int) PathCommonPrefixA(LPCSTR pszFile1, LPCSTR pszFile2, LPSTR ac LWSTDAPI_(BOOL) PathCompactPathExW(__out_ecount(cchMax) LPWSTR pszOut, LPCWS
hPath); TR pszSrc, UINT cchMax, DWORD dwFlags);
LWSTDAPI_(int) PathCommonPrefixW(LPCWSTR pszFile1, LPCWSTR pszFile2, LPWSTR LWSTDAPI_(int) PathCommonPrefixA(LPCSTR pszFile1, LPCSTR pszFile2, __out_ec
achPath); ount_opt(MAX_PATH) LPSTR achPath);
LWSTDAPI_(BOOL) PathFileExistsA(LPCSTR pszPath); LWSTDAPI_(int) PathCommonPrefixW(LPCWSTR pszFile1, LPCWSTR pszFile2, __out_
LWSTDAPI_(BOOL) PathFileExistsW(LPCWSTR pszPath); ecount_opt(MAX_PATH) LPWSTR achPath);
LWSTDAPI_(BOOL) PathFileExistsA(__in LPCSTR 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
LWSTDAPI_(LPSTR) PathFindExtensionA(LPCSTR pszPath); #ifdef USE_STRICT_CONST
LWSTDAPI_(LPWSTR) PathFindExtensionW(LPCWSTR pszPath); LWSTDAPI_(LPCSTR) PathFindExtensionA(__in LPCSTR pszPath);
LWSTDAPI_(LPCWSTR) PathFindExtensionW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathFindExtension PathFindExtensionW #define PathFindExtension PathFindExtensionW
#else #else
#define PathFindExtension PathFindExtensionA #define PathFindExtension PathFindExtensionA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(LPSTR) PathFindFileNameA(LPCSTR pszPath); LWSTDAPI_(LPCSTR) PathFindFileNameA(__in LPCSTR pszPath);
LWSTDAPI_(LPWSTR) PathFindFileNameW(LPCWSTR pszPath); LWSTDAPI_(LPCWSTR) PathFindFileNameW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathFindFileName PathFindFileNameW #define PathFindFileName PathFindFileNameW
#else #else
#define PathFindFileName PathFindFileNameA #define PathFindFileName PathFindFileNameA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(LPSTR) PathFindNextComponentA(LPCSTR pszPath); LWSTDAPI_(LPCSTR) PathFindNextComponentA(__in LPCSTR pszPath);
LWSTDAPI_(LPWSTR) PathFindNextComponentW(LPCWSTR pszPath); LWSTDAPI_(LPCWSTR) 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
LWSTDAPI_(BOOL) PathFindOnPathA(LPSTR pszPath, LPCSTR * ppszOtherDirs); #else
LWSTDAPI_(BOOL) PathFindOnPathW(LPWSTR pszPath, LPCWSTR * ppszOtherDirs); LWSTDAPI_(LPSTR) PathFindExtensionA(__in LPCSTR pszPath);
LWSTDAPI_(LPSTR) PathGetArgsA(LPCSTR pszPath); LWSTDAPI_(LPWSTR) PathFindExtensionW(__in LPCWSTR pszPath);
LWSTDAPI_(LPWSTR) PathGetArgsW(LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathGetArgs PathGetArgsW #define PathFindExtension PathFindExtensionW
#else #else
#define PathGetArgs PathGetArgsA #define PathFindExtension PathFindExtensionA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(LPCSTR) PathFindSuffixArrayA(LPCSTR pszPath, const LPCSTR *apszSuffix, LWSTDAPI_(LPSTR) PathFindFileNameA(__in LPCSTR pszPath);
int iArraySize); LWSTDAPI_(LPWSTR) PathFindFileNameW(__in LPCWSTR pszPath);
LWSTDAPI_(LPCWSTR) PathFindSuffixArrayW(LPCWSTR pszPath, const LPCWSTR *apszSuff #ifdef UNICODE
ix, int iArraySize); #define PathFindFileName PathFindFileNameW
#else
#define PathFindFileName PathFindFileNameA
#endif // !UNICODE
LWSTDAPI_(LPSTR) PathFindNextComponentA(__in LPCSTR pszPath);
LWSTDAPI_(LPWSTR) PathFindNextComponentW(__in LPCWSTR pszPath);
#ifdef UNICODE
#define PathFindNextComponent PathFindNextComponentW
#else
#define PathFindNextComponent PathFindNextComponentA
#endif // !UNICODE
#endif
LWSTDAPI_(BOOL) PathFindOnPathA(__inout_ecount(MAX_PATH) LPSTR pszPath, __in
_opt __nullterminated LPCSTR * ppszOtherDirs);
LWSTDAPI_(BOOL) PathFindOnPathW(__inout_ecount(MAX_PATH) LPWSTR pszPath, __i
n_opt __nullterminated LPCWSTR * ppszOtherDirs);
LWSTDAPI_(LPCSTR) PathFindSuffixArrayA(LPCSTR pszPath, __in_ecount(iArraySize) c
onst LPCSTR *apszSuffix, int iArraySize);
LWSTDAPI_(LPCWSTR) PathFindSuffixArrayW(LPCWSTR pszPath, __in_ecount(iArraySize)
const LPCWSTR *apszSuffix, 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
LWSTDAPI_(LPCSTR) PathGetArgsA(__in LPCSTR pszPath);
LWSTDAPI_(LPCWSTR) PathGetArgsW(__in LPCWSTR pszPath);
#ifdef UNICODE
#define PathGetArgs PathGetArgsW
#else
#define PathGetArgs PathGetArgsA
#endif // !UNICODE
#else
LWSTDAPI_(LPSTR) PathGetArgsA(__in LPCSTR pszPath);
LWSTDAPI_(LPWSTR) PathGetArgsW(__in LPCWSTR pszPath);
#ifdef UNICODE
#define PathGetArgs PathGetArgsW
#else
#define PathGetArgs PathGetArgsA
#endif // !UNICODE
#endif
LWSTDAPI_(BOOL) PathIsLFNFileSpecA(LPCSTR lpName); LWSTDAPI_(BOOL) PathIsLFNFileSpecA(LPCSTR lpName);
LWSTDAPI_(BOOL) PathIsLFNFileSpecW(LPCWSTR lpName); LWSTDAPI_(BOOL) PathIsLFNFileSpecW(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(UCHAR ch); LWSTDAPI_(UINT) PathGetCharTypeW(__in WCHAR ch);
LWSTDAPI_(UINT) PathGetCharTypeW(WCHAR ch);
// Return flags for PathGetCharType // Return flags for PathGetCharType
#define GCT_INVALID 0x0000 #define GCT_INVALID 0x0000
#define GCT_LFNCHAR 0x0001 #define GCT_LFNCHAR 0x0001
#define GCT_SHORTCHAR 0x0002 #define GCT_SHORTCHAR 0x0002
#define GCT_WILD 0x0004 #define GCT_WILD 0x0004
#define GCT_SEPARATOR 0x0008 #define GCT_SEPARATOR 0x0008
LWSTDAPI_(int) PathGetDriveNumberA(LPCSTR pszPath); LWSTDAPI_(int) PathGetDriveNumberA(__in LPCSTR pszPath);
LWSTDAPI_(int) PathGetDriveNumberW(LPCWSTR pszPath); LWSTDAPI_(int) PathGetDriveNumberW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathGetDriveNumber PathGetDriveNumberW #define PathGetDriveNumber PathGetDriveNumberW
#else #else
#define PathGetDriveNumber PathGetDriveNumberA #define PathGetDriveNumber PathGetDriveNumberA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsDirectoryA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathIsDirectoryA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathIsDirectoryW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathIsDirectoryW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathIsDirectory PathIsDirectoryW #define PathIsDirectory PathIsDirectoryW
#else #else
#define PathIsDirectory PathIsDirectoryA #define PathIsDirectory PathIsDirectoryA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsDirectoryEmptyA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathIsDirectoryEmptyA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathIsDirectoryEmptyW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathIsDirectoryEmptyW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathIsDirectoryEmpty PathIsDirectoryEmptyW #define PathIsDirectoryEmpty PathIsDirectoryEmptyW
#else #else
#define PathIsDirectoryEmpty PathIsDirectoryEmptyA #define PathIsDirectoryEmpty PathIsDirectoryEmptyA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsFileSpecA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathIsFileSpecA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathIsFileSpecW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathIsFileSpecW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathIsFileSpec PathIsFileSpecW #define PathIsFileSpec PathIsFileSpecW
#else #else
#define PathIsFileSpec PathIsFileSpecA #define PathIsFileSpec PathIsFileSpecA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsPrefixA(LPCSTR pszPrefix, LPCSTR pszPath); LWSTDAPI_(BOOL) PathIsPrefixA(__in LPCSTR pszPrefix, __in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathIsPrefixW(LPCWSTR pszPrefix, LPCWSTR pszPath); LWSTDAPI_(BOOL) PathIsPrefixW(__in LPCWSTR pszPrefix, __in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathIsPrefix PathIsPrefixW #define PathIsPrefix PathIsPrefixW
#else #else
#define PathIsPrefix PathIsPrefixA #define PathIsPrefix PathIsPrefixA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsRelativeA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathIsRelativeA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathIsRelativeW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathIsRelativeW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathIsRelative PathIsRelativeW #define PathIsRelative PathIsRelativeW
#else #else
#define PathIsRelative PathIsRelativeA #define PathIsRelative PathIsRelativeA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsRootA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathIsRootA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathIsRootW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathIsRootW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathIsRoot PathIsRootW #define PathIsRoot PathIsRootW
#else #else
#define PathIsRoot PathIsRootA #define PathIsRoot PathIsRootA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsSameRootA(LPCSTR pszPath1, LPCSTR pszPath2); LWSTDAPI_(BOOL) PathIsSameRootA(__in LPCSTR pszPath1, __in LPCSTR pszPath2);
LWSTDAPI_(BOOL) PathIsSameRootW(LPCWSTR pszPath1, LPCWSTR pszPath2); LWSTDAPI_(BOOL) PathIsSameRootW(__in LPCWSTR pszPath1, __in LPCWSTR pszPath2
);
#ifdef UNICODE #ifdef UNICODE
#define PathIsSameRoot PathIsSameRootW #define PathIsSameRoot PathIsSameRootW
#else #else
#define PathIsSameRoot PathIsSameRootA #define PathIsSameRoot PathIsSameRootA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsUNCA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathIsUNCA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathIsUNCW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathIsUNCW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathIsUNC PathIsUNCW #define PathIsUNC PathIsUNCW
#else #else
#define PathIsUNC PathIsUNCA #define PathIsUNC PathIsUNCA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsNetworkPathA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathIsNetworkPathA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathIsNetworkPathW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathIsNetworkPathW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathIsNetworkPath PathIsNetworkPathW #define PathIsNetworkPath PathIsNetworkPathW
#else #else
#define PathIsNetworkPath PathIsNetworkPathA #define PathIsNetworkPath PathIsNetworkPathA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsUNCServerA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathIsUNCServerA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathIsUNCServerW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathIsUNCServerW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathIsUNCServer PathIsUNCServerW #define PathIsUNCServer PathIsUNCServerW
#else #else
#define PathIsUNCServer PathIsUNCServerA #define PathIsUNCServer PathIsUNCServerA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsUNCServerShareA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathIsUNCServerShareA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathIsUNCServerShareW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathIsUNCServerShareW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathIsUNCServerShare PathIsUNCServerShareW #define PathIsUNCServerShare PathIsUNCServerShareW
#else #else
#define PathIsUNCServerShare PathIsUNCServerShareA #define PathIsUNCServerShare PathIsUNCServerShareA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsContentTypeA(LPCSTR pszPath, LPCSTR pszContentType); LWSTDAPI_(BOOL) PathIsContentTypeA(__in LPCSTR pszPath, __in LPCSTR pszConte
LWSTDAPI_(BOOL) PathIsContentTypeW(LPCWSTR pszPath, LPCWSTR pszContentType); ntType);
LWSTDAPI_(BOOL) PathIsURLA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathIsContentTypeW(__in LPCWSTR pszPath, __in LPCWSTR pszCon
LWSTDAPI_(BOOL) PathIsURLW(LPCWSTR pszPath); tentType);
LWSTDAPI_(BOOL) PathIsURLA(__in LPCSTR pszPath);
LWSTDAPI_(BOOL) PathIsURLW(__in LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathIsURL PathIsURLW #define PathIsURL PathIsURLW
#else #else
#define PathIsURL PathIsURLA #define PathIsURL PathIsURLA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathMakePrettyA(LPSTR pszPath); LWSTDAPI_(BOOL) PathMakePrettyA(__inout LPSTR pszPath);
LWSTDAPI_(BOOL) PathMakePrettyW(LPWSTR pszPath); LWSTDAPI_(BOOL) PathMakePrettyW(__inout LPWSTR pszPath);
LWSTDAPI_(BOOL) PathMatchSpecA(LPCSTR pszFile, LPCSTR pszSpec); LWSTDAPI_(BOOL) PathMatchSpecA(__in LPCSTR pszFile, __in LPCSTR pszSpec);
LWSTDAPI_(BOOL) PathMatchSpecW(LPCWSTR pszFile, LPCWSTR pszSpec); LWSTDAPI_(BOOL) PathMatchSpecW(__in LPCWSTR pszFile, __in LPCWSTR pszSpec);
LWSTDAPI_(int) PathParseIconLocationA(LPSTR pszIconFile);
LWSTDAPI_(int) PathParseIconLocationW(LPWSTR pszIconFile); #if (_WIN32_IE >= _WIN32_IE_IE70)
LWSTDAPI_(void) PathQuoteSpacesA(LPSTR lpsz); // Flags for PathMatchSpecEx
LWSTDAPI_(void) PathQuoteSpacesW(LPWSTR lpsz); #define PMSF_NORMAL 0x00000000
LWSTDAPI_(BOOL) PathRelativePathToA(LPSTR pszPath, LPCSTR pszFrom, DWORD dwA #define PMSF_MULTIPLE 0x00000001
ttrFrom, LPCSTR pszTo, DWORD dwAttrTo); #define PMSF_DONT_STRIP_SPACES 0x00010000 // modifies either of the above
LWSTDAPI_(BOOL) PathRelativePathToW(LPWSTR pszPath, LPCWSTR pszFrom, DWORD d
wAttrFrom, LPCWSTR pszTo, DWORD dwAttrTo); LWSTDAPI PathMatchSpecExA(LPCSTR pszFile, LPCSTR pszSpec, DWORD dwFlags);
LWSTDAPI_(void) PathRemoveArgsA(LPSTR pszPath); LWSTDAPI PathMatchSpecExW(LPCWSTR pszFile, LPCWSTR pszSpec, DWORD dwFlags);
LWSTDAPI_(void) PathRemoveArgsW(LPWSTR pszPath); #endif // _WIN32_IE_IE70
LWSTDAPI_(LPSTR) PathRemoveBackslashA(LPSTR pszPath);
LWSTDAPI_(LPWSTR) PathRemoveBackslashW(LPWSTR pszPath); LWSTDAPI_(int) PathParseIconLocationA(__inout LPSTR pszIconFile);
LWSTDAPI_(int) PathParseIconLocationW(__inout LPWSTR pszIconFile);
LWSTDAPI_(BOOL) PathQuoteSpacesA(__inout_ecount(MAX_PATH) LPSTR lpsz);
LWSTDAPI_(BOOL) PathQuoteSpacesW(__inout_ecount(MAX_PATH) LPWSTR lpsz);
LWSTDAPI_(BOOL) PathRelativePathToA(__out_ecount(MAX_PATH) LPSTR pszPath, LP
CSTR pszFrom, DWORD dwAttrFrom, LPCSTR pszTo, DWORD dwAttrTo);
LWSTDAPI_(BOOL) PathRelativePathToW(__out_ecount(MAX_PATH) LPWSTR pszPath, L
PCWSTR pszFrom, DWORD dwAttrFrom, LPCWSTR pszTo, DWORD dwAttrTo);
LWSTDAPI_(void) PathRemoveArgsA(__inout LPSTR pszPath);
LWSTDAPI_(void) PathRemoveArgsW(__inout LPWSTR pszPath);
LWSTDAPI_(LPSTR) PathRemoveBackslashA(__inout LPSTR 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(LPSTR pszPath); LWSTDAPI_(void) PathRemoveBlanksA(__inout LPSTR pszPath);
LWSTDAPI_(void) PathRemoveBlanksW(LPWSTR pszPath); LWSTDAPI_(void) PathRemoveBlanksW(__inout LPWSTR pszPath);
LWSTDAPI_(void) PathRemoveExtensionA(LPSTR pszPath); LWSTDAPI_(void) PathRemoveExtensionA(__inout LPSTR pszPath);
LWSTDAPI_(void) PathRemoveExtensionW(LPWSTR pszPath); LWSTDAPI_(void) PathRemoveExtensionW(__inout LPWSTR pszPath);
LWSTDAPI_(BOOL) PathRemoveFileSpecA(LPSTR pszPath); LWSTDAPI_(BOOL) PathRemoveFileSpecA(__inout LPSTR pszPath);
LWSTDAPI_(BOOL) PathRemoveFileSpecW(LPWSTR pszPath); LWSTDAPI_(BOOL) PathRemoveFileSpecW(__inout LPWSTR pszPath);
LWSTDAPI_(BOOL) PathRenameExtensionA(LPSTR pszPath, LPCSTR pszExt); LWSTDAPI_(BOOL) PathRenameExtensionA(__inout_ecount(MAX_PATH) LPSTR pszPath,
LWSTDAPI_(BOOL) PathRenameExtensionW(LPWSTR pszPath, LPCWSTR pszExt); LPCSTR pszExt);
LWSTDAPI_(BOOL) PathSearchAndQualifyA(LPCSTR pszPath, LPSTR pszBuf, UINT cch LWSTDAPI_(BOOL) PathRenameExtensionW(__inout_ecount(MAX_PATH) LPWSTR pszPath
Buf); , LPCWSTR pszExt);
LWSTDAPI_(BOOL) PathSearchAndQualifyW(LPCWSTR pszPath, LPWSTR pszBuf, UINT c LWSTDAPI_(BOOL) PathSearchAndQualifyA(LPCSTR pszPath, __out_ecount(cchBuf) L
chBuf); PSTR pszBuf, UINT cchBuf);
LWSTDAPI_(void) PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath); LWSTDAPI_(BOOL) PathSearchAndQualifyW(LPCWSTR pszPath, __out_ecount(cchBuf)
LWSTDAPI_(void) PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR pszPath); LPWSTR pszBuf, UINT cchBuf);
LWSTDAPI_(void) PathSetDlgItemPathA(__in HWND hDlg, int id, LPCSTR pszPath);
LWSTDAPI_(void) PathSetDlgItemPathW(__in HWND hDlg, int id, LPCWSTR pszPath)
;
#ifdef USE_STRICT_CONST
LWSTDAPI_(LPCSTR) PathSkipRootA(LPCSTR pszPath);
LWSTDAPI_(LPCWSTR) PathSkipRootW(LPCWSTR pszPath);
#ifdef UNICODE
#define PathSkipRoot PathSkipRootW
#else
#define PathSkipRoot PathSkipRootA
#endif // !UNICODE
#else
LWSTDAPI_(LPSTR) PathSkipRootA(LPCSTR pszPath); LWSTDAPI_(LPSTR) PathSkipRootA(LPCSTR pszPath);
LWSTDAPI_(LPWSTR) PathSkipRootW(LPCWSTR pszPath); LWSTDAPI_(LPWSTR) PathSkipRootW(LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathSkipRoot PathSkipRootW #define PathSkipRoot PathSkipRootW
#else #else
#define PathSkipRoot PathSkipRootA #define PathSkipRoot PathSkipRootA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(void) PathStripPathA(LPSTR pszPath); #endif
LWSTDAPI_(void) PathStripPathW(LPWSTR pszPath); LWSTDAPI_(void) PathStripPathA(__inout LPSTR pszPath);
LWSTDAPI_(void) PathStripPathW(__inout LPWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
#define PathStripPath PathStripPathW #define PathStripPath PathStripPathW
#else #else
#define PathStripPath PathStripPathA #define PathStripPath PathStripPathA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathStripToRootA(LPSTR pszPath); LWSTDAPI_(BOOL) PathStripToRootA(__inout LPSTR pszPath);
LWSTDAPI_(BOOL) PathStripToRootW(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_(void) PathUnquoteSpacesA(LPSTR lpsz); LWSTDAPI_(BOOL) PathUnquoteSpacesA(__inout LPSTR lpsz);
LWSTDAPI_(void) PathUnquoteSpacesW(LPWSTR lpsz); LWSTDAPI_(BOOL) PathUnquoteSpacesW(__inout LPWSTR lpsz);
LWSTDAPI_(BOOL) PathMakeSystemFolderA(LPCSTR pszPath); LWSTDAPI_(BOOL) PathMakeSystemFolderA(LPCSTR pszPath);
LWSTDAPI_(BOOL) PathMakeSystemFolderW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathMakeSystemFolderW(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(LPCSTR pszPath);
LWSTDAPI_(BOOL) PathUnmakeSystemFolderW(LPCWSTR pszPath); LWSTDAPI_(BOOL) PathUnmakeSystemFolderW(LPCWSTR pszPath);
#ifdef UNICODE #ifdef UNICODE
skipping to change at line 617 skipping to change at line 751
#else #else
#define PathUnmakeSystemFolder PathUnmakeSystemFolderA #define PathUnmakeSystemFolder PathUnmakeSystemFolderA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(BOOL) PathIsSystemFolderA(LPCSTR pszPath, DWORD dwAttrb); LWSTDAPI_(BOOL) PathIsSystemFolderA(LPCSTR pszPath, DWORD dwAttrb);
LWSTDAPI_(BOOL) PathIsSystemFolderW(LPCWSTR pszPath, DWORD dwAttrb); LWSTDAPI_(BOOL) PathIsSystemFolderW(LPCWSTR pszPath, DWORD dwAttrb);
#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(LPSTR pszPath); LWSTDAPI_(void) PathUndecorateA(__inout LPSTR pszPath);
LWSTDAPI_(void) PathUndecorateW(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, LPSTR pszBuf, UINT c LWSTDAPI_(BOOL) PathUnExpandEnvStringsA(LPCSTR pszPath, __out_ecount(cchBuf)
chBuf); LPSTR pszBuf, UINT cchBuf);
LWSTDAPI_(BOOL) PathUnExpandEnvStringsW(LPCWSTR pszPath, LPWSTR pszBuf, UINT LWSTDAPI_(BOOL) PathUnExpandEnvStringsW(LPCWSTR pszPath, __out_ecount(cchBuf
cchBuf); ) LPWSTR pszBuf, 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
#define PathCompactPathEx PathCompactPathExW #define PathCompactPathEx PathCompactPathExW
#define PathCommonPrefix PathCommonPrefixW #define PathCommonPrefix PathCommonPrefixW
#define PathFindOnPath PathFindOnPathW #define PathFindOnPath PathFindOnPathW
#define PathGetCharType PathGetCharTypeW #define PathGetCharType PathGetCharTypeW
#define PathIsContentType PathIsContentTypeW #define PathIsContentType PathIsContentTypeW
#define PathIsHTMLFile PathIsHTMLFileW #define PathIsHTMLFile PathIsHTMLFileW
#define PathMakePretty PathMakePrettyW #define PathMakePretty PathMakePrettyW
#define PathMatchSpec PathMatchSpecW #define PathMatchSpec PathMatchSpecW
#if (_WIN32_IE >= _WIN32_IE_IE70)
#define PathMatchSpecEx PathMatchSpecExW
#endif // _WIN32_IE_IE70
#define PathParseIconLocation PathParseIconLocationW #define PathParseIconLocation PathParseIconLocationW
#define PathQuoteSpaces PathQuoteSpacesW #define PathQuoteSpaces PathQuoteSpacesW
#define PathRelativePathTo PathRelativePathToW #define PathRelativePathTo PathRelativePathToW
#define PathRemoveArgs PathRemoveArgsW #define PathRemoveArgs PathRemoveArgsW
#define PathRemoveBlanks PathRemoveBlanksW #define PathRemoveBlanks PathRemoveBlanksW
#define PathRemoveExtension PathRemoveExtensionW #define PathRemoveExtension PathRemoveExtensionW
#define PathRemoveFileSpec PathRemoveFileSpecW #define PathRemoveFileSpec PathRemoveFileSpecW
#define PathRenameExtension PathRenameExtensionW #define PathRenameExtension PathRenameExtensionW
#define PathSearchAndQualify PathSearchAndQualifyW #define PathSearchAndQualify PathSearchAndQualifyW
#define PathSetDlgItemPath PathSetDlgItemPathW #define PathSetDlgItemPath PathSetDlgItemPathW
skipping to change at line 667 skipping to change at line 804
#define PathCanonicalize PathCanonicalizeA #define PathCanonicalize PathCanonicalizeA
#define PathCompactPath PathCompactPathA #define PathCompactPath PathCompactPathA
#define PathCompactPathEx PathCompactPathExA #define PathCompactPathEx PathCompactPathExA
#define PathCommonPrefix PathCommonPrefixA #define PathCommonPrefix PathCommonPrefixA
#define PathFindOnPath PathFindOnPathA #define PathFindOnPath PathFindOnPathA
#define PathGetCharType PathGetCharTypeA #define PathGetCharType PathGetCharTypeA
#define PathIsContentType PathIsContentTypeA #define PathIsContentType PathIsContentTypeA
#define PathIsHTMLFile PathIsHTMLFileA #define PathIsHTMLFile PathIsHTMLFileA
#define PathMakePretty PathMakePrettyA #define PathMakePretty PathMakePrettyA
#define PathMatchSpec PathMatchSpecA #define PathMatchSpec PathMatchSpecA
#if (_WIN32_IE >= _WIN32_IE_IE70)
#define PathMatchSpecEx PathMatchSpecExA
#endif // _WIN32_IE_IE70
#define PathParseIconLocation PathParseIconLocationA #define PathParseIconLocation PathParseIconLocationA
#define PathQuoteSpaces PathQuoteSpacesA #define PathQuoteSpaces PathQuoteSpacesA
#define PathRelativePathTo PathRelativePathToA #define PathRelativePathTo PathRelativePathToA
#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
skipping to change at line 701 skipping to change at line 841
URL_SCHEME_FILE, URL_SCHEME_FILE,
URL_SCHEME_MK, URL_SCHEME_MK,
URL_SCHEME_HTTPS, URL_SCHEME_HTTPS,
URL_SCHEME_SHELL, URL_SCHEME_SHELL,
URL_SCHEME_SNEWS, URL_SCHEME_SNEWS,
URL_SCHEME_LOCAL, URL_SCHEME_LOCAL,
URL_SCHEME_JAVASCRIPT, URL_SCHEME_JAVASCRIPT,
URL_SCHEME_VBSCRIPT, URL_SCHEME_VBSCRIPT,
URL_SCHEME_ABOUT, URL_SCHEME_ABOUT,
URL_SCHEME_RES, URL_SCHEME_RES,
#if (_WIN32_IE >= _WIN32_IE_IE60)
URL_SCHEME_MSSHELLROOTED, URL_SCHEME_MSSHELLROOTED,
URL_SCHEME_MSSHELLIDLIST, URL_SCHEME_MSSHELLIDLIST,
URL_SCHEME_MSHELP, URL_SCHEME_MSHELP,
URL_SCHEME_MAXVALUE #endif // _WIN32_IE_IE60
#if (_WIN32_IE >= _WIN32_IE_IE70)
URL_SCHEME_MSSHELLDEVICE,
URL_SCHEME_WILDCARD,
#endif // _WIN32_IE_IE70
URL_SCHEME_SEARCH_MS,
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,
skipping to change at line 742 skipping to change at line 889
#define URL_DONT_UNESCAPE_EXTRA_INFO URL_DONT_ESCAPE_EXTRA_INFO #define URL_DONT_UNESCAPE_EXTRA_INFO URL_DONT_ESCAPE_EXTRA_INFO
#define URL_BROWSER_MODE URL_DONT_ESCAPE_EXTRA_INFO #define URL_BROWSER_MODE URL_DONT_ESCAPE_EXTRA_INFO
#define URL_ESCAPE_SPACES_ONLY 0x04000000 #define URL_ESCAPE_SPACES_ONLY 0x04000000
#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)
#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
#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(LPCSTR psz1, LPCSTR psz2, BOOL fIgnoreSlash) LWSTDAPI_(int) UrlCompareA(__in LPCSTR psz1, __in LPCSTR psz2, __in BOO
; L fIgnoreSlash);
LWSTDAPI_(int) UrlCompareW(LPCWSTR psz1, LPCWSTR psz2, BOOL fIgnoreSlas LWSTDAPI_(int) UrlCompareW(__in LPCWSTR psz1, __in LPCWSTR psz2, __in
h); BOOL fIgnoreSlash);
LWSTDAPI UrlCombineA(LPCSTR pszBase, LPCSTR pszRelative, LPSTR ps LWSTDAPI UrlCombineA(LPCSTR pszBase, LPCSTR pszRelative, __out_ec
zCombined, LPDWORD pcchCombined, DWORD dwFlags); ount_opt(*pcchCombined) LPSTR pszCombined, __inout LPDWORD pcchCombined, DWORD d
LWSTDAPI UrlCombineW(LPCWSTR pszBase, LPCWSTR pszRelative, LPWSTR wFlags);
pszCombined, LPDWORD pcchCombined, DWORD dwFlags); LWSTDAPI UrlCombineW(LPCWSTR pszBase, LPCWSTR pszRelative, __out_
LWSTDAPI UrlCanonicalizeA(LPCSTR pszUrl, LPSTR pszCanonicalized, ecount_opt(*pcchCombined) LPWSTR pszCombined, __inout LPDWORD pcchCombined, DWOR
LPDWORD pcchCanonicalized, DWORD dwFlags); D dwFlags);
LWSTDAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized LWSTDAPI UrlCanonicalizeA(LPCSTR pszUrl, __out_ecount(*pcchCanoni
, LPDWORD pcchCanonicalized, DWORD dwFlags); calized) LPSTR pszCanonicalized, __inout LPDWORD pcchCanonicalized, DWORD dwFlag
s);
LWSTDAPI UrlCanonicalizeW(LPCWSTR pszUrl, __out_ecount(*pcchCanon
icalized) LPWSTR pszCanonicalized, __inout LPDWORD pcchCanonicalized, DWORD dwFl
ags);
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, URLIS UrlIs); LWSTDAPI_(BOOL) UrlIsA(LPCSTR pszUrl, __in URLIS UrlIs);
LWSTDAPI_(BOOL) UrlIsW(LPCWSTR pszUrl, 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(LPSTR pszUrl, LPSTR pszUnescaped, LPDWORD p LWSTDAPI UrlUnescapeA(__inout LPSTR pszUrl, __out_ecount_opt(*pcc
cchUnescaped, DWORD dwFlags); hUnescaped) LPSTR pszUnescaped, __inout_opt LPDWORD pcchUnescaped, DWORD dwFlags
LWSTDAPI UrlUnescapeW(LPWSTR pszUrl, LPWSTR pszUnescaped, LPDWORD );
pcchUnescaped, DWORD dwFlags); LWSTDAPI UrlUnescapeW(__inout LPWSTR pszUrl, __out_ecount_opt(*pc
LWSTDAPI UrlEscapeA(LPCSTR pszUrl, LPSTR pszEscaped, LPDWORD pcch chUnescaped) LPWSTR pszUnescaped, __inout_opt LPDWORD pcchUnescaped, DWORD dwFla
Escaped, DWORD dwFlags); gs);
LWSTDAPI UrlEscapeW(LPCWSTR pszUrl, LPWSTR pszEscaped, LPDWORD pc LWSTDAPI UrlEscapeA(LPCSTR pszUrl, __out_ecount(*pcchEscaped) LPS
chEscaped, DWORD dwFlags); TR pszEscaped, __inout LPDWORD pcchEscaped, DWORD dwFlags);
LWSTDAPI UrlCreateFromPathA(LPCSTR pszPath, LPSTR pszUrl, LPDWORD LWSTDAPI UrlEscapeW(LPCWSTR pszUrl, __out_ecount(*pcchEscaped) LP
pcchUrl, DWORD dwFlags); WSTR pszEscaped, __inout LPDWORD pcchEscaped, DWORD dwFlags);
LWSTDAPI UrlCreateFromPathW(LPCWSTR pszPath, LPWSTR pszUrl, LPDWO LWSTDAPI UrlCreateFromPathA(LPCSTR pszPath, __out_ecount(*pcchUrl
RD pcchUrl, DWORD dwFlags); ) LPSTR pszUrl, __inout LPDWORD pcchUrl, DWORD dwFlags);
LWSTDAPI PathCreateFromUrlA(LPCSTR pszUrl, LPSTR pszPath, LPDWORD LWSTDAPI UrlCreateFromPathW(LPCWSTR pszPath, __out_ecount(*pcchUr
pcchPath, DWORD dwFlags); l) LPWSTR pszUrl, __inout LPDWORD pcchUrl, DWORD dwFlags);
LWSTDAPI PathCreateFromUrlW(LPCWSTR pszUrl, LPWSTR pszPath, LPDWO LWSTDAPI PathCreateFromUrlA(LPCSTR pszUrl, __out_ecount(*pcchPath
RD pcchPath, DWORD dwFlags); ) LPSTR pszPath, __inout LPDWORD pcchPath, DWORD dwFlags);
LWSTDAPI UrlHashA(LPCSTR pszUrl, LPBYTE pbHash, DWORD cbHash); LWSTDAPI PathCreateFromUrlW(LPCWSTR pszUrl, __out_ecount(*pcchPat
LWSTDAPI UrlHashW(LPCWSTR pszUrl, LPBYTE pbHash, DWORD cbHash); h) LPWSTR pszPath, __inout LPDWORD pcchPath, DWORD dwFlags);
LWSTDAPI UrlGetPartW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOu #if (_WIN32_IE >= _WIN32_IE_IE70)
t, DWORD dwPart, DWORD dwFlags); LWSTDAPI PathCreateFromUrlAlloc(LPCWSTR pszIn, __out LPWSTR *ppsz
LWSTDAPI UrlGetPartA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut, Out, DWORD dwFlags);
DWORD dwPart, DWORD dwFlags); #endif // _WIN32_IE_IE70
LWSTDAPI UrlApplySchemeA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcch LWSTDAPI UrlHashA(LPCSTR pszUrl, __out_ecount(cbHash) LPBYTE pbHa
Out, DWORD dwFlags); sh, DWORD cbHash);
LWSTDAPI UrlApplySchemeW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pc LWSTDAPI UrlHashW(LPCWSTR pszUrl, __out_ecount(cbHash) LPBYTE pbH
chOut, DWORD dwFlags); ash, DWORD cbHash);
LWSTDAPI HashData(LPBYTE pbData, DWORD cbData, LPBYTE pbHash, DWO LWSTDAPI UrlGetPartW(LPCWSTR pszIn, __out_ecount(*pcchOut) LPWSTR
RD cbHash); pszOut, __inout LPDWORD pcchOut, DWORD dwPart, DWORD dwFlags);
LWSTDAPI UrlGetPartA(LPCSTR pszIn, __out_ecount(*pcchOut) LPSTR p
szOut, __inout LPDWORD pcchOut, DWORD dwPart, 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 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);
#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
#define UrlIsFileUrl UrlIsFileUrlW #define UrlIsFileUrl UrlIsFileUrlW
#define UrlGetLocation UrlGetLocationW #define UrlGetLocation UrlGetLocationW
#define UrlUnescape UrlUnescapeW #define UrlUnescape UrlUnescapeW
#define UrlEscape UrlEscapeW #define UrlEscape UrlEscapeW
#define UrlCreateFromPath UrlCreateFromPathW #define UrlCreateFromPath UrlCreateFromPathW
#define PathCreateFromUrl PathCreateFromUrlW #define PathCreateFromUrl PathCreateFromUrlW
#define UrlHash UrlHashW #define UrlHash UrlHashW
#define UrlGetPart UrlGetPartW #define UrlGetPart UrlGetPartW
#define UrlApplyScheme UrlApplySchemeW #define UrlApplyScheme UrlApplySchemeW
#define UrlIs UrlIsW #define UrlIs UrlIsW
#define UrlFixup UrlFixupW
#else //!UNICODE #else //!UNICODE
#define UrlCompare UrlCompareA #define UrlCompare UrlCompareA
#define UrlCombine UrlCombineA #define UrlCombine UrlCombineA
#define UrlCanonicalize UrlCanonicalizeA #define UrlCanonicalize UrlCanonicalizeA
#define UrlIsOpaque UrlIsOpaqueA #define UrlIsOpaque UrlIsOpaqueA
#define UrlIsFileUrl UrlIsFileUrlA #define UrlIsFileUrl UrlIsFileUrlA
#define UrlGetLocation UrlGetLocationA #define UrlGetLocation UrlGetLocationA
#define UrlUnescape UrlUnescapeA #define UrlUnescape UrlUnescapeA
#define UrlEscape UrlEscapeA #define UrlEscape UrlEscapeA
#define UrlCreateFromPath UrlCreateFromPathA #define UrlCreateFromPath UrlCreateFromPathA
#define PathCreateFromUrl PathCreateFromUrlA #define PathCreateFromUrl PathCreateFromUrlA
#define UrlHash UrlHashA #define UrlHash UrlHashA
#define UrlGetPart UrlGetPartA #define UrlGetPart UrlGetPartA
#define UrlApplyScheme UrlApplySchemeA #define UrlApplyScheme UrlApplySchemeA
#define UrlIs UrlIsA #define UrlIs UrlIsA
// no UrlFixupA
#endif //UNICODE #endif //UNICODE
#define UrlEscapeSpaces(pszUrl, pszEscaped, pcchEscaped) UrlCanonicalize( pszUrl, pszEscaped, pcchEscaped, URL_ESCAPE_SPACES_ONLY |URL_DONT_ESCAPE_EXTRA_I NFO ) #define UrlEscapeSpaces(pszUrl, pszEscaped, pcchEscaped) UrlCanonicalize( pszUrl, pszEscaped, pcchEscaped, URL_ESCAPE_SPACES_ONLY |URL_DONT_ESCAPE_EXTRA_I NFO )
#define UrlUnescapeInPlace(pszUrl, dwFlags) UrlUnescape(pszU rl, NULL, NULL, dwFlags | URL_UNESCAPE_INPLACE) #define UrlUnescapeInPlace(pszUrl, dwFlags) UrlUnescape(pszU rl, NULL, NULL, dwFlags | URL_UNESCAPE_INPLACE)
#if (_WIN32_IE >= _WIN32_IE_IE50)
typedef struct tagPARSEDURLA {
DWORD cbSize;
// Pointers into the buffer that was provided to ParseURL
LPCSTR pszProtocol;
UINT cchProtocol;
LPCSTR pszSuffix;
UINT cchSuffix;
UINT nScheme; // One of URL_SCHEME_*
} PARSEDURLA, * PPARSEDURLA;
typedef struct tagPARSEDURLW {
DWORD cbSize;
// Pointers into the buffer that was provided to ParseURL
LPCWSTR pszProtocol;
UINT cchProtocol;
LPCWSTR pszSuffix;
UINT cchSuffix;
UINT nScheme; // One of URL_SCHEME_*
} PARSEDURLW, * PPARSEDURLW;
#ifdef UNICODE
typedef PARSEDURLW PARSEDURL;
typedef PPARSEDURLW PPARSEDURL;
#else
typedef PARSEDURLA PARSEDURL;
typedef PPARSEDURLA PPARSEDURL;
#endif // UNICODE
LWSTDAPI ParseURLA(LPCSTR pcszURL, __inout PARSEDURLA * ppu);
LWSTDAPI ParseURLW(LPCWSTR pcszURL, __inout PARSEDURLW * ppu);
#ifdef UNICODE
#define ParseURL ParseURLW
#else
#define ParseURL ParseURLA
#endif // !UNICODE
#endif // _WIN32_IE_IE50
#endif // NO_SHLWAPI_PATH #endif // NO_SHLWAPI_PATH
#ifndef NO_SHLWAPI_REG #ifndef NO_SHLWAPI_REG
// //
//=============== Registry Routines =================================== //=============== Registry Routines ===================================
// //
// SHDeleteEmptyKey mimics RegDeleteKey as it behaves on NT. // SHDeleteEmptyKey mimics RegDeleteKey as it behaves on NT.
// SHDeleteKey mimics RegDeleteKey as it behaves on Win95. // SHDeleteKey mimics RegDeleteKey as it behaves on Win95.
LWSTDAPI_(DWORD) SHDeleteEmptyKeyA(HKEY hkey, LPCSTR pszSubKey); LWSTDAPI_(LSTATUS) SHDeleteEmptyKeyA(__in HKEY hkey, __in_opt LPCSTR pszSubKey)
LWSTDAPI_(DWORD) SHDeleteEmptyKeyW(HKEY hkey, LPCWSTR pszSubKey); ;
LWSTDAPI_(LSTATUS) SHDeleteEmptyKeyW(__in HKEY hkey, __in_opt LPCWSTR pszSubKey
);
#ifdef UNICODE #ifdef UNICODE
#define SHDeleteEmptyKey SHDeleteEmptyKeyW #define SHDeleteEmptyKey SHDeleteEmptyKeyW
#else #else
#define SHDeleteEmptyKey SHDeleteEmptyKeyA #define SHDeleteEmptyKey SHDeleteEmptyKeyA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(DWORD) SHDeleteKeyA(HKEY hkey, LPCSTR pszSubKey); LWSTDAPI_(LSTATUS) SHDeleteKeyA(__in HKEY hkey, __in_opt LPCSTR pszSubKey);
LWSTDAPI_(DWORD) SHDeleteKeyW(HKEY hkey, LPCWSTR pszSubKey); LWSTDAPI_(LSTATUS) SHDeleteKeyW(__in HKEY hkey, __in_opt LPCWSTR pszSubKey);
#ifdef UNICODE #ifdef UNICODE
#define SHDeleteKey SHDeleteKeyW #define SHDeleteKey SHDeleteKeyW
#else #else
#define SHDeleteKey SHDeleteKeyA #define SHDeleteKey SHDeleteKeyA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(HKEY) SHRegDuplicateHKey(HKEY hkey); LWSTDAPI_(HKEY) SHRegDuplicateHKey(__in HKEY hkey);
// These functions open the key, get/set/delete the value, then close // These functions open the key, get/set/delete the value, then close
// the key. // the key.
LWSTDAPI_(DWORD) SHDeleteValueA(HKEY hkey, LPCSTR pszSubKey, LPCSTR pszValue) LWSTDAPI_(LSTATUS) SHDeleteValueA(__in HKEY hkey, __in_opt LPCSTR pszSubKey,
; __in_opt LPCSTR pszValue);
LWSTDAPI_(DWORD) SHDeleteValueW(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValu LWSTDAPI_(LSTATUS) SHDeleteValueW(__in HKEY hkey, __in_opt LPCWSTR pszSubKey,
e); __in_opt LPCWSTR pszValue);
#ifdef UNICODE #ifdef UNICODE
#define SHDeleteValue SHDeleteValueW #define SHDeleteValue SHDeleteValueW
#else #else
#define SHDeleteValue SHDeleteValueA #define SHDeleteValue SHDeleteValueA
#endif // !UNICODE #endif // !UNICODE
LWSTDAPI_(DWORD) SHGetValueA(HKEY hkey, LPCSTR pszSubKey, LPCSTR pszValue, DW LWSTDAPI_(LSTATUS) SHGetValueA(
ORD *pdwType, void *pvData, DWORD *pcbData); __in HKEY hkey,
LWSTDAPI_(DWORD) SHGetValueW(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValue, __in_opt LPCSTR pszSubKey,
DWORD *pdwType, void *pvData, DWORD *pcbData); __in_opt LPCSTR pszValue,
__out_opt DWORD *pdwType,
__out_bcount_opt(*pcbData) void *pvData,
__inout_opt DWORD *pcbData);
LWSTDAPI_(LSTATUS) SHGetValueW(
__in HKEY hkey,
__in_opt LPCWSTR pszSubKey,
__in_opt LPCWSTR pszValue,
__out_opt DWORD *pdwType,
__out_bcount_opt(*pcbData) void *pvData,
__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_(DWORD) SHSetValueA(HKEY hkey, LPCSTR pszSubKey, LPCSTR pszValue, DW LWSTDAPI_(LSTATUS) SHSetValueA(__in HKEY hkey, __in_opt LPCSTR pszSubKey, __i
ORD dwType, LPCVOID pvData, DWORD cbData); n_opt LPCSTR pszValue, __in DWORD dwType,
LWSTDAPI_(DWORD) SHSetValueW(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValue, __typefix(LPBYTE) __in_bcount_opt(cbData) LPCVOID pvData, __in_opt DWORD cbD
DWORD dwType, LPCVOID pvData, DWORD cbData); ata);
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);
#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)
// //
typedef DWORD SRRF; typedef int SRRF;
#define SRRF_RT_REG_NONE 0x00000001 // restrict type to REG_NONE (o ther data types will not return ERROR_SUCCESS) #define SRRF_RT_REG_NONE 0x00000001 // restrict type to REG_NONE (o ther data types will not return ERROR_SUCCESS)
#define SRRF_RT_REG_SZ 0x00000002 // restrict type to REG_SZ (o #define SRRF_RT_REG_SZ 0x00000002 // restrict type to REG_SZ (o
ther data types will not return ERROR_SUCCESS) ther data types will not return ERROR_SUCCESS) (automatically converts REG_EXPAN
#define SRRF_RT_REG_EXPAND_SZ 0x00000004 // restrict type to REG_EXPAND_SZ (o D_SZ to REG_SZ unless SRRF_NOEXPAND is specified)
ther data types will not return ERROR_SUCCESS) #define SRRF_RT_REG_EXPAND_SZ 0x00000004 // restrict type to REG_EXPAND_SZ (o
ther data types will not return ERROR_SUCCESS) (must specify SRRF_NOEXPAND or SH
RegGetValue will fail with ERROR_INVALID_PARAMETER)
#define SRRF_RT_REG_BINARY 0x00000008 // restrict type to REG_BINARY (o ther data types will not return ERROR_SUCCESS) #define SRRF_RT_REG_BINARY 0x00000008 // restrict type to REG_BINARY (o ther data types will not return ERROR_SUCCESS)
#define SRRF_RT_REG_DWORD 0x00000010 // restrict type to REG_DWORD (o ther data types will not return ERROR_SUCCESS) #define SRRF_RT_REG_DWORD 0x00000010 // restrict type to REG_DWORD (o ther data types will not return ERROR_SUCCESS)
#define SRRF_RT_REG_MULTI_SZ 0x00000020 // restrict type to REG_MULTI_SZ (o ther data types will not return ERROR_SUCCESS) #define SRRF_RT_REG_MULTI_SZ 0x00000020 // restrict type to REG_MULTI_SZ (o ther data types will not return ERROR_SUCCESS)
#define SRRF_RT_REG_QWORD 0x00000040 // restrict type to REG_QWORD (o ther data types will not return ERROR_SUCCESS) #define SRRF_RT_REG_QWORD 0x00000040 // restrict type to REG_QWORD (o ther data types will not return ERROR_SUCCESS)
#define SRRF_RT_DWORD (SRRF_RT_REG_BINARY | SRRF_RT_REG_DWORD) // rest rict type to *32-bit* SRRF_RT_REG_BINARY or SRRF_RT_REG_DWORD (other data types will not return ERROR_SUCCESS) #define SRRF_RT_DWORD (SRRF_RT_REG_BINARY | SRRF_RT_REG_DWORD) // rest rict type to *32-bit* SRRF_RT_REG_BINARY or SRRF_RT_REG_DWORD (other data types will not return ERROR_SUCCESS)
#define SRRF_RT_QWORD (SRRF_RT_REG_BINARY | SRRF_RT_REG_QWORD) // rest rict type to *64-bit* SRRF_RT_REG_BINARY or SRRF_RT_REG_DWORD (other data types will not return ERROR_SUCCESS) #define SRRF_RT_QWORD (SRRF_RT_REG_BINARY | SRRF_RT_REG_QWORD) // rest rict type to *64-bit* SRRF_RT_REG_BINARY or SRRF_RT_REG_DWORD (other data types will not return ERROR_SUCCESS)
#define SRRF_RT_ANY 0x0000ffff // no t ype restriction #define SRRF_RT_ANY 0x0000ffff // no t ype restriction
#define SRRF_RM_ANY 0x00000000 // no mode restriction (default is t o allow any mode) #define SRRF_RM_ANY 0x00000000 // no mode restriction (default is t o allow any mode)
#define SRRF_RM_NORMAL 0x00010000 // restrict system startup mode to " normal boot" (other startup modes will not return ERROR_SUCCESS) #define SRRF_RM_NORMAL 0x00010000 // restrict system startup mode to " normal boot" (other startup modes will not return ERROR_SUCCESS)
#define SRRF_RM_SAFE 0x00020000 // restrict system startup mode to " safe mode" (other startup modes will not return ERROR_SUCCESS) #define SRRF_RM_SAFE 0x00020000 // restrict system startup mode to " safe mode" (other startup modes will not return ERROR_SUCCESS)
#define SRRF_RM_SAFENETWORK 0x00040000 // restrict system startup mode to " safe mode with networking" (other startup modes will not return ERROR_SUCCESS) #define SRRF_RM_SAFENETWORK 0x00040000 // restrict system startup mode to " safe mode with networking" (other startup modes will not return ERROR_SUCCESS)
#define SRRF_NOEXPAND 0x10000000 // do not automatically expand envir onment strings if value is of type REG_EXPAND_SZ #define SRRF_NOEXPAND 0x10000000 // do not automatically expand envir onment strings if value is of type REG_EXPAND_SZ
#define SRRF_ZEROONFAILURE 0x20000000 // if pvData is not NULL, set conten t to all zeros on failure #define SRRF_ZEROONFAILURE 0x20000000 // if pvData is not NULL, set conten t to all zeros on failure
#define SRRF_NOVIRT 0x40000000 // if the requested key is virtualiz ed, then fail with ERROR_FILE_NOT_FOUND
// Function: // Function:
// //
// SHRegGetValue() // SHRegGetValue()
// //
// Purpose: // Purpose:
// //
// Gets a registry value. SHRegGetValue() provides the following benefits: // Gets a registry value. SHRegGetValue() provides the following benefits:
// //
// - data type checking // - data type checking
skipping to change at line 939 skipping to change at line 1145
// to calling this method, and using this opened key as // to calling this method, and using this opened key as
// hkey with pszSubKey set to NULL. // hkey with pszSubKey set to NULL.
// //
// pszValue - pointer to a null-terminated string specifying the name of // pszValue - pointer to a null-terminated string specifying the name of
// the value to query for data // the value to query for data
// //
// Note1: pszValue can be NULL or "". In either of these two // Note1: pszValue can be NULL or "". In either of these two
// cases, the data is retrieved from the unnamed or // cases, the data is retrieved from the unnamed or
// default value. // default value.
// //
// dwFlags - bitwise or of SRRF_ flags, which cannot be 0: at least one // srrfFlags - bitwise or of SRRF_ flags, which cannot be 0: at least one
// type restriction must be specified (SRRF_RT_...), or if any // type restriction must be specified (SRRF_RT_...), or if any
// type is desired then SRRF_RT_ANY can be specified // type is desired then SRRF_RT_ANY can be specified
// //
// Note1: SRRF_RT_ANY will allow any data type to be returned. // Note1: SRRF_RT_ANY will allow any data type to be returned.
// Note2: The following two type restrictions have special // Note2: The following two type restrictions have special
// handling semantics: // handling semantics:
// //
// SRRF_RT_DWORD == SRRF_RT_REG_BINARY | SRRF_RT_REG_DWO RD // SRRF_RT_DWORD == SRRF_RT_REG_BINARY | SRRF_RT_REG_DWO RD
// SRRF_RT_QWORD == SRRF_RT_REG_BINARY | SRRF_RT_REG_QWO RD // SRRF_RT_QWORD == SRRF_RT_REG_BINARY | SRRF_RT_REG_QWO RD
// //
skipping to change at line 1087 skipping to change at line 1293
// DWORD cbData = sizeof(dwData) // DWORD cbData = sizeof(dwData)
// if (ERROR_SUCCESS == SHRegGetValue(hkey, TEXT("MySubKey"), TEXT("MyValue "), SRRF_RT_DWORD, NULL, &dwData, &cbData)) // if (ERROR_SUCCESS == SHRegGetValue(hkey, TEXT("MySubKey"), TEXT("MyValue "), SRRF_RT_DWORD, NULL, &dwData, &cbData))
// { // {
// // use dwData (successful read) // // use dwData (successful read)
// } // }
// //
// 5) determine existence of "MyValue" value of an open hkey // 5) determine existence of "MyValue" value of an open hkey
// //
// BOOL bExists = ERROR_SUCCESS == SHRegGetValue(hkey, NULL, TEXT("MyValue" ), SRRF_RT_ANY, NULL, NULL, NULL) // BOOL bExists = ERROR_SUCCESS == SHRegGetValue(hkey, NULL, TEXT("MyValue" ), SRRF_RT_ANY, NULL, NULL, NULL)
LWSTDAPI_(LONG) SHRegGetValueA(HKEY hkey, LPCSTR pszSubKey, LPCSTR pszValue, LWSTDAPI_(LSTATUS) SHRegGetValueA(__in HKEY hkey, __in_opt LPCSTR pszSubKey, __i
SRRF dwFlags, DWORD *pdwType, void *pvData, DWORD *pcbData); n_opt LPCSTR pszValue,
LWSTDAPI_(LONG) SHRegGetValueW(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValu __in SRRF srrfFlags, __out_opt DWORD *pdwType, __out_bcount_part_opt(*pcbDat
e, SRRF dwFlags, DWORD *pdwType, void *pvData, DWORD *pcbData); a,*pcbData) __typefix(LPBYTE) void *pvData,
__inout_opt DWORD *pcbData);
LWSTDAPI_(LSTATUS) SHRegGetValueW(__in HKEY hkey, __in_opt LPCWSTR pszSubKey, __
in_opt LPCWSTR pszValue,
__in SRRF srrfFlags, __out_opt DWORD *pdwType, __out_bcount_part_opt(*pcbDat
a,*pcbData) __typefix(LPBYTE) void *pvData,
__inout_opt DWORD *pcbData);
#ifdef UNICODE #ifdef UNICODE
#define SHRegGetValue SHRegGetValueW #define SHRegGetValue SHRegGetValueW
#else #else
#define SHRegGetValue SHRegGetValueA #define SHRegGetValue SHRegGetValueA
#endif // !UNICODE #endif // !UNICODE
#endif // (_WIN32_IE >= 0x0602)
LWSTDAPI_(LSTATUS) SHRegSetValue(__in HKEY hkey, __in_opt LPCWSTR pszSubKey,
__in_opt LPCWSTR pszValue, __in SRRF srrfFlags,
__in DWORD dwType, __in_bcount_opt(cbData) LPCVOID pvData, __in_opt DWORD cb
Data);
LWSTDAPI_(LSTATUS) SHRegGetValueFromHKCUHKLM(__in PCWSTR pwszKey, __in_opt PCWST
R pwszValue, __in SRRF srrfFlags,
__out_opt DWORD* pdwType, __out_bcount_p
art_opt(*pcbData,*pcbData) __typefix(LPBYTE) void* pvData,
__inout_opt DWORD * pcbData);
STDAPI_(BOOL) SHRegGetBoolValueFromHKCUHKLM(__in PCWSTR pszKey, __in_opt PCWSTR
pszValue, __in BOOL fDefault);
#endif // (_WIN32_IE >= 0x0602)
// These functions behave just like RegQueryValueEx(), except if the data // These functions behave just like RegQueryValueEx(), except if the data
// type is REG_SZ, REG_EXPAND_SZ or REG_MULTI_SZ then the string is // type is REG_SZ, REG_EXPAND_SZ or REG_MULTI_SZ then the string is
// guaranteed to be properly null terminated. // guaranteed to be properly null terminated.
// //
// Additionally, if the data type is REG_EXPAND_SZ these functions will // Additionally, if the data type is REG_EXPAND_SZ these functions will
// go ahead and expand out the string, and "massage" the returned *pdwType // go ahead and expand out the string, and "massage" the returned *pdwType
// to be REG_SZ. // to be REG_SZ.
LWSTDAPI_(LSTATUS) SHQueryValueExA(
LWSTDAPI_(DWORD) SHQueryValueExA(HKEY hkey, LPCSTR pszValue, DWORD *pdwReserv __in HKEY hkey,
ed, DWORD *pdwType, void *pvData, DWORD *pcbData); __in_opt LPCSTR pszValue,
LWSTDAPI_(DWORD) SHQueryValueExW(HKEY hkey, LPCWSTR pszValue, DWORD *pdwReser __reserved DWORD *pdwReserved,
ved, DWORD *pdwType, void *pvData, DWORD *pcbData); __out_opt DWORD *pdwType,
__out_bcount_part_opt(*pcbData,*pcbData) void *pvData,
__inout_opt DWORD *pcbData);
// These functions behave just like RegQueryValueEx(), except if the data
// type is REG_SZ, REG_EXPAND_SZ or REG_MULTI_SZ then the string is
// guaranteed to be properly null terminated.
//
// Additionally, if the data type is REG_EXPAND_SZ these functions will
// go ahead and expand out the string, and "massage" the returned *pdwType
// to be REG_SZ.
LWSTDAPI_(LSTATUS) SHQueryValueExW(
__in HKEY hkey,
__in_opt LPCWSTR pszValue,
__reserved DWORD *pdwReserved,
__out_opt DWORD *pdwType,
__out_bcount_part_opt(*pcbData,*pcbData) void *pvData,
__inout_opt DWORD *pcbData);
#ifdef UNICODE #ifdef UNICODE
#define SHQueryValueEx SHQueryValueExW #define SHQueryValueEx SHQueryValueExW
#else #else
#define SHQueryValueEx SHQueryValueExA #define SHQueryValueEx SHQueryValueExA
#endif // !UNICODE #endif // !UNICODE
// Enumeration functions support. // Enumeration functions support.
LWSTDAPI_(LONG) SHEnumKeyExA(HKEY hkey, DWORD dwIndex, LPSTR pszName, LPDWOR LWSTDAPI_(LSTATUS) SHEnumKeyExA(__in HKEY hkey, DWORD dwIndex, __out_ecount(
D pcchName); *pcchName) LPSTR pszName, __inout LPDWORD pcchName);
LWSTDAPI_(LONG) SHEnumKeyExW(HKEY hkey, DWORD dwIndex, LPWSTR pszName, LPDWO LWSTDAPI_(LSTATUS) SHEnumKeyExW(__in HKEY hkey, DWORD dwIndex, __out_ecount(
RD pcchName); *pcchName) LPWSTR pszName, __inout LPDWORD pcchName);
LWSTDAPI_(LONG) SHEnumValueA(HKEY hkey, DWORD dwIndex, LPSTR pszValueName, L LWSTDAPI_(LSTATUS) SHEnumValueA(__in HKEY hkey, __in DWORD dwIndex, __out_ec
PDWORD pcchValueName, LPDWORD pdwType, void *pvData, LPDWORD pcbData); ount_opt(*pcchValueName) PSTR pszValueName,
LWSTDAPI_(LONG) SHEnumValueW(HKEY hkey, DWORD dwIndex, LPWSTR pszValueName, __inout_opt LPDWORD pcchValueName, __out_opt LPDWORD pdwType, __out_bcount_p
LPDWORD pcchValueName, LPDWORD pdwType, void *pvData, LPDWORD pcbData); art_opt(*pcbData,*pcbData) __typefix(LPBYTE) void *pvData,
LWSTDAPI_(LONG) SHQueryInfoKeyA(HKEY hkey, LPDWORD pcSubKeys, LPDWORD pcchMa __inout_opt LPDWORD pcbData);
xSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen); LWSTDAPI_(LSTATUS) SHEnumValueW(__in HKEY hkey, __in DWORD dwIndex, __out_ec
LWSTDAPI_(LONG) SHQueryInfoKeyW(HKEY hkey, LPDWORD pcSubKeys, LPDWORD pcchMa ount_opt(*pcchValueName) PWSTR pszValueName,
xSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen); __inout_opt LPDWORD pcchValueName, __out_opt LPDWORD pdwType, __out_bcount_p
art_opt(*pcbData,*pcbData) __typefix(LPBYTE) void *pvData,
__inout_opt LPDWORD pcbData);
LWSTDAPI_(LSTATUS) SHQueryInfoKeyA(__in HKEY hkey, __out_opt LPDWORD pcSubKe
ys, __out_opt LPDWORD pcchMaxSubKeyLen, __out_opt LPDWORD pcValues, __out_opt LP
DWORD pcchMaxValueNameLen);
LWSTDAPI_(LSTATUS) SHQueryInfoKeyW(__in HKEY hkey, __out_opt LPDWORD pcSubKe
ys, __out_opt LPDWORD pcchMaxSubKeyLen, __out_opt LPDWORD pcValues, __out_opt LP
DWORD pcchMaxValueNameLen);
// recursive key copy // recursive key copy
LWSTDAPI_(DWORD) SHCopyKeyA(HKEY hkeySrc, LPCSTR szSrcSubKey, HKEY hkeyDes LWSTDAPI_(LSTATUS) SHCopyKeyA(__in HKEY hkeySrc, __in_opt LPCSTR szSrcSubK
t, DWORD fReserved); ey, __in HKEY hkeyDest, __reserved DWORD fReserved);
LWSTDAPI_(DWORD) SHCopyKeyW(HKEY hkeySrc, LPCWSTR wszSrcSubKey, HKEY hkeyDes LWSTDAPI_(LSTATUS) SHCopyKeyW(__in HKEY hkeySrc, __in_opt LPCWSTR wszSrcSubK
t, DWORD fReserved); ey, __in HKEY hkeyDest, __reserved DWORD fReserved);
// Getting and setting file system paths with environment variables // Getting and setting file system paths with environment variables
LWSTDAPI_(DWORD) SHRegGetPathA(HKEY hKey, LPCSTR pcszSubKey, LPCSTR pcszValue LWSTDAPI_(LSTATUS) SHRegGetPathA(__in HKEY hKey, __in_opt LPCSTR pcszSubKey,
, LPSTR pszPath, DWORD dwFlags); __in_opt LPCSTR pcszValue, __out_ecount(MAX_PATH) LPSTR pszPath, __in DWORD dwFl
LWSTDAPI_(DWORD) SHRegGetPathW(HKEY hKey, LPCWSTR pcszSubKey, LPCWSTR pcszVal ags);
ue, LPWSTR pszPath, DWORD dwFlags); LWSTDAPI_(LSTATUS) SHRegGetPathW(__in HKEY hKey, __in_opt LPCWSTR pcszSubKey,
LWSTDAPI_(DWORD) SHRegSetPathA(HKEY hKey, LPCSTR pcszSubKey, LPCSTR pcszValue __in_opt LPCWSTR pcszValue, __out_ecount(MAX_PATH) LPWSTR pszPath, __in DWORD d
, LPCSTR pcszPath, DWORD dwFlags); wFlags);
LWSTDAPI_(DWORD) SHRegSetPathW(HKEY hKey, LPCWSTR pcszSubKey, LPCWSTR pcszVal LWSTDAPI_(LSTATUS) SHRegSetPathA(__in HKEY hKey, __in_opt LPCSTR pcszSubKey,
ue, LPCWSTR pcszPath, DWORD dwFlags); __in_opt LPCSTR pcszValue, __in LPCSTR pcszPath, __in DWORD dwFlags);
LWSTDAPI_(LSTATUS) SHRegSetPathW(__in HKEY hKey, __in_opt LPCWSTR pcszSubKey,
__in_opt LPCWSTR pcszValue, __in LPCWSTR pcszPath, __in DWORD dwFlags);
#ifdef UNICODE #ifdef UNICODE
#define SHEnumKeyEx SHEnumKeyExW #define SHEnumKeyEx SHEnumKeyExW
#define SHEnumValue SHEnumValueW #define SHEnumValue SHEnumValueW
#define SHQueryInfoKey SHQueryInfoKeyW #define SHQueryInfoKey SHQueryInfoKeyW
#define SHCopyKey SHCopyKeyW #define SHCopyKey SHCopyKeyW
#define SHRegGetPath SHRegGetPathW #define SHRegGetPath SHRegGetPathW
#define SHRegSetPath SHRegSetPathW #define SHRegSetPath SHRegSetPathW
#else #else
#define SHEnumKeyEx SHEnumKeyExA #define SHEnumKeyEx SHEnumKeyExA
skipping to change at line 1182 skipping to change at line 1422
#define SHREGSET_HKCU 0x00000001 // Write to HKCU if empty. #define SHREGSET_HKCU 0x00000001 // Write to HKCU if empty.
#define SHREGSET_FORCE_HKCU 0x00000002 // Write to HKCU. #define SHREGSET_FORCE_HKCU 0x00000002 // Write to HKCU.
#define SHREGSET_HKLM 0x00000004 // Write to HKLM if empty. #define SHREGSET_HKLM 0x00000004 // Write to HKLM if empty.
#define SHREGSET_FORCE_HKLM 0x00000008 // Write to HKLM. #define SHREGSET_FORCE_HKLM 0x00000008 // Write to HKLM.
#define SHREGSET_DEFAULT (SHREGSET_FORCE_HKCU | SHREGSET_HKLM) // Default is SHREGSET_FORCE_HKCU | SHREGSET_HKLM. #define SHREGSET_DEFAULT (SHREGSET_FORCE_HKCU | SHREGSET_HKLM) // Default is SHREGSET_FORCE_HKCU | SHREGSET_HKLM.
typedef HANDLE HUSKEY; // HUSKEY is a Handle to a User Specific KEY. typedef HANDLE HUSKEY; // HUSKEY is a Handle to a User Specific KEY.
typedef HUSKEY *PHUSKEY; typedef HUSKEY *PHUSKEY;
LWSTDAPI_(LONG) SHRegCreateUSKeyA(LPCSTR pszPath, REGSAM samDesired, HUSK LWSTDAPI_(LSTATUS) SHRegCreateUSKeyA(__in LPCSTR pszPath, __in REGSAM samDes
EY hRelativeUSKey, PHUSKEY phNewUSKey, DWORD dwFlags); ired, __in_opt HUSKEY hRelativeUSKey, __out PHUSKEY phNewUSKey, __in DWORD dwFla
LWSTDAPI_(LONG) SHRegCreateUSKeyW(LPCWSTR pwzPath, REGSAM samDesired, HUS gs);
KEY hRelativeUSKey, PHUSKEY phNewUSKey, DWORD dwFlags); LWSTDAPI_(LSTATUS) SHRegCreateUSKeyW(__in LPCWSTR pwzPath, __in REGSAM samDe
LWSTDAPI_(LONG) SHRegOpenUSKeyA(LPCSTR pszPath, REGSAM samDesired, HUSKEY sired, __in_opt HUSKEY hRelativeUSKey, __out PHUSKEY phNewUSKey, __in DWORD dwFl
hRelativeUSKey, PHUSKEY phNewUSKey, BOOL fIgnoreHKCU); ags);
LWSTDAPI_(LONG) SHRegOpenUSKeyW(LPCWSTR pwzPath, REGSAM samDesired, HUSKE LWSTDAPI_(LSTATUS) SHRegOpenUSKeyA(__in LPCSTR pszPath, __in REGSAM samDesir
Y hRelativeUSKey, PHUSKEY phNewUSKey, BOOL fIgnoreHKCU); ed, __in_opt HUSKEY hRelativeUSKey, __out PHUSKEY phNewUSKey, __in BOOL fIgnoreH
LWSTDAPI_(LONG) SHRegQueryUSValueA(HUSKEY hUSKey, LPCSTR pszValue, LPDWOR KCU);
D pdwType, void *pvData, LPDWORD pcbData, BOOL fIgnoreHKCU, void *pvDefaultData, LWSTDAPI_(LSTATUS) SHRegOpenUSKeyW(__in LPCWSTR pwzPath, __in REGSAM samDesi
DWORD dwDefaultDataSize); red, __in_opt HUSKEY hRelativeUSKey, __out PHUSKEY phNewUSKey, __in BOOL fIgnore
LWSTDAPI_(LONG) SHRegQueryUSValueW(HUSKEY hUSKey, LPCWSTR pwzValue, LPDWO HKCU);
RD pdwType, void *pvData, LPDWORD pcbData, BOOL fIgnoreHKCU, void *pvDefaultData LWSTDAPI_(LSTATUS) SHRegQueryUSValueA(
, DWORD dwDefaultDataSize); __in HUSKEY hUSKey,
LWSTDAPI_(LONG) SHRegWriteUSValueA(HUSKEY hUSKey, LPCSTR pszValue, DWORD __in_opt LPCSTR pszValue,
dwType, const void *pvData, DWORD cbData, DWORD dwFlags); __inout_opt DWORD * pdwType,
LWSTDAPI_(LONG) SHRegWriteUSValueW(HUSKEY hUSKey, LPCWSTR pwzValue, DWORD __out_bcount_part_opt(*pcbData, *pcbData) void * pvData,
dwType, const void *pvData, DWORD cbData, DWORD dwFlags); __inout_opt DWORD * pcbData,
LWSTDAPI_(LONG) SHRegDeleteUSValueA(HUSKEY hUSKey, LPCSTR pszValue, SHREG __in BOOL fIgnoreHKCU,
DEL_FLAGS delRegFlags); __in_bcount_opt(dwDefaultDataSize) void * pvDefaultData,
LWSTDAPI_(LONG) SHRegDeleteEmptyUSKeyW(HUSKEY hUSKey, LPCWSTR pwzSubKey, __in_opt DWORD dwDefaultDataSize);
SHREGDEL_FLAGS delRegFlags); LWSTDAPI_(LSTATUS) SHRegQueryUSValueW(
LWSTDAPI_(LONG) SHRegDeleteEmptyUSKeyA(HUSKEY hUSKey, LPCSTR pszSubKey, S __in HUSKEY hUSKey,
HREGDEL_FLAGS delRegFlags); __in_opt LPCWSTR pszValue,
LWSTDAPI_(LONG) SHRegDeleteUSValueW(HUSKEY hUSKey, LPCWSTR pwzValue, SHRE __inout_opt DWORD * pdwType,
GDEL_FLAGS delRegFlags); __out_bcount_part_opt(*pcbData, *pcbData) void * pvData,
LWSTDAPI_(LONG) SHRegEnumUSKeyA(HUSKEY hUSKey, DWORD dwIndex, LPSTR pszNa __inout_opt DWORD * pcbData,
me, LPDWORD pcchName, SHREGENUM_FLAGS enumRegFlags); __in BOOL fIgnoreHKCU,
LWSTDAPI_(LONG) SHRegEnumUSKeyW(HUSKEY hUSKey, DWORD dwIndex, LPWSTR pwzN __in_bcount_opt(dwDefaultDataSize) void * pvDefaultData,
ame, LPDWORD pcchName, SHREGENUM_FLAGS enumRegFlags); __in_opt DWORD dwDefaultDataSize);
LWSTDAPI_(LONG) SHRegEnumUSValueA(HUSKEY hUSkey, DWORD dwIndex, LPSTR psz LWSTDAPI_(LSTATUS) SHRegWriteUSValueA(__in HUSKEY hUSKey, __in LPCSTR pszVal
ValueName, LPDWORD pcchValueName, LPDWORD pdwType, void *pvData, LPDWORD pcbData ue, __in DWORD dwType, __in_bcount(cbData) const void *pvData, __in DWORD cbData
, SHREGENUM_FLAGS enumRegFlags); , __in DWORD dwFlags);
LWSTDAPI_(LONG) SHRegEnumUSValueW(HUSKEY hUSkey, DWORD dwIndex, LPWSTR ps LWSTDAPI_(LSTATUS) SHRegWriteUSValueW(__in HUSKEY hUSKey, __in LPCWSTR pwzVa
zValueName, LPDWORD pcchValueName, LPDWORD pdwType, void *pvData, LPDWORD pcbDat lue, __in DWORD dwType, __in_bcount(cbData) const void *pvData, __in DWORD cbDat
a, SHREGENUM_FLAGS enumRegFlags); a, __in DWORD dwFlags);
LWSTDAPI_(LONG) SHRegQueryInfoUSKeyA(HUSKEY hUSKey, LPDWORD pcSubKeys, LP LWSTDAPI_(LSTATUS) SHRegDeleteUSValueA(__in HUSKEY hUSKey, __in LPCSTR pszVa
DWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen, SHREGENUM lue, __in SHREGDEL_FLAGS delRegFlags);
_FLAGS enumRegFlags); LWSTDAPI_(LSTATUS) SHRegDeleteUSValueW(__in HUSKEY hUSKey, __in LPCWSTR pwzV
LWSTDAPI_(LONG) SHRegQueryInfoUSKeyW(HUSKEY hUSKey, LPDWORD pcSubKeys, LP alue, __in SHREGDEL_FLAGS delRegFlags);
DWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen, SHREGENUM LWSTDAPI_(LSTATUS) SHRegDeleteEmptyUSKeyW(__in HUSKEY hUSKey, __in LPCWSTR p
_FLAGS enumRegFlags); wzSubKey, __in SHREGDEL_FLAGS delRegFlags);
LWSTDAPI_(LONG) SHRegCloseUSKey(HUSKEY hUSKey); 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) 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,
__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);
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_bcount_opt(*pcbData) void *pvData, __inout_opt LPDWORD pcbData, __in S
HREGENUM_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) 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.
LWSTDAPI_(LONG) SHRegGetUSValueA(LPCSTR pszSubKey, LPCSTR pszValue, LPDWO STDAPI_(LSTATUS) SHRegGetUSValueA(
RD pdwType, void * pvData, LPDWORD pcbData, BOOL fIgnoreHKCU, void *pvDefaultDat __in LPCSTR pszSubKey,
a, DWORD dwDefaultDataSize); __in_opt LPCSTR pszValue,
LWSTDAPI_(LONG) SHRegGetUSValueW(LPCWSTR pwzSubKey, LPCWSTR pwzValue, LPD __inout_opt DWORD *pdwType,
WORD pdwType, void * pvData, LPDWORD pcbData, BOOL fIgnoreHKCU, void *pvDefaultD __out_bcount_part_opt(*pcbData, *pcbData) void *pvData,
ata, DWORD dwDefaultDataSize); __inout_opt DWORD *pcbData,
LWSTDAPI_(LONG) SHRegSetUSValueA(LPCSTR pszSubKey, LPCSTR pszValue, DWORD __in BOOL fIgnoreHKCU,
dwType, const void *pvData, DWORD cbData, DWORD dwFlags); __in_bcount_opt(dwDefaultDataSize) void *pvDefaultData,
LWSTDAPI_(LONG) SHRegSetUSValueW(LPCWSTR pwzSubKey, LPCWSTR pwzValue, DWO __in_opt DWORD dwDefaultDataSize);
RD dwType, const void *pvData, DWORD cbData, DWORD dwFlags); STDAPI_(LSTATUS) SHRegGetUSValueW(
LWSTDAPI_(int) SHRegGetIntW(HKEY hk, LPCWSTR pwzKey, int iDefault); __in LPCWSTR pszSubKey,
__in_opt LPCWSTR pszValue,
__inout_opt DWORD *pdwType,
__out_bcount_part_opt(*pcbData, *pcbData) void *pvData,
__inout_opt DWORD *pcbData,
__in BOOL fIgnoreHKCU,
__in_bcount_opt(dwDefaultDataSize) void *pvDefaultData,
__in_opt 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) 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);
#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
#define SHRegDeleteEmptyUSKey SHRegDeleteEmptyUSKeyW #define SHRegDeleteEmptyUSKey SHRegDeleteEmptyUSKeyW
#define SHRegEnumUSKey SHRegEnumUSKeyW #define SHRegEnumUSKey SHRegEnumUSKeyW
#define SHRegEnumUSValue SHRegEnumUSValueW #define SHRegEnumUSValue SHRegEnumUSValueW
skipping to change at line 1236 skipping to change at line 1512
#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(LPCSTR pszSubKey, LPCSTR pszValue, BOOL fIg LWSTDAPI_(BOOL) SHRegGetBoolUSValueA(__in LPCSTR pszSubKey, __in LPCSTR pszValue
noreHKCU, BOOL fDefault); , __in BOOL fIgnoreHKCU, __in BOOL fDefault);
LWSTDAPI_(BOOL) SHRegGetBoolUSValueW(LPCWSTR pszSubKey, LPCWSTR pszValue, BOOL f LWSTDAPI_(BOOL) SHRegGetBoolUSValueW(__in LPCWSTR pszSubKey, __in LPCWSTR pszVal
IgnoreHKCU, BOOL fDefault); ue, __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 #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 {
skipping to change at line 1265 skipping to change at line 1540
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
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
}; };
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)
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
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)
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
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_( IQueryAssociations, IUnknown ) 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_ REFIID riid, void **ppv) PURE;
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 wnd) PURE; STDMETHOD (Init)(THIS_ ASSOCF flags, LPCWSTR pszAssoc, HKEY hkProgid, HWND h wnd) PURE;
STDMETHOD (GetString)(THIS_ ASSOCF flags, ASSOCSTR str, LPCWSTR pszExtra, LP STDMETHOD (GetString)(THIS_ ASSOCF flags, ASSOCSTR str, LPCWSTR pszExtra, __
WSTR pszOut, DWORD *pcchOut) PURE; out_ecount_opt(*pcchOut) LPWSTR pszOut, __inout DWORD *pcchOut) PURE;
STDMETHOD (GetKey)(THIS_ ASSOCF flags, ASSOCKEY key, LPCWSTR pszExtra, HKEY STDMETHOD (GetKey)(THIS_ ASSOCF flags, ASSOCKEY key, LPCWSTR pszExtra, __out
*phkeyOut) PURE; HKEY *phkeyOut) PURE;
STDMETHOD (GetData)(THIS_ ASSOCF flags, ASSOCDATA data, LPCWSTR pszExtra, LP STDMETHOD (GetData)(THIS_ ASSOCF flags, ASSOCDATA data, LPCWSTR pszExtra, __
VOID pvOut, DWORD *pcbOut) PURE; out_bcount_opt(*pcbOut) void * pvOut, __inout_opt DWORD *pcbOut) PURE;
STDMETHOD (GetEnum)(THIS_ ASSOCF flags, ASSOCENUM assocenum, LPCWSTR pszExtr STDMETHOD (GetEnum)(THIS_ ASSOCF flags, ASSOCENUM assocenum, LPCWSTR pszExtr
a, REFIID riid, LPVOID *ppvOut) PURE; a, REFIID riid, __out void **ppvOut) PURE;
}; };
LWSTDAPI AssocCreate(CLSID clsid, REFIID riid, LPVOID *ppv); // use CLSID_QueryAssociations for clsid, object implements IQueryAssociations
// AssocCreateForClasses() is the more functional version of this API
LWSTDAPI AssocCreate(__in CLSID clsid, __in REFIID riid, __out void **ppv);
// wrappers for the interface // wrappers for the interface
LWSTDAPI AssocQueryStringA(ASSOCF flags, ASSOCSTR str, LPCSTR pszAssoc, LPCSTR p szExtra, LPSTR pszOut, DWORD *pcchOut); 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);
// wrappers for the interface // wrappers for the interface
LWSTDAPI AssocQueryStringW(ASSOCF flags, ASSOCSTR str, LPCWSTR pszAssoc, LPCWSTR pszExtra, LPWSTR pszOut, DWORD *pcchOut); LWSTDAPI AssocQueryStringW(__in ASSOCF flags, __in ASSOCSTR str, __in LPCWSTR ps zAssoc, __in_opt LPCWSTR pszExtra, __out_ecount(*pcchOut) LPWSTR pszOut, __inout 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(ASSOCF flags, ASSOCSTR str, HKEY hkAssoc, LPCSTR LWSTDAPI AssocQueryStringByKeyA(__in ASSOCF flags, __in ASSOCSTR str, __in HKEY
pszExtra, LPSTR pszOut, DWORD *pcchOut); hkAssoc, __in_opt LPCSTR pszExtra, __out_ecount(*pcchOut) LPSTR pszOut, __inout
LWSTDAPI AssocQueryStringByKeyW(ASSOCF flags, ASSOCSTR str, HKEY hkAssoc, LPCWST DWORD *pcchOut);
R pszExtra, LPWSTR pszOut, DWORD *pcchOut); LWSTDAPI AssocQueryStringByKeyW(__in ASSOCF flags, __in ASSOCSTR str, __in HKEY
hkAssoc, __in_opt LPCWSTR pszExtra, __out_ecount(*pcchOut) LPWSTR pszOut, __inou
t 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(ASSOCF flags, ASSOCKEY key, LPCSTR pszAssoc, LPCSTR pszE LWSTDAPI AssocQueryKeyA(__in ASSOCF flags, __in ASSOCKEY key, __in LPCSTR pszAss
xtra, HKEY *phkeyOut); oc, __in_opt LPCSTR pszExtra, __out HKEY *phkeyOut);
LWSTDAPI AssocQueryKeyW(ASSOCF flags, ASSOCKEY key, LPCWSTR pszAssoc, LPCWSTR ps LWSTDAPI AssocQueryKeyW(__in ASSOCF flags, __in ASSOCKEY key, __in LPCWSTR pszAs
zExtra, HKEY *phkeyOut); soc, __in_opt LPCWSTR pszExtra, __out HKEY *phkeyOut);
#ifdef UNICODE #ifdef UNICODE
#define AssocQueryKey AssocQueryKeyW #define AssocQueryKey AssocQueryKeyW
#else #else
#define AssocQueryKey AssocQueryKeyA #define AssocQueryKey AssocQueryKeyA
#endif // !UNICODE #endif // !UNICODE
#if (_WIN32_IE >= 0x0601) #if (_WIN32_IE >= 0x0601)
// AssocIsDangerous() checks a file type to determine whether it is "Dangerous" // AssocIsDangerous() checks a file type to determine whether it is "Dangerous"
// this maps to the IE download dialog's forcing a prompt to open or save. // this maps to the IE download dialog's forcing a prompt to open or save.
// dangerous file types should be handled more carefully than other file ty pes. // dangerous file types should be handled more carefully than other file ty pes.
skipping to change at line 1371 skipping to change at line 1653
// //
// Returns: TRUE if the file type is dangerous. // Returns: TRUE if the file type is dangerous.
// //
// NOTES: // NOTES:
// //
// this API first checks a hardcoded list of known dangerous types. // this API first checks a hardcoded list of known dangerous types.
// then it checks the editflags for the file type looking for the FTA_Alway sUnsafe bit. // then it checks the editflags for the file type looking for the FTA_Alway sUnsafe bit.
// then it checks Safer policies. // then it checks Safer policies.
// //
LWSTDAPI_(BOOL) AssocIsDangerous(LPCWSTR pszAssoc); LWSTDAPI_(BOOL) AssocIsDangerous(LPCWSTR pszAssoc);
#endif // (_WIN32_IE >= 0x0601)
#if (_WIN32_IE >= 0x0603)
// PERCEIVED types:
typedef enum {
PERCEIVED_TYPE_CUSTOM = -3,
PERCEIVED_TYPE_UNSPECIFIED = -2,
PERCEIVED_TYPE_FOLDER = -1,
PERCEIVED_TYPE_UNKNOWN = 0,
PERCEIVED_TYPE_TEXT,
PERCEIVED_TYPE_IMAGE,
PERCEIVED_TYPE_AUDIO,
PERCEIVED_TYPE_VIDEO,
PERCEIVED_TYPE_COMPRESSED,
PERCEIVED_TYPE_DOCUMENT,
PERCEIVED_TYPE_SYSTEM,
PERCEIVED_TYPE_APPLICATION
} PERCEIVED;
#define PERCEIVEDFLAG_UNDEFINED 0x0000
#define PERCEIVEDFLAG_SOFTCODED 0x0001
#define PERCEIVEDFLAG_HARDCODED 0x0002
#define PERCEIVEDFLAG_NATIVESUPPORT 0x0004
#define PERCEIVEDFLAG_GDIPLUS 0x0010
#define PERCEIVEDFLAG_WMSDK 0x0020
#define PERCEIVEDFLAG_ZIPFOLDER 0x0040
typedef DWORD PERCEIVEDFLAG; #endif // _WIN32_IE >= 0x0601
#if (_WIN32_IE >= _WIN32_IE_IE60SP2)
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 // (_WIN32_IE >= 0x0603) #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(HKEY hkey, LPCSTR pszSubkey, LPCSTR LWSTDAPI_(struct IStream *) SHOpenRegStreamA(__in HKEY hkey, LPCSTR pszSubkey, L
pszValue, DWORD grfMode); PCSTR pszValue, DWORD grfMode);
LWSTDAPI_(struct IStream *) SHOpenRegStreamW(HKEY hkey, LPCWSTR pszSubkey, LPCWS LWSTDAPI_(struct IStream *) SHOpenRegStreamW(__in HKEY hkey, LPCWSTR pszSubkey,
TR pszValue, DWORD grfMode); LPCWSTR pszValue, 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(HKEY hkey, LPCSTR pszSubkey, LPCST LWSTDAPI_(struct IStream *) SHOpenRegStream2A(__in HKEY hkey, LPCSTR pszSubkey,
R pszValue, DWORD grfMode); LPCSTR pszValue, DWORD grfMode);
LWSTDAPI_(struct IStream *) SHOpenRegStream2W(HKEY hkey, LPCWSTR pszSubkey, LPCW LWSTDAPI_(struct IStream *) SHOpenRegStream2W(__in HKEY hkey, LPCWSTR pszSubkey,
STR pszValue, DWORD grfMode); LPCWSTR pszValue, 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, struct IStream **p LWSTDAPI SHCreateStreamOnFileA(LPCSTR pszFile, DWORD grfMode, __out struct IStre
pstm); am **ppstm);
LWSTDAPI SHCreateStreamOnFileW(LPCWSTR pszFile, DWORD grfMode, struct IStream ** LWSTDAPI SHCreateStreamOnFileW(LPCWSTR pszFile, DWORD grfMode, __out struct IStr
ppstm); eam **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, struct IStream * pstmTemplate, struct IStream **ppstm); LWSTDAPI SHCreateStreamOnFileEx(LPCWSTR pszFile, DWORD grfMode, DWORD dwAttribut es, BOOL fCreate, __in_opt struct IStream * pstmTemplate, __out struct IStream * *ppstm);
#endif // (_WIN32_IE >= 0x0600) #endif // (_WIN32_IE >= 0x0600)
#if (_WIN32_IE >= _WIN32_IE_IE501)
LWSTDAPI_(struct IStream *) SHCreateMemStream(__in_bcount_opt(cbInit) const BYTE
*pInit, UINT cbInit);
#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(LPSTR psz, DWORD* pcch); LWSTDAPI GetAcceptLanguagesA(__out_ecount(*pcch) LPSTR psz, LPDWORD pcch);
LWSTDAPI GetAcceptLanguagesW(LPWSTR psz, DWORD* pcch); LWSTDAPI GetAcceptLanguagesW(__out_ecount(*pcch) LPWSTR psz, LPDWORD 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 >= 0x0601) #if (_WIN32_IE < _WIN32_IE_IE70) && !defined(NO_SHLWAPI_STOPWATCH)
#define SPMODE_SHELL 0x00000001
#define SPMODE_DEBUGOUT 0x00000002
#define SPMODE_TEST 0x00000004
#define SPMODE_BROWSER 0x00000008
#define SPMODE_FLUSH 0x00000010
#define SPMODE_EVENT 0x00000020
#define SPMODE_MSVM 0x00000040
#define SPMODE_FORMATTEXT 0x00000080
#define SPMODE_PROFILE 0x00000100
#define SPMODE_DEBUGBREAK 0x00000200
#define SPMODE_MSGTRACE 0x00000400
#define SPMODE_PERFTAGS 0x00000800
#define SPMODE_MEMWATCH 0x00001000
#define SPMODE_DBMON 0x00002000
#define SPMODE_MULTISTOP 0x00004000
#ifndef NO_ETW_TRACING
#define SPMODE_EVENTTRACE 0x00008000 // Event Tracing for Windows Enabled
#endif
DWORD WINAPI StopWatchMode(void);
DWORD WINAPI StopWatchFlush(void);
#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)
LWSTDAPI_(void) IUnknown_Set(__deref_inout IUnknown ** ppunk, __in_opt IUnkn
own * punk);
LWSTDAPI_(void) IUnknown_AtomicRelease(__inout_opt void ** ppunk);
LWSTDAPI IUnknown_GetWindow(__in IUnknown* punk, __out HWND* phwnd);
LWSTDAPI IUnknown_SetSite(__in IUnknown *punk, __in_opt IUnknown *punkSite);
LWSTDAPI IUnknown_GetSite(__in IUnknown *punk, __in REFIID riid, __deref_out
void **ppv);
LWSTDAPI IUnknown_QueryService(__in_opt IUnknown* punk, __in REFGUID guidSer
vice, __in REFIID riid, __deref_out void ** ppvOut);
#endif // (_WIN32_IE >= _WIN32_IE_IE501)
#if (_WIN32_IE >= _WIN32_IE_IE501)
#if !defined(__cplusplus) && defined(COBJMACROS)
#undef IStream_Read
#undef IStream_Write
#endif
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_Reset(__in IStream *pstm);
LWSTDAPI IStream_Size(__in IStream *pstm, __out ULARGE_INTEGER *pui);
LWSTDAPI ConnectToConnectionPoint(__in_opt IUnknown* punk, __in REFIID riidEvent
, __in BOOL fConnect, __in IUnknown* punkTarget, __out DWORD* pdwCookie, __deref
_out_opt IConnectionPoint** ppcpOut);
#endif // (_WIN32_IE >= _WIN32_IE_IE501)
#if (_WIN32_IE >= _WIN32_IE_IE60)
LWSTDAPI IStream_ReadPidl(__in IStream *pstm, __deref_out PIDLIST_RELATIVE *ppid
lOut);
LWSTDAPI IStream_WritePidl(__in IStream *pstm, __in PCUIDLIST_RELATIVE pidlWrite
);
#endif // (_WIN32_IE >= _WIN32_IE_IE60)
#if (_WIN32_IE >= _WIN32_IE_IE70)
LWSTDAPI IStream_ReadStr(__in IStream *pstm, __deref_out PWSTR *ppsz);
LWSTDAPI IStream_WriteStr(__in IStream *pstm, __in PCWSTR psz);
LWSTDAPI IStream_Copy(__in IStream *pstmFrom, __in IStream *pstmTo, DWORD cb);
#endif // (_WIN32_IE >= _WIN32_IE_IE70)
#if (_WIN32_IE >= 0x0600)
#define SHGVSPB_PERUSER 0x00000001 // must have one of PERUSER or AL LUSERS #define SHGVSPB_PERUSER 0x00000001 // must have one of PERUSER or AL LUSERS
#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_GLOBALDEAFAULTS (SHGVSPB_ALLUSERS | SHGVSPB_ALLFOLDERS)
LWSTDAPI SHGetViewStatePropertyBag(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD LWSTDAPI SHGetViewStatePropertyBag(__in_opt PCIDLIST_ABSOLUTE pidl, __in_opt LPC
dwFlags, REFIID riid, void** ppv); WSTR pszBagName, __in DWORD dwFlags, __in REFIID riid, __deref_out void** ppv);
#endif // (_WIN32_IE >= 0x0601) #endif // (_WIN32_IE >= 0x0600)
// SHFormatDateTime flags
// (FDTF_SHORTDATE and FDTF_LONGDATE are mutually exclusive, as is
// FDTF_SHORTIME and FDTF_LONGTIME.)
//
#define FDTF_SHORTTIME 0x00000001 // eg, "7:48 PM"
#define FDTF_SHORTDATE 0x00000002 // eg, "3/29/98"
#define FDTF_DEFAULT (FDTF_SHORTDATE | FDTF_SHORTTIME) // eg, "3/29/9
8 7:48 PM"
#define FDTF_LONGDATE 0x00000004 // eg, "Monday, March 29, 1998"
#define FDTF_LONGTIME 0x00000008 // eg. "7:48:33 PM"
#define FDTF_RELATIVE 0x00000010 // uses "Yesterday", etc. if pos
sible
#define FDTF_LTRDATE 0x00000100 // Left To Right reading order
#define FDTF_RTLDATE 0x00000200 // Right To Left reading order
#define FDTF_NOAUTOREADINGORDER 0x00000400 // Don't detect reading order au
tomatically. Useful if you will be converting to Ansi and don't want Unicode rea
ding order characters
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);
#ifdef UNICODE
#define SHFormatDateTime SHFormatDateTimeW
#else
#define SHFormatDateTime SHFormatDateTimeA
#endif // !UNICODE
#if (_WIN32_IE >= _WIN32_IE_IE501)
LWSTDAPI_(int) SHAnsiToUnicode(LPCSTR pszSrc, __out_ecount(cwchBuf) LPWSTR pwsz
Dst, int cwchBuf);
LWSTDAPI_(int) SHAnsiToAnsi(LPCSTR pszSrc, __out_ecount(cchBuf) LPSTR pszDst, i
nt cchBuf);
LWSTDAPI_(int) SHUnicodeToAnsi(LPCWSTR pwszSrc, __out_ecount(cchBuf) LPSTR pszD
st, int cchBuf);
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.
#ifdef UNICODE
#define SHTCharToUnicode(wzSrc, wzDest, cchSize) SHUnicodeToUnico
de(wzSrc, wzDest, cchSize)
#define SHTCharToAnsi(wzSrc, szDest, cchSize) SHUnicodeToAnsi(
wzSrc, szDest, cchSize)
#define SHUnicodeToTChar(wzSrc, wzDest, cchSize) SHUnicodeToUnico
de(wzSrc, wzDest, cchSize)
#define SHAnsiToTChar(szSrc, wzDest, cchSize) SHAnsiToUnicode(
szSrc, wzDest, cchSize)
#else // UNICODE
#define SHTCharToUnicode(szSrc, wzDest, cchSize) SHAnsiToUnicode(
szSrc, wzDest, cchSize)
#define SHTCharToAnsi(szSrc, szDest, cchSize) SHAnsiToAnsi(szS
rc, szDest, cchSize)
#define SHUnicodeToTChar(wzSrc, szDest, cchSize) SHUnicodeToAnsi(
wzSrc, szDest, cchSize)
#define SHAnsiToTChar(szSrc, szDest, cchSize) SHAnsiToAnsi(szS
rc, szDest, cchSize)
#endif // UNICODE
#endif // (_WIN32_IE >= _WIN32_IE_IE501)
#if (_WIN32_IE >= _WIN32_IE_IE501)
LWSTDAPI_(int) SHMessageBoxCheckA(HWND hwnd, LPCSTR pszText, LPCSTR pszCaption,
UINT uType, int iDefault, LPCSTR pszRegVal);
LWSTDAPI_(int) SHMessageBoxCheckW(HWND hwnd, LPCWSTR pszText, LPCWSTR pszCaption
, UINT uType, int iDefault, LPCWSTR pszRegVal);
#ifdef UNICODE
#define SHMessageBoxCheck SHMessageBoxCheckW
#else
#define SHMessageBoxCheck SHMessageBoxCheckA
#endif // !UNICODE
#endif // (_WIN32_IE >= _WIN32_IE_IE501)
#if (_WIN32_IE >= _WIN32_IE_IE501)
// Prevents hang do to hung window on broadcast
LWSTDAPI_(LRESULT) SHSendMessageBroadcastA(UINT uMsg, __in WPARAM wParam, __in L
PARAM lParam);
// Prevents hang do to hung window on broadcast
LWSTDAPI_(LRESULT) SHSendMessageBroadcastW(UINT uMsg, __in WPARAM wParam, __in L
PARAM lParam);
#ifdef UNICODE
#define SHSendMessageBroadcast SHSendMessageBroadcastW
#else
#define SHSendMessageBroadcast SHSendMessageBroadcastA
#endif // !UNICODE
LWSTDAPI_(CHAR) SHStripMneumonicA(__inout LPSTR pszMenu);
LWSTDAPI_(WCHAR) SHStripMneumonicW(__inout LPWSTR pszMenu);
#ifdef UNICODE
#define SHStripMneumonic SHStripMneumonicW
#else
#define SHStripMneumonic SHStripMneumonicA
#endif // !UNICODE
// Returns TRUE/FALSE depending on question
#define OS_WINDOWS 0 // Windows 9x vs. NT
#define OS_NT 1 // Windows 9x vs. NT
#define OS_WIN95ORGREATER 2 // Win95 or greater
#define OS_NT4ORGREATER 3 // NT4 or greater
#define OS_WIN98ORGREATER 5 // Win98 or greater
#define OS_WIN98_GOLD 6 // Win98 Gold (Version 4.10 buil
d 1998)
#define OS_WIN2000ORGREATER 7 // Some derivative of Win2000
// NOTE: these flags check explicitly for (dwMajorVersion == 5)
#define OS_WIN2000PRO 8 // Windows 2000 Professional (Wo
rkstation)
#define OS_WIN2000SERVER 9 // Windows 2000 Server
#define OS_WIN2000ADVSERVER 10 // Windows 2000 Advanced Server
#define OS_WIN2000DATACENTER 11 // Windows 2000 Data Center Serv
er
#define OS_WIN2000TERMINAL 12 // Windows 2000 Terminal Server
in "Application Server" mode (now simply called "Terminal Server")
#define OS_EMBEDDED 13 // Embedded Windows Edition
#define OS_TERMINALCLIENT 14 // Windows Terminal Client (eg u
ser is comming in via tsclient)
#define OS_TERMINALREMOTEADMIN 15 // Terminal Server in "Remote Ad
ministration" mode
#define OS_WIN95_GOLD 16 // Windows 95 Gold (Version 4.0
Build 1995)
#define OS_MEORGREATER 17 // Windows Millennium (Version 5
.0)
#define OS_XPORGREATER 18 // Windows XP or greater
#define OS_HOME 19 // Home Edition (eg NOT Professi
onal, Server, Advanced Server, or Datacenter)
#define OS_PROFESSIONAL 20 // Professional (aka Worksta
tion; eg NOT Server, Advanced Server, or Datacenter)
#define OS_DATACENTER 21 // Datacenter (eg NOT Serv
er, Advanced Server, Professional, or Personal)
#define OS_ADVSERVER 22 // Advanced Server (eg NOT Data
center, Server, Professional, or Personal)
#define OS_SERVER 23 // Server (eg NOT Data
center, Advanced Server, Professional, or Personal)
#define OS_TERMINALSERVER 24 // Terminal Server - server runn
ing in what used to be called "Application Server" mode (now simply called "Term
inal Server")
#define OS_PERSONALTERMINALSERVER 25 // Personal Terminal Server - pe
r/pro machine running in single user TS mode
#define OS_FASTUSERSWITCHING 26 // Fast User Switching
#define OS_WELCOMELOGONUI 27 // New friendly logon UI
#define OS_DOMAINMEMBER 28 // Is this machine a member of a
domain (eg NOT a workgroup)
#define OS_ANYSERVER 29 // is this machine any type of s
erver? (eg datacenter or advanced server or server)?
#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_SMALLBUSINESSSERVER 32 // SBS Server
#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_MEDIACENTER 35 // eHome Freestyle Project
#define OS_APPLIANCE 36 // Windows .NET Appliance Server
LWSTDAPI_(BOOL) IsOS(DWORD dwOS);
#endif // (_WIN32_IE >= _WIN32_IE_IE501)
// Shared memory apis // Shared memory apis
#if (_WIN32_IE >= 0x0603) #if (_WIN32_IE >= 0x0603)
LWSTDAPI_(HANDLE) SHAllocShared(const void *pvData, DWORD dwSize, DWORD dwProc LWSTDAPI_(HANDLE) SHAllocShared(__in_bcount(dwSize) const void *pvData, __in D
essId); WORD dwSize, __in DWORD dwProcessId);
LWSTDAPI_(BOOL) SHFreeShared(HANDLE hData,DWORD dwProcessId); LWSTDAPI_(BOOL) SHFreeShared(__in HANDLE hData, __in DWORD dwProcessId);
LWSTDAPI_(void *) SHLockShared(HANDLE hData, DWORD dwProcessId); LWSTDAPI_(void *) SHLockShared(__in HANDLE hData, __in DWORD dwProcessId);
LWSTDAPI_(BOOL) SHUnlockShared(void *pvData); LWSTDAPI_(BOOL) SHUnlockShared(__in void *pvData);
#endif // _WIN32_IE >= 0x0603 #endif // _WIN32_IE >= 0x0603
#if (_WIN32_IE >= _WIN32_IE_IE501)
LWSTDAPI_(UINT) WhichPlatform(void);
// Return values of WhichPlatform
#define PLATFORM_UNKNOWN 0
#define PLATFORM_IE3 1 // obsolete: use PLATFORM_BROWSERONLY
#define PLATFORM_BROWSERONLY 1 // browser-only (no new shell)
#define PLATFORM_INTEGRATED 2 // integrated shell
//*** QueryInterface helpers
// NOTES
// ATL has a fancier version of this. if we need to extend ours, we
// should probably just switch to ATL's rather than reinvent.
// EXAMPLE
// Cfoo::QI(REFIID riid, void **ppv)
// {
// // (the IID_xxx comments make grep'ing work!)
// static const QITAB qit = {
// QITABENT(Cfoo, Iiface1), // IID_Iiface1
// ...
// QITABENT(Cfoo, IifaceN), // IID_IifaceN
// { 0 }, // n.b. don't forget the 0
// };
//
// // n.b. make sure you don't cast 'this'
// hr = QISearch(this, qit, riid, ppv);
// if (FAILED(hr))
// hr = SUPER::QI(riid, ppv);
// // custom code could be added here for FAILED() case
// return hr;
// }
//
// If you have an interface that is implemented multiple times,
// the compiler will claim an ambiguous cast, so you need to give
// some help. For example, if your class is defined as
//
// class CClass : public IPersistStream, public IPersistFile
//
// then you need to say
//
// QITABENTMULTI(CClass, IPersist, IPersistStream)
// QITABENT(CClass, IPersistStream)
// QITABENT(CClass, IPersistFile)
//
// The MULTI is needed for IPersist because the compiler doesn't
// know whether you wanted the IPersist from IPersistStream
// or the IPersist from IPersistFile. Unless you have played weird
// compiler tricks, they are the same implementation, so you can
// just pick either one, doesn't matter.
//
// Common mistake: You do not need to use MULTI if the base interface
// can be unambiguously determined. E.g.,
//
// class CSimple : public IContextMenu3
//
// QITABENT(CClass, IContextMenu) // do not need MULTI
// QITABENT(CClass, IContextMenu2) // do not need MULTI
// QITABENT(CClass, IContextMenu3)
//
// Do not create an entry for IUnknown; the first entry in the
// table will be used for IUnknown.
//
typedef struct
{
const IID * piid;
int dwOffset;
} QITAB, *LPQITAB;
typedef const QITAB *LPCQITAB;
#ifdef __cplusplus
#define QITABENTMULTI(Cthis, Ifoo, Iimpl) \
{ &__uuidof(Ifoo), OFFSETOFCLASS(Iimpl, Cthis) }
#else
#define QITABENTMULTI(Cthis, Ifoo, Iimpl) \
{ (IID*) &IID_##Ifoo, OFFSETOFCLASS(Iimpl, Cthis) }
#endif // __cplusplus
#define QITABENTMULTI2(Cthis, Ifoo, Iimpl) \
{ (IID*) &Ifoo, OFFSETOFCLASS(Iimpl, Cthis) }
#define QITABENT(Cthis, Ifoo) QITABENTMULTI(Cthis, Ifoo, Ifoo)
STDAPI QISearch(__inout void* that, __in LPCQITAB pqit, __in REFIID riid, __dere
f_out void **ppv);
#endif // (_WIN32_IE >= _WIN32_IE_IE501)
#ifndef STATIC_CAST
//*** STATIC_CAST -- 'portable' static_cast<>
// NOTES
// do *not* use SAFE_CAST (see comment in OFFSETOFCLASS)
#define STATIC_CAST(typ) static_cast<typ>
#ifndef _X86_
// assume only intel compiler (>=vc5) supports static_cast for now
// we could key off of _MSC_VER >= 1100 but i'm not sure that will work
//
// a straight cast will give the correct result but no error checking,
// so we'll have to catch errors on intel.
#undef STATIC_CAST
#define STATIC_CAST(typ) (typ)
#endif
#endif
#ifndef OFFSETOFCLASS
//*** OFFSETOFCLASS -- (stolen from ATL)
// we use STATIC_CAST not SAFE_CAST because the compiler gets confused
// (it doesn't constant-fold the ,-op in SAFE_CAST so we end up generating
// code for the table!)
#define OFFSETOFCLASS(base, derived) \
((DWORD)(DWORD_PTR)(STATIC_CAST(base*)((derived*)8))-8)
#endif
// Types for SHIsLowMemoryMachine
#define ILMM_IE4 0 // 1997-era machine
LWSTDAPI_(BOOL) SHIsLowMemoryMachine(DWORD dwType);
// Menu Helpers
LWSTDAPI_(int) GetMenuPosFromID(HMENU hmenu, UINT id);
LWSTDAPI SHGetInverseCMAP(__out_bcount(cbMap) BYTE *pbMap, ULONG cbMap);
#if (_WIN32_IE >= 0x0500) #if (_WIN32_IE >= 0x0500)
// SHAutoComplete // SHAutoComplete
// hwndEdit - HWND of editbox, ComboBox or ComboBoxEx. // hwndEdit - HWND of editbox, ComboBox or ComboBoxEx.
// dwFlags - Flags to indicate what to AutoAppend or AutoSuggest for the ed itbox. // dwFlags - Flags to indicate what to AutoAppend or AutoSuggest for the ed itbox.
// //
// WARNING: // WARNING:
// Caller needs to have called CoInitialize() or OleInitialize() // Caller needs to have called CoInitialize() or OleInitialize()
// and cannot call CoUninit/OleUninit until after // and cannot call CoUninit/OleUninit until after
// WM_DESTROY on hwndEdit. // WM_DESTROY on hwndEdit.
skipping to change at line 1506 skipping to change at line 2117
// WM_DESTROY on hwndEdit. // WM_DESTROY on hwndEdit.
// //
// dwFlags values: // dwFlags values:
#define SHACF_DEFAULT 0x00000000 // Currently (SHACF_FILESYST EM | SHACF_URLALL) #define SHACF_DEFAULT 0x00000000 // Currently (SHACF_FILESYST EM | SHACF_URLALL)
#define SHACF_FILESYSTEM 0x00000001 // This includes the File Sy stem as well as the rest of the shell (Desktop\My Computer\Control Panel\) #define SHACF_FILESYSTEM 0x00000001 // This includes the File Sy stem as well as the rest of the shell (Desktop\My Computer\Control Panel\)
#define SHACF_URLALL (SHACF_URLHISTORY | SHACF_URLMRU) #define SHACF_URLALL (SHACF_URLHISTORY | SHACF_URLMRU)
#define SHACF_URLHISTORY 0x00000002 // URLs in the User's Histor y #define SHACF_URLHISTORY 0x00000002 // URLs in the User's Histor y
#define SHACF_URLMRU 0x00000004 // URLs in the User's Recent ly Used list. #define SHACF_URLMRU 0x00000004 // URLs in the User's Recent ly Used list.
#define SHACF_USETAB 0x00000008 // Use the tab to move thru the autocomplete possibilities instead of to the next dialog/window control. #define SHACF_USETAB 0x00000008 // Use the tab to move thru the autocomplete possibilities instead of to the next dialog/window control.
#define SHACF_FILESYS_ONLY 0x00000010 // This includes the File Sy stem #define SHACF_FILESYS_ONLY 0x00000010 // This includes the File Sy stem
#if (_WIN32_IE >= 0x0600) #if (_WIN32_IE >= 0x0600)
#define SHACF_FILESYS_DIRS 0x00000020 // Same as SHACF_FILESYS_ONL Y except it only includes directories, UNC servers, and UNC server shares. #define SHACF_FILESYS_DIRS 0x00000020 // Same as SHACF_FILESYS_ONL Y except it only includes directories, UNC servers, and UNC server shares.
#endif // (_WIN32_IE >= 0x0600) #endif // (_WIN32_IE >= 0x0600)
#if (_WIN32_IE >= _WIN32_IE_IE70)
#define SHACF_VIRTUAL_NAMESPACE 0x00000040 // Also include the virtual
namespace
#endif // _WIN32_IE_IE70
#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);
LWSTDAPI SHSetThreadRef(IUnknown *punk); #if (_WIN32_IE >= _WIN32_IE_IE60SP2)
LWSTDAPI SHGetThreadRef(IUnknown **ppunk); LWSTDAPI SHCreateThreadRef(__inout LONG *pcRef, __deref_out IUnknown **ppunk);
#endif // _WIN32_IE_IE60SP2
LWSTDAPI SHSetThreadRef(__in IUnknown *punk);
LWSTDAPI SHGetThreadRef(__deref_out IUnknown **ppunk);
LWSTDAPI_(BOOL) SHSkipJunction(struct IBindCtx* pbc, const CLSID *pclsid); LWSTDAPI_(BOOL) SHSkipJunction(__in_opt struct IBindCtx* pbc, const CLSID *pclsi d);
#endif // (_WIN32_IE >= 0x0500) #endif // (_WIN32_IE >= 0x0500)
#if (_WIN32_IE >= 0x0603) #define CTF_INSIST 0x00000001 // SHCreateThread() dwFl
LWSTDAPI SHCreateThreadRef(LONG *pcRef, IUnknown **ppunk); ags - call pfnThreadProc synchronously if CreateThread() fails
#endif // (_WIN32_IE >= 0x0603) #define CTF_THREAD_REF 0x00000002 // hold a reference to t
he creating thread
#define CTF_PROCESS_REF 0x00000004 // hold a reference to t
he creating process
#define CTF_COINIT_STA 0x00000008 // init COM as STA for t
he created thread
#define CTF_COINIT CTF_COINIT_STA // init COM as STA for t
he created thread
#if (_WIN32_IE >= _WIN32_IE_IE60)
#define CTF_FREELIBANDEXIT 0x00000010 // hold a ref to the DLL
and call FreeLibraryAndExitThread() when done
#define CTF_REF_COUNTED 0x00000020 // thread supports ref c
ounting via SHGetThreadRef() or CTF_THREAD_REF so that child threads can keep th
is thread alive
#define CTF_WAIT_ALLOWCOM 0x00000040 // while waiting for pfn
Callback, allow COM marshaling to the blocked calling thread
#endif // _WIN32_IE_IE60
#if (_WIN32_IE >= _WIN32_IE_IE70)
#define CTF_UNUSED 0x00000080
#define CTF_INHERITWOW64 0x00000100 // new thread should inh
erit the wow64 disable state for the file system redirector
#endif // _WIN32_IE_IE70
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
#define CTF_WAIT_NO_REENTRANCY 0x00000200 // don't allow re-entran
cy when waiting for the sync proc, this won't work with marshalled objects or Se
ndMessages() from the sync proc
#endif // (NTDDI_VERSION >= NTDDI_LONGHORN)
#define CTF_INSIST 0x00000001 // SHCreateThread() dwFlags - call p //#define CTF_COINIT_MTA 0x00000800 // init COM as STA for the created
fnThreadProc synchronously if CreateThread() fails thread
#define CTF_THREAD_REF 0x00000002 // hold a reference to the creating
thread
#define CTF_PROCESS_REF 0x00000004 // hold a reference to the creating
process
#define CTF_COINIT 0x00000008 // init COM for the created thread
#define CTF_FREELIBANDEXIT 0x00000010 // hold a ref to the DLL and call Fr
eeLibraryAndExitThread() when done
#define CTF_REF_COUNTED 0x00000020 // thread supports ref counting via
SHGetThreadRef() or CTF_THREAD_REF so that child threads can keep this thread al
ive
#define CTF_WAIT_ALLOWCOM 0x00000040 // while waiting for pfnCallback, al
low COM marshaling to the blocked calling thread
LWSTDAPI_(BOOL) SHCreateThread(LPTHREAD_START_ROUTINE pfnThreadProc, void *pData , DWORD dwFlags, LPTHREAD_START_ROUTINE pfnCallback); LWSTDAPI_(BOOL) SHCreateThread(__in LPTHREAD_START_ROUTINE pfnThreadProc, __in_o pt void *pData, DWORD dwFlags, __in_opt LPTHREAD_START_ROUTINE pfnCallback);
#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
#ifndef NO_SHLWAPI_GDI #ifndef NO_SHLWAPI_GDI
// //
//====== GDI helper functions ================================================ //====== GDI helper functions ================================================
// //
LWSTDAPI_(HPALETTE) SHCreateShellPalette(HDC hdc); LWSTDAPI_(HPALETTE) SHCreateShellPalette(__in_opt HDC hdc);
#if (_WIN32_IE >= 0x0500) #if (_WIN32_IE >= 0x0500)
LWSTDAPI_(void) ColorRGBToHLS(COLORREF clrRGB, WORD* pwHue, WORD* pwLuminanc LWSTDAPI_(void) ColorRGBToHLS(__in COLORREF clrRGB, __out WORD* pwHue, __out
e, WORD* pwSaturation); WORD* pwLuminance, __out WORD* pwSaturation);
LWSTDAPI_(COLORREF) ColorHLSToRGB(WORD wHue, WORD wLuminance, WORD wSaturation); LWSTDAPI_(COLORREF) ColorHLSToRGB(__in WORD wHue, __in WORD wLuminance, __in WOR
LWSTDAPI_(COLORREF) ColorAdjustLuma(COLORREF clrRGB, int n, BOOL fScale); D wSaturation);
LWSTDAPI_(COLORREF) ColorAdjustLuma(__in COLORREF clrRGB, int n, BOOL fScale);
#endif // _WIN32_IE >= 0x0500 #endif // _WIN32_IE >= 0x0500
#endif // NO_SHLWAPI_GDI #endif // NO_SHLWAPI_GDI
// //
//====== DllGetVersion ======================================================= //====== DllGetVersion =======================================================
// //
typedef struct _DLLVERSIONINFO typedef struct _DLLVERSIONINFO
skipping to change at line 1608 skipping to change at line 2233
((ULONGLONG)( qfe) << 0)) ((ULONGLONG)( qfe) << 0))
// //
// The caller should always GetProcAddress("DllGetVersion"), not // The caller should always GetProcAddress("DllGetVersion"), not
// implicitly link to it. // implicitly link to it.
// //
typedef HRESULT (CALLBACK* DLLGETVERSIONPROC)(DLLVERSIONINFO *); typedef HRESULT (CALLBACK* DLLGETVERSIONPROC)(DLLVERSIONINFO *);
// DllInstall (to be implemented by self-installing DLLs) // DllInstall (to be implemented by self-installing DLLs)
STDAPI DllInstall(BOOL bInstall, LPCWSTR pszCmdLine); STDAPI DllInstall(__in BOOL bInstall, __in LPCWSTR pszCmdLine);
#if (_WIN32_IE >= 0x0602) #if (_WIN32_IE >= 0x0602)
// Function to see if Internet Explorer Enhanced Security Configuration is activ e for the current user // Function to see if Internet Explorer Enhanced Security Configuration is activ e for the current user
LWSTDAPI_(BOOL) IsInternetESCEnabled(); LWSTDAPI_(BOOL) IsInternetESCEnabled();
#endif // (_WIN32_IE >= 0x0602) #endif // (_WIN32_IE >= 0x0602)
#ifdef __cplusplus #ifdef __cplusplus
} }
#if defined(USE_STRICT_CONST) && !defined(NO_SHLWAPI_STRFCNS)
//=============================================================================
// C++ versions to help detect "const" violations
__inline LPSTR StrChrA(__in LPSTR lpStart, WORD wMatch)
{
return const_cast<LPSTR>(StrChrA(const_cast<LPCSTR>(lpStart), wMatch));
}
__inline LPWSTR StrChrW(__in LPWSTR lpStart, __in WCHAR wMatch)
{
return const_cast<LPWSTR>(StrChrW(const_cast<LPCWSTR>(lpStart), wMatch));
}
__inline LPSTR StrChrIA(__in LPSTR lpStart, WORD wMatch)
{
return const_cast<LPSTR>(StrChrIA(const_cast<LPCSTR>(lpStart), wMatch));
}
__inline LPWSTR StrChrIW(__in LPWSTR lpStart, __in WCHAR wMatch)
{
return const_cast<LPWSTR>(StrChrIW(const_cast<LPCWSTR>(lpStart), wMatch));
}
#if (_WIN32_IE >= _WIN32_IE_IE60)
__inline LPWSTR StrChrNW(__in LPWSTR lpStart, __in WCHAR wMatch, UINT cchMax)
{
return const_cast<LPWSTR>(StrChrNW(const_cast<LPCWSTR>(lpStart), wMatch, cch
Max));
}
__inline LPWSTR StrChrNIW(__in LPWSTR lpStart, __in WCHAR wMatch, UINT cchMax)
{
return const_cast<LPWSTR>(StrChrNIW(const_cast<LPCWSTR>(lpStart), wMatch, cc
hMax));
}
#endif // _WIN32_IE_IE60
__inline LPSTR StrPBrkA(__in LPSTR psz, __in LPCSTR pszSet)
{
return const_cast<LPSTR>(StrPBrkA(const_cast<LPCSTR>(psz), pszSet));
}
__inline LPWSTR StrPBrkW(__in LPWSTR psz, __in LPCWSTR pszSet)
{
return const_cast<LPWSTR>(StrPBrkW(const_cast<LPCWSTR>(psz), pszSet));
}
__inline LPSTR StrRChrA(__in LPSTR lpStart, __in_opt LPCSTR lpEnd, __in WORD wMa
tch)
{
return const_cast<LPSTR>(StrRChrA(const_cast<LPCSTR>(lpStart), lpEnd, wMatch
));
}
__inline LPWSTR StrRChrW(__in LPWSTR lpStart, __in_opt LPCWSTR lpEnd, __in WCHAR
wMatch)
{
return const_cast<LPWSTR>(StrRChrW(const_cast<LPCWSTR>(lpStart), lpEnd, wMat
ch));
}
__inline LPSTR StrRChrIA(__in LPSTR lpStart, __in_opt LPCSTR lpEnd, __in WORD wM
atch)
{
return const_cast<LPSTR>(StrRChrIA(const_cast<LPCSTR>(lpStart), lpEnd, wMatc
h));
}
__inline LPWSTR StrRChrIW(__in LPWSTR lpStart, __in_opt LPCWSTR lpEnd, __in WCHA
R wMatch)
{
return const_cast<LPWSTR>(StrRChrIW(const_cast<LPCWSTR>(lpStart), lpEnd, wMa
tch));
}
__inline LPSTR StrRStrIA(__in LPSTR lpSource, __in_opt LPCSTR lpLast, __in LPCST
R lpSrch)
{
return const_cast<LPSTR>(StrRStrIA(const_cast<LPCSTR>(lpSource), lpLast, lpS
rch));
}
__inline LPWSTR StrRStrIW(__in LPWSTR lpSource, __in_opt LPCWSTR lpLast, __in LP
CWSTR lpSrch)
{
return const_cast<LPWSTR>(StrRStrIW(const_cast<LPCWSTR>(lpSource), lpLast, l
pSrch));
}
__inline LPSTR StrStrA(__in LPSTR lpFirst, __in LPCSTR lpSrch)
{
return const_cast<LPSTR>(StrStrA(const_cast<LPCSTR>(lpFirst), lpSrch));
}
__inline LPWSTR StrStrW(__in LPWSTR lpFirst, __in LPCWSTR lpSrch)
{
return const_cast<LPWSTR>(StrStrW(const_cast<LPCWSTR>(lpFirst), lpSrch));
}
__inline LPSTR StrStrIA(__in LPSTR lpFirst, __in LPCSTR lpSrch)
{
return const_cast<LPSTR>(StrStrIA(const_cast<LPCSTR>(lpFirst), lpSrch));
}
__inline LPWSTR StrStrIW(__in LPWSTR lpFirst, __in LPCWSTR lpSrch)
{
return const_cast<LPWSTR>(StrStrIW(const_cast<LPCWSTR>(lpFirst), lpSrch));
}
#if (_WIN32_IE >= _WIN32_IE_IE60)
__inline LPWSTR StrStrNW(__in LPWSTR lpFirst, __in LPCWSTR lpSrch, __in UINT cch
Max)
{
return const_cast<LPWSTR>(StrStrNW(const_cast<LPCWSTR>(lpFirst), lpSrch, cch
Max));
}
__inline LPWSTR StrStrNIW(__in LPWSTR lpFirst, __in LPCWSTR lpSrch, __in UINT cc
hMax)
{
return const_cast<LPWSTR>(StrStrNIW(const_cast<LPCWSTR>(lpFirst), lpSrch, cc
hMax));
}
#endif
__inline LPSTR PathFindExtensionA(__in LPSTR pszPath)
{
return const_cast<LPSTR>(PathFindExtensionA(const_cast<LPCSTR>(pszPath)));
}
__inline LPWSTR PathFindExtensionW(__in LPWSTR pszPath)
{
return const_cast<LPWSTR>(PathFindExtensionW(const_cast<LPCWSTR>(pszPath)));
}
__inline LPSTR PathFindFileNameA(__in LPSTR pszPath)
{
return const_cast<LPSTR>(PathFindFileNameA(const_cast<LPCSTR>(pszPath)));
}
__inline LPWSTR PathFindFileNameW(__in LPWSTR pszPath)
{
return const_cast<LPWSTR>(PathFindFileNameW(const_cast<LPCWSTR>(pszPath)));
}
__inline LPSTR PathFindNextComponentA(__in LPSTR pszPath)
{
return const_cast<LPSTR>(PathFindNextComponentA(const_cast<LPCSTR>(pszPath))
);
}
__inline LPWSTR PathFindNextComponentW(__in LPWSTR pszPath)
{
return const_cast<LPWSTR>(PathFindNextComponentW(const_cast<LPCWSTR>(pszPath
)));
}
__inline LPSTR PathGetArgsA(__in LPSTR pszPath)
{
return const_cast<LPSTR>(PathGetArgsA(const_cast<LPCSTR>(pszPath)));
}
__inline LPWSTR PathGetArgsW(__in LPWSTR pszPath)
{
return const_cast<LPWSTR>(PathGetArgsW(const_cast<LPCWSTR>(pszPath)));
}
__inline LPSTR PathSkipRootA(__in LPSTR pszPath)
{
return const_cast<LPSTR>(PathSkipRootA(const_cast<LPCSTR>(pszPath)));
}
__inline LPWSTR PathSkipRootW(__in LPWSTR pszPath)
{
return const_cast<LPWSTR>(PathSkipRootW(const_cast<LPCWSTR>(pszPath)));
}
#endif
#endif
#if defined(DEPRECATE_SUPPORTED)
#pragma warning(pop)
#endif #endif
#ifdef _WIN32 #ifdef _WIN32
#include <poppack.h> #include <poppack.h>
#endif #endif
#endif #endif
#endif // _INC_SHLWAPI #endif // _INC_SHLWAPI
 End of changes. 134 change blocks. 
486 lines changed or deleted 1411 lines changed or added

This html diff was produced by rfcdiff 1.41.