|
|
;begin_both/*****************************************************************************\* ** shlwapi.h - Interface for the Windows light-weight utility APIs ** ** Version 1.0 ** ** Copyright (c) Microsoft Corporation. All rights reserved. ** *\*****************************************************************************/
;end_both
#ifndef _INC_SHLWAPI#define _INC_SHLWAPI#ifndef _INC_SHLWAPIP ;internal#define _INC_SHLWAPIP ;internal
;begin_both#ifndef NOSHLWAPI
#include <objbase.h>#include <shtypes.h>
;end_both
#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 UNIXtypedef interface IInternetSecurityMgrSite IInternetSecurityMgrSite;typedef interface IInternetSecurityManager IInternetSecurityManager;typedef interface IInternetHostSecurityManager IInternetHostSecurityManager;#endif
//// Define API decoration for direct importing of DLL references.//#ifndef WINSHLWAPI#if !defined(_SHLWAPI_)#define LWSTDAPI EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE#define LWSTDAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE#define LWSTDAPIV EXTERN_C DECLSPEC_IMPORT HRESULT STDAPIVCALLTYPE#define LWSTDAPIV_(type) EXTERN_C DECLSPEC_IMPORT type STDAPIVCALLTYPE#else#define LWSTDAPI STDAPI#define LWSTDAPI_(type) STDAPI_(type)#define LWSTDAPIV STDAPIV#define LWSTDAPIV_(type) STDAPIV_(type)#endif#endif // WINSHLWAPI
;begin_both#ifdef _WIN32#include <pshpack8.h>#endif
#ifdef __cplusplusextern "C" {#endif
//// Users of this header may define any number of these constants to avoid// the definitions of each functional group.//// NO_SHLWAPI_STRFCNS String functions// NO_SHLWAPI_PATH Path functions// NO_SHLWAPI_REG Registry functions// NO_SHLWAPI_UALSTR Unaligned string functions ;internal// NO_SHLWAPI_STREAM Stream functions// NO_SHLWAPI_HTTP HTTP helper routines ;internal// NO_SHLWAPI_INTERNAL Other random internal things ;internal// NO_SHLWAPI_GDI GDI helper functions// NO_SHLWAPI_UNITHUNK Unicode wrapper functions ;internal// NO_SHLWAPI_TPS Thread Pool Services ;internal// NO_SHLWAPI_MLUI Multi Language UI functions ;internal
#ifndef NO_SHLWAPI_STRFCNS////=============== String Routines ===================================//
;end_bothLWSTDAPI_(LPSTR) StrChrA(LPCSTR lpStart, WORD wMatch);LWSTDAPI_(LPWSTR) StrChrW(LPCWSTR lpStart, WCHAR wMatch);LWSTDAPI_(LPSTR) StrChrIA(LPCSTR lpStart, WORD wMatch);LWSTDAPI_(LPWSTR) StrChrIW(LPCWSTR lpStart, WCHAR wMatch);LWSTDAPI_(int) StrCmpNA(LPCSTR lpStr1, LPCSTR lpStr2, int nChar);LWSTDAPI_(int) StrCmpNW(LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar);LWSTDAPI_(int) StrCmpNIA(LPCSTR lpStr1, LPCSTR lpStr2, int nChar);LWSTDAPI_(int) StrCmpNIW(LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar);LWSTDAPI_(int) StrCSpnA(LPCSTR lpStr, LPCSTR lpSet);LWSTDAPI_(int) StrCSpnW(LPCWSTR lpStr, LPCWSTR lpSet);LWSTDAPI_(int) StrCSpnIA(LPCSTR lpStr, LPCSTR lpSet);LWSTDAPI_(int) StrCSpnIW(LPCWSTR lpStr, LPCWSTR lpSet);LWSTDAPI_(LPSTR) StrDupA(LPCSTR lpSrch);LWSTDAPI_(LPWSTR) StrDupW(LPCWSTR lpSrch);LWSTDAPI_(LPSTR) StrFormatByteSizeA(DWORD dw, LPSTR szBuf, UINT uiBufSize);LWSTDAPI_(LPSTR) StrFormatByteSize64A(LONGLONG qdw, LPSTR szBuf, UINT uiBufSize);LWSTDAPI_(LPWSTR) StrFormatByteSizeW(LONGLONG qdw, LPWSTR szBuf, UINT uiBufSize);LWSTDAPI_(LPWSTR) StrFormatKBSizeW(LONGLONG qdw, LPWSTR szBuf, UINT uiBufSize);LWSTDAPI_(LPSTR) StrFormatKBSizeA(LONGLONG qdw, LPSTR szBuf, UINT uiBufSize);LWSTDAPI_(int) StrFromTimeIntervalA(LPSTR pszOut, UINT cchMax, DWORD dwTimeMS, int digits);LWSTDAPI_(int) StrFromTimeIntervalW(LPWSTR pszOut, UINT cchMax, DWORD dwTimeMS, int digits);LWSTDAPI_(BOOL) StrIsIntlEqualA(BOOL fCaseSens, LPCSTR lpString1, LPCSTR lpString2, int nChar);LWSTDAPI_(BOOL) StrIsIntlEqualW(BOOL fCaseSens, LPCWSTR lpString1, LPCWSTR lpString2, int nChar);LWSTDAPI_(LPSTR) StrNCatA(LPSTR psz1, LPCSTR psz2, int cchMax);LWSTDAPI_(LPWSTR) StrNCatW(LPWSTR psz1, LPCWSTR psz2, int cchMax);LWSTDAPI_(LPSTR) StrPBrkA(LPCSTR psz, LPCSTR pszSet);LWSTDAPI_(LPWSTR) StrPBrkW(LPCWSTR psz, LPCWSTR pszSet);LWSTDAPI_(LPSTR) StrRChrA(LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch);LWSTDAPI_(LPWSTR) StrRChrW(LPCWSTR lpStart, LPCWSTR lpEnd, WCHAR wMatch);LWSTDAPI_(LPSTR) StrRChrIA(LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch);LWSTDAPI_(LPWSTR) StrRChrIW(LPCWSTR lpStart, LPCWSTR lpEnd, WCHAR wMatch);LWSTDAPI_(LPSTR) StrRStrIA(LPCSTR lpSource, LPCSTR lpLast, LPCSTR lpSrch);LWSTDAPI_(LPWSTR) StrRStrIW(LPCWSTR lpSource, LPCWSTR lpLast, LPCWSTR lpSrch);LWSTDAPI_(int) StrSpnA(LPCSTR psz, LPCSTR pszSet);LWSTDAPI_(int) StrSpnW(LPCWSTR psz, LPCWSTR pszSet);LWSTDAPI_(LPSTR) StrStrA(LPCSTR lpFirst, LPCSTR lpSrch);LWSTDAPI_(LPWSTR) StrStrW(LPCWSTR lpFirst, LPCWSTR lpSrch);LWSTDAPI_(LPSTR) StrStrIA(LPCSTR lpFirst, LPCSTR lpSrch);LWSTDAPI_(LPWSTR) StrStrIW(LPCWSTR lpFirst, LPCWSTR lpSrch);LWSTDAPI_(int) StrToIntA(LPCSTR lpSrc);LWSTDAPI_(int) StrToIntW(LPCWSTR lpSrc);LWSTDAPI_(BOOL) StrToIntExA(LPCSTR pszString, DWORD dwFlags, int * piRet);LWSTDAPI_(BOOL) StrToIntExW(LPCWSTR pszString, DWORD dwFlags, int * piRet);#if (_WIN32_IE >= 0x0600)LWSTDAPI_(BOOL) StrToInt64ExA(LPCSTR pszString, DWORD dwFlags, LONGLONG * pllRet);LWSTDAPI_(BOOL) StrToInt64ExW(LPCWSTR pszString, DWORD dwFlags, LONGLONG * pllRet);#endifLWSTDAPI_(BOOL) StrTrimA(LPSTR psz, LPCSTR pszTrimChars);LWSTDAPI_(BOOL) StrTrimW(LPWSTR psz, LPCWSTR pszTrimChars);
LWSTDAPI_(LPWSTR) StrCatW(LPWSTR psz1, LPCWSTR psz2);LWSTDAPI_(int) StrCmpW(LPCWSTR psz1, LPCWSTR psz2);LWSTDAPI_(int) StrCmpIW(LPCWSTR psz1, LPCWSTR psz2);LWSTDAPI_(LPWSTR) StrCpyW(LPWSTR psz1, LPCWSTR psz2);LWSTDAPI_(LPWSTR) StrCpyNW(LPWSTR psz1, LPCWSTR psz2, int cchMax);;begin_internalLWSTDAPI_(LPSTR) StrCpyNXA(LPSTR psz1, LPCSTR psz2, int cchMax);LWSTDAPI_(LPWSTR) StrCpyNXW(LPWSTR psz1, LPCWSTR psz2, int cchMax);;end_internal
LWSTDAPI_(LPWSTR) StrCatBuffW(LPWSTR pszDest, LPCWSTR pszSrc, int cchDestBuffSize);LWSTDAPI_(LPSTR) StrCatBuffA(LPSTR pszDest, LPCSTR pszSrc, int cchDestBuffSize);
LWSTDAPI_(BOOL) ChrCmpIA(WORD w1, WORD w2);LWSTDAPI_(BOOL) ChrCmpIW(WCHAR w1, WCHAR w2);
LWSTDAPI_(int) wvnsprintfA(LPSTR lpOut, int cchLimitIn, LPCSTR lpFmt, va_list arglist);LWSTDAPI_(int) wvnsprintfW(LPWSTR lpOut, int cchLimitIn, LPCWSTR lpFmt, va_list arglist);LWSTDAPIV_(int) wnsprintfA(LPSTR lpOut, int cchLimitIn, LPCSTR lpFmt, ...);LWSTDAPIV_(int) wnsprintfW(LPWSTR lpOut, int cchLimitIn, LPCWSTR lpFmt, ...);
#define StrIntlEqNA( s1, s2, nChar) StrIsIntlEqualA( 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 StrIntlEqNIW(s1, s2, nChar) StrIsIntlEqualW(FALSE, s1, s2, nChar)
LWSTDAPI StrRetToStr%(STRRET *pstr, LPCITEMIDLIST pidl, LPTSTR% *ppsz);LWSTDAPI StrRetToBuf%(STRRET *pstr, LPCITEMIDLIST pidl, LPTSTR% pszBuf, UINT cchBuf);LWSTDAPI StrRetToBSTR(STRRET *pstr, LPCITEMIDLIST pidl, BSTR *pbstr);
// helper to duplicate a string using the task allocator
LWSTDAPI SHStrDup%(LPCTSTR% psz, WCHAR **ppwsz);
LWSTDAPI_(int) StrCmpLogicalW(LPCWSTR psz1, LPCWSTR psz2);LWSTDAPI_(DWORD) StrCatChainW(LPWSTR pszDst, DWORD cchDst, DWORD ichAt, LPCWSTR pszSrc);
LWSTDAPI SHLoadIndirectString(LPCWSTR pszSource, LPWSTR pszOutBuf, UINT cchOutBuf, void **ppvReserved);
;begin_internal
#define ORD_SHLOADREGUISTRINGA 438#define ORD_SHLOADREGUISTRINGW 439LWSTDAPI SHLoadRegUIString%(HKEY hkey, LPCTSTR% pszValue, LPTSTR% pszOutBuf, UINT cchOutBuf);
LWSTDAPI_(BOOL) IsCharCntrlW(WCHAR wch);LWSTDAPI_(BOOL) IsCharDigitW(WCHAR wch);LWSTDAPI_(BOOL) IsCharXDigitW(WCHAR wch);LWSTDAPI_(BOOL) IsCharSpaceW(WCHAR wch);LWSTDAPI_(BOOL) IsCharBlankW(WCHAR wch);LWSTDAPI_(BOOL) IsCharPunctW(WCHAR wch);LWSTDAPI_(BOOL) GetStringType3ExW( LPCWSTR, int, LPWORD );
// StrCmp*C* - Compare strings using C runtime collation rules.// These functions are faster than the StrCmp family of functions// above and can be used when the character set of the strings is// known to be limited to seven ASCII character set.
LWSTDAPI_(int) StrCmpNCA(LPCSTR lpStr1, LPCSTR lpStr2, int nChar);LWSTDAPI_(int) StrCmpNCW(LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar);LWSTDAPI_(int) StrCmpNICA(LPCSTR lpStr1, LPCSTR lpStr2, int nChar);LWSTDAPI_(int) StrCmpNICW(LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar);LWSTDAPI_(int) StrCmpCA(LPCSTR lpStr1, LPCSTR lpStr2);LWSTDAPI_(int) StrCmpCW(LPCWSTR lpStr1, LPCWSTR lpStr2);LWSTDAPI_(int) StrCmpICA(LPCSTR lpStr1, LPCSTR lpStr2);LWSTDAPI_(int) StrCmpICW(LPCWSTR lpStr1, LPCWSTR lpStr2);
// This is a true-Unicode version of CompareString. It only supports// STRING_SORT, however. After better test coverage, it shall replace// the CompareString Unicode wrapper itself. In the mean time, we only// call this from the find dialog/OM method of Trident.
LWSTDAPI_(int) CompareStringAltW( LCID lcid, DWORD dwFlags, LPCWSTR lpchA, int cchA, LPCWSTR lpchB, int cchB );
;end_internal
#ifdef UNICODE#define StrChr StrChrW#define StrRChr StrRChrW#define StrChrI StrChrIW#define StrRChrI StrRChrIW#define StrCmpN StrCmpNW#define StrCmpNI StrCmpNIW#define StrStr StrStrW#define StrStrI StrStrIW#define StrDup StrDupW#define StrRStrI StrRStrIW#define StrCSpn StrCSpnW#define StrCSpnI StrCSpnIW#define StrSpn StrSpnW#define StrToInt StrToIntW#define StrPBrk StrPBrkW#define StrToIntEx StrToIntExW#if (_WIN32_IE >= 0x0600)#define StrToInt64Ex StrToInt64ExW#endif#define StrFromTimeInterval StrFromTimeIntervalW#define StrIntlEqN StrIntlEqNW#define StrIntlEqNI StrIntlEqNIW#define StrFormatByteSize StrFormatByteSizeW#define StrFormatByteSize64 StrFormatByteSizeW#define StrFormatKBSize StrFormatKBSizeW#define StrNCat StrNCatW#define StrTrim StrTrimW#define StrCatBuff StrCatBuffW#define ChrCmpI ChrCmpIW#define wvnsprintf wvnsprintfW#define wnsprintf wnsprintfW#define StrIsIntlEqual StrIsIntlEqualW
;begin_internal//// Macros for IsCharAlpha, IsCharAlphaNumeric, IsCharLower, IsCharUpper// are in winuser.h////
#define IsCharCntrl IsCharCntrlW#define IsCharDigit IsCharDigitW#define IsCharXDigit IsCharXDigitW#define IsCharSpace IsCharSpaceW#define IsCharBlank IsCharBlankW#define IsCharPunct IsCharPunctW#define GetStringType3Ex GetStringType3ExW
;end_internal
#else#define StrChr StrChrA#define StrRChr StrRChrA#define StrChrI StrChrIA#define StrRChrI StrRChrIA#define StrCmpN StrCmpNA#define StrCmpNI StrCmpNIA#define StrStr StrStrA#define StrStrI StrStrIA#define StrDup StrDupA#define StrRStrI StrRStrIA#define StrCSpn StrCSpnA#define StrCSpnI StrCSpnIA#define StrSpn StrSpnA#define StrToInt StrToIntA#define StrPBrk StrPBrkA#define StrToIntEx StrToIntExA#if (_WIN32_IE >= 0x0600)#define StrToInt64Ex StrToInt64ExA#endif#define StrFromTimeInterval StrFromTimeIntervalA#define StrIntlEqN StrIntlEqNA#define StrIntlEqNI StrIntlEqNIA#define StrFormatByteSize StrFormatByteSizeA#define StrFormatByteSize64 StrFormatByteSize64A#define StrFormatKBSize StrFormatKBSizeA#define StrNCat StrNCatA#define StrTrim StrTrimA#define StrCatBuff StrCatBuffA#define ChrCmpI ChrCmpIA#define wvnsprintf wvnsprintfA#define wnsprintf wnsprintfA#define StrIsIntlEqual StrIsIntlEqualA#endif
;begin_internal
#ifdef UNICODE
#define StrCmpNC StrCmpNCW#define StrCmpNIC StrCmpNICW#define StrCmpC StrCmpCW#define StrCmpIC StrCmpICW#define StrCpyNX StrCpyNXW
#else
#define StrCmpNC StrCmpNCA#define StrCmpNIC StrCmpNICA#define StrCmpC StrCmpCA#define StrCmpIC StrCmpICA#define StrCpyNX StrCpyNXA
#endif
;end_internal
// Backward compatible to NT's non-standard naming (strictly// for comctl32)//LWSTDAPI_(BOOL) IntlStrEqWorkerA(BOOL fCaseSens, LPCSTR lpString1, LPCSTR lpString2, int nChar);LWSTDAPI_(BOOL) IntlStrEqWorkerW(BOOL fCaseSens, LPCWSTR lpString1, LPCWSTR lpString2, int nChar);
#define IntlStrEqNA( s1, s2, nChar) IntlStrEqWorkerA( 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 IntlStrEqNIW(s1, s2, nChar) IntlStrEqWorkerW(FALSE, s1, s2, nChar)
#ifdef UNICODE#define IntlStrEqN IntlStrEqNW#define IntlStrEqNI IntlStrEqNIW#else#define IntlStrEqN IntlStrEqNA#define IntlStrEqNI IntlStrEqNIA#endif
#define SZ_CONTENTTYPE_HTMLA "text/html"#define SZ_CONTENTTYPE_HTMLW L"text/html"#define SZ_CONTENTTYPE_CDFA "application/x-cdf"#define SZ_CONTENTTYPE_CDFW L"application/x-cdf"
#ifdef UNICODE#define SZ_CONTENTTYPE_HTML SZ_CONTENTTYPE_HTMLW#define SZ_CONTENTTYPE_CDF SZ_CONTENTTYPE_CDFW#else#define SZ_CONTENTTYPE_HTML SZ_CONTENTTYPE_HTMLA#define SZ_CONTENTTYPE_CDF SZ_CONTENTTYPE_CDFA#endif
#define PathIsHTMLFileA(pszPath) PathIsContentTypeA(pszPath, SZ_CONTENTTYPE_HTMLA)#define PathIsHTMLFileW(pszPath) PathIsContentTypeW(pszPath, SZ_CONTENTTYPE_HTMLW)
// Flags for StrToIntEx#define STIF_DEFAULT 0x00000000L#define STIF_SUPPORT_HEX 0x00000001L
#define StrCatA lstrcatA#define StrCmpA lstrcmpA#define StrCmpIA lstrcmpiA#define StrCpyA lstrcpyA#define StrCpyNA lstrcpynA
#define StrToLong StrToInt#define StrNCmp StrCmpN#define StrNCmpI StrCmpNI#define StrNCpy StrCpyN#define StrCatN StrNCat
#ifdef UNICODE#define StrCat StrCatW#define StrCmp StrCmpW#define StrCmpI StrCmpIW#define StrCpy StrCpyW#define StrCpyN StrCpyNW#define StrCatBuff StrCatBuffW#else#define StrCat lstrcatA#define StrCmp lstrcmpA#define StrCmpI lstrcmpiA#define StrCpy lstrcpyA#define StrCpyN lstrcpynA#define StrCatBuff StrCatBuffA#endif
;begin_both
#endif // NO_SHLWAPI_STRFCNS
;end_both;begin_both
#ifndef NO_SHLWAPI_PATH
////=============== Path Routines ===================================//
;end_bothLWSTDAPI_(LPTSTR%) PathAddBackslash%(LPTSTR% pszPath);LWSTDAPI_(BOOL) PathAddExtension%(LPTSTR% pszPath, LPCTSTR% pszExt);LWSTDAPI_(BOOL) PathAppendA(LPSTR pszPath, LPCSTR pMore);LWSTDAPI_(BOOL) PathAppendW(LPWSTR pszPath, LPCWSTR pMore);LWSTDAPI_(LPTSTR%) PathBuildRoot%(LPTSTR% pszRoot, int iDrive);LWSTDAPI_(BOOL) PathCanonicalizeA(LPSTR pszBuf, LPCSTR pszPath);LWSTDAPI_(BOOL) PathCanonicalizeW(LPWSTR pszBuf, LPCWSTR pszPath);LWSTDAPI_(LPTSTR%) PathCombine%(LPTSTR% pszDest, LPCTSTR% pszDir, LPCTSTR% pszFile);LWSTDAPI_(BOOL) PathCompactPathA(HDC hDC, LPSTR pszPath, UINT dx);LWSTDAPI_(BOOL) PathCompactPathW(HDC hDC, LPWSTR pszPath, UINT dx);LWSTDAPI_(BOOL) PathCompactPathExA(LPSTR pszOut, LPCSTR pszSrc, UINT cchMax, DWORD dwFlags);LWSTDAPI_(BOOL) PathCompactPathExW(LPWSTR pszOut, LPCWSTR pszSrc, UINT cchMax, DWORD dwFlags);LWSTDAPI_(int) PathCommonPrefixA(LPCSTR pszFile1, LPCSTR pszFile2, LPSTR achPath);LWSTDAPI_(int) PathCommonPrefixW(LPCWSTR pszFile1, LPCWSTR pszFile2, LPWSTR achPath);LWSTDAPI_(BOOL) PathFileExists%(LPCTSTR% pszPath);LWSTDAPI_(LPTSTR%) PathFindExtension%(LPCTSTR% pszPath);LWSTDAPI_(LPTSTR%) PathFindFileName%(LPCTSTR% pszPath);LWSTDAPI_(LPTSTR%) PathFindNextComponent%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathFindOnPathA(LPSTR pszPath, LPCSTR * ppszOtherDirs);LWSTDAPI_(BOOL) PathFindOnPathW(LPWSTR pszPath, LPCWSTR * ppszOtherDirs);LWSTDAPI_(LPTSTR%) PathGetArgs%(LPCTSTR% pszPath);LWSTDAPI_(LPCTSTR%) PathFindSuffixArray%(LPCTSTR% pszPath, const LPCTSTR% *apszSuffix, int iArraySize);LWSTDAPI_(BOOL) PathIsLFNFileSpec%(LPCTSTR% lpName);
LWSTDAPI_(UINT) PathGetCharTypeA(UCHAR ch);LWSTDAPI_(UINT) PathGetCharTypeW(WCHAR ch);
// Return flags for PathGetCharType#define GCT_INVALID 0x0000#define GCT_LFNCHAR 0x0001#define GCT_SHORTCHAR 0x0002#define GCT_WILD 0x0004#define GCT_SEPARATOR 0x0008
LWSTDAPI_(int) PathGetDriveNumber%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathIsDirectory%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathIsDirectoryEmpty%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathIsFileSpec%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathIsPrefix%(LPCTSTR% pszPrefix, LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathIsRelative%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathIsRoot%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathIsSameRoot%(LPCTSTR% pszPath1, LPCTSTR% pszPath2);LWSTDAPI_(BOOL) PathIsUNC%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathIsNetworkPath%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathIsUNCServer%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathIsUNCServerShare%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathIsContentTypeA(LPCSTR pszPath, LPCSTR pszContentType);LWSTDAPI_(BOOL) PathIsContentTypeW(LPCWSTR pszPath, LPCWSTR pszContentType);LWSTDAPI_(BOOL) PathIsURL%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathMakePrettyA(LPSTR pszPath);LWSTDAPI_(BOOL) PathMakePrettyW(LPWSTR pszPath);LWSTDAPI_(BOOL) PathMatchSpecA(LPCSTR pszFile, LPCSTR pszSpec);LWSTDAPI_(BOOL) PathMatchSpecW(LPCWSTR pszFile, LPCWSTR pszSpec);LWSTDAPI_(int) PathParseIconLocationA(LPSTR pszIconFile);LWSTDAPI_(int) PathParseIconLocationW(LPWSTR pszIconFile);LWSTDAPI_(void) PathQuoteSpacesA(LPSTR lpsz);LWSTDAPI_(void) PathQuoteSpacesW(LPWSTR lpsz);LWSTDAPI_(BOOL) PathRelativePathToA(LPSTR pszPath, LPCSTR pszFrom, DWORD dwAttrFrom, LPCSTR pszTo, DWORD dwAttrTo);LWSTDAPI_(BOOL) PathRelativePathToW(LPWSTR pszPath, LPCWSTR pszFrom, DWORD dwAttrFrom, LPCWSTR pszTo, DWORD dwAttrTo);LWSTDAPI_(void) PathRemoveArgsA(LPSTR pszPath);LWSTDAPI_(void) PathRemoveArgsW(LPWSTR pszPath);LWSTDAPI_(LPTSTR%) PathRemoveBackslash%(LPTSTR% pszPath);LWSTDAPI_(void) PathRemoveBlanksA(LPSTR pszPath);LWSTDAPI_(void) PathRemoveBlanksW(LPWSTR pszPath);LWSTDAPI_(void) PathRemoveExtensionA(LPSTR pszPath);LWSTDAPI_(void) PathRemoveExtensionW(LPWSTR pszPath);LWSTDAPI_(BOOL) PathRemoveFileSpecA(LPSTR pszPath);LWSTDAPI_(BOOL) PathRemoveFileSpecW(LPWSTR pszPath);LWSTDAPI_(BOOL) PathRenameExtensionA(LPSTR pszPath, LPCSTR pszExt);LWSTDAPI_(BOOL) PathRenameExtensionW(LPWSTR pszPath, LPCWSTR pszExt);LWSTDAPI_(BOOL) PathSearchAndQualifyA(LPCSTR pszPath, LPSTR pszBuf, UINT cchBuf);LWSTDAPI_(BOOL) PathSearchAndQualifyW(LPCWSTR pszPath, LPWSTR pszBuf, UINT cchBuf);LWSTDAPI_(void) PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath);LWSTDAPI_(void) PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR pszPath);LWSTDAPI_(LPTSTR%) PathSkipRoot%(LPCTSTR% pszPath);LWSTDAPI_(void) PathStripPath%(LPTSTR% pszPath);LWSTDAPI_(BOOL) PathStripToRoot%(LPTSTR% pszPath);LWSTDAPI_(void) PathUnquoteSpacesA(LPSTR lpsz);LWSTDAPI_(void) PathUnquoteSpacesW(LPWSTR lpsz);LWSTDAPI_(BOOL) PathMakeSystemFolder%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathUnmakeSystemFolder%(LPCTSTR% pszPath);LWSTDAPI_(BOOL) PathIsSystemFolder%(LPCTSTR% pszPath, DWORD dwAttrb);LWSTDAPI_(void) PathUndecorate%(LPTSTR% pszPath);LWSTDAPI_(BOOL) PathUnExpandEnvStrings%(LPCTSTR% pszPath, LPTSTR% pszBuf, UINT cchBuf);
;begin_internal
#if (_WIN32_IE >= 0x0501)
LWSTDAPI_(BOOL) PathUnExpandEnvStringsForUser%(HANDLE hToken, LPCTSTR% pszPath, LPTSTR% pszBuf, UINT cchBuf);LWSTDAPI_(void) PrettifyFileDescription%(LPTSTR pszDesc%, LPCTSTR% pszCutList);
#endif // (_WIN32_IE >= 0x0501)
#if defined(WINNT) && (_WIN32_IE >= 0x0550)//====== ACL helpers ==================================================
//// shell struct to identify user/group for each ACE//typedef struct _SHELL_USER_SID{ SID_IDENTIFIER_AUTHORITY sidAuthority; DWORD dwUserGroupID; DWORD dwUserID;} SHELL_USER_SID, *PSHELL_USER_SID;
//// common SHELL_USER_SID's//// NOTE: you need to link to stocklib.lib to resolve these//extern const SHELL_USER_SID susCurrentUser; // the current user extern const SHELL_USER_SID susSystem; // the "SYSTEM" groupextern const SHELL_USER_SID susAdministrators; // the "Administrators" groupextern const SHELL_USER_SID susPowerUsers; // the "Power Users" groupextern const SHELL_USER_SID susGuests; // the "Guests" groupextern const SHELL_USER_SID susEveryone; // the "Everyone" group
//// shell struct that is passed to GetShellSecurityDescriptor()//typedef struct _SHELL_USER_PERMISSION{ SHELL_USER_SID susID; // identifies the user for whom you want to grant permissions to DWORD dwAccessType; // this is either ACCESS_ALLOWED_ACE_TYPE or ACCESS_DENIED_ACE_TYPE BOOL fInherit; // the permissions inheritable? (eg a directory or reg key and you want new children to inherit this permission) DWORD dwAccessMask; // access granted (eg FILE_LIST_CONTENTS, KEY_ALL_ACCESS, etc...) DWORD dwInheritMask; // mask used for inheritance, usually (OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE) DWORD dwInheritAccessMask; // the inheritable access granted (eg GENERIC_ALL)} SHELL_USER_PERMISSION, *PSHELL_USER_PERMISSION;
//// The GetShellSecurityDescriptor API takes an array of PSHELL_USER_PERMISSION's// and returns a PSECURITY_DESCRIPTOR based on those permission (an ACL is// contained in the PSECURITY_DESCRIPTOR).//// NOTE: The PSECURITY_DESCRIPTOR returned to the caller must be freed with LocalFree()// if it is non-null.////// Parameters:// apUserPerm - Array of shell_user_permission structs that defines what type// of access various users are allowed//// cUserPerm - count of elements in apUserPerm.//// Returns:// SECURITY_DESCRIPTOR* or NULL if failed.//LWSTDAPI_(SECURITY_DESCRIPTOR*) GetShellSecurityDescriptor(PSHELL_USER_PERMISSION* apUserPerm, int cUserPerm);#endif // defined(WINNT) && (_WIN32_IE >= 0x0550)
;end_internal
#ifdef UNICODE#define PathAppend PathAppendW#define PathCanonicalize PathCanonicalizeW#define PathCompactPath PathCompactPathW#define PathCompactPathEx PathCompactPathExW#define PathCommonPrefix PathCommonPrefixW#define PathFindOnPath PathFindOnPathW#define PathGetCharType PathGetCharTypeW#define PathIsContentType PathIsContentTypeW#define PathIsHTMLFile PathIsHTMLFileW#define PathMakePretty PathMakePrettyW#define PathMatchSpec PathMatchSpecW#define PathParseIconLocation PathParseIconLocationW#define PathQuoteSpaces PathQuoteSpacesW#define PathRelativePathTo PathRelativePathToW#define PathRemoveArgs PathRemoveArgsW#define PathRemoveBlanks PathRemoveBlanksW#define PathRemoveExtension PathRemoveExtensionW#define PathRemoveFileSpec PathRemoveFileSpecW#define PathRenameExtension PathRenameExtensionW#define PathSearchAndQualify PathSearchAndQualifyW#define PathSetDlgItemPath PathSetDlgItemPathW#define PathUnquoteSpaces PathUnquoteSpacesW#else#define PathAppend PathAppendA#define PathCanonicalize PathCanonicalizeA#define PathCompactPath PathCompactPathA#define PathCompactPathEx PathCompactPathExA#define PathCommonPrefix PathCommonPrefixA#define PathFindOnPath PathFindOnPathA#define PathGetCharType PathGetCharTypeA#define PathIsContentType PathIsContentTypeA#define PathIsHTMLFile PathIsHTMLFileA#define PathMakePretty PathMakePrettyA#define PathMatchSpec PathMatchSpecA#define PathParseIconLocation PathParseIconLocationA#define PathQuoteSpaces PathQuoteSpacesA#define PathRelativePathTo PathRelativePathToA#define PathRemoveArgs PathRemoveArgsA#define PathRemoveBlanks PathRemoveBlanksA#define PathRemoveExtension PathRemoveExtensionA#define PathRemoveFileSpec PathRemoveFileSpecA#define PathRenameExtension PathRenameExtensionA#define PathSearchAndQualify PathSearchAndQualifyA#define PathSetDlgItemPath PathSetDlgItemPathA#define PathUnquoteSpaces PathUnquoteSpacesA#endif
typedef enum { URL_SCHEME_INVALID = -1, URL_SCHEME_UNKNOWN = 0, URL_SCHEME_FTP, URL_SCHEME_HTTP, URL_SCHEME_GOPHER, URL_SCHEME_MAILTO, URL_SCHEME_NEWS, URL_SCHEME_NNTP, URL_SCHEME_TELNET, URL_SCHEME_WAIS, URL_SCHEME_FILE, URL_SCHEME_MK, URL_SCHEME_HTTPS, URL_SCHEME_SHELL, URL_SCHEME_SNEWS, URL_SCHEME_LOCAL, URL_SCHEME_JAVASCRIPT, URL_SCHEME_VBSCRIPT, URL_SCHEME_ABOUT, URL_SCHEME_RES, URL_SCHEME_MSSHELLROOTED, URL_SCHEME_MSSHELLIDLIST, URL_SCHEME_MSHELP, URL_SCHEME_MAXVALUE} URL_SCHEME;
typedef enum { URL_PART_NONE = 0, URL_PART_SCHEME = 1, URL_PART_HOSTNAME, URL_PART_USERNAME, URL_PART_PASSWORD, URL_PART_PORT, URL_PART_QUERY,} URL_PART;
typedef enum { URLIS_URL, URLIS_OPAQUE, URLIS_NOHISTORY, URLIS_FILEURL, URLIS_APPLIABLE, URLIS_DIRECTORY, URLIS_HASQUERY,} URLIS;
#define URL_UNESCAPE 0x10000000#define URL_ESCAPE_UNSAFE 0x20000000#define URL_PLUGGABLE_PROTOCOL 0x40000000#define URL_WININET_COMPATIBILITY 0x80000000#define URL_DONT_ESCAPE_EXTRA_INFO 0x02000000#define URL_DONT_UNESCAPE_EXTRA_INFO URL_DONT_ESCAPE_EXTRA_INFO#define URL_BROWSER_MODE URL_DONT_ESCAPE_EXTRA_INFO#define URL_ESCAPE_SPACES_ONLY 0x04000000#define URL_DONT_SIMPLIFY 0x08000000#define URL_NO_META URL_DONT_SIMPLIFY#define URL_UNESCAPE_INPLACE 0x00100000#define URL_CONVERT_IF_DOSPATH 0x00200000#define URL_UNESCAPE_HIGH_ANSI_ONLY 0x00400000#define URL_INTERNAL_PATH 0x00800000 // Will escape #'s in paths#define URL_FILE_USE_PATHURL 0x00010000#define URL_ESCAPE_PERCENT 0x00001000#define URL_ESCAPE_SEGMENT_ONLY 0x00002000 // Treat the entire URL param as one URL segment.
#define URL_PARTFLAG_KEEPSCHEME 0x00000001
#define URL_APPLY_DEFAULT 0x00000001#define URL_APPLY_GUESSSCHEME 0x00000002#define URL_APPLY_GUESSFILE 0x00000004#define URL_APPLY_FORCEAPPLY 0x00000008
LWSTDAPI_(int) UrlCompareA(LPCSTR psz1, LPCSTR psz2, BOOL fIgnoreSlash);LWSTDAPI_(int) UrlCompareW(LPCWSTR psz1, LPCWSTR psz2, BOOL fIgnoreSlash);LWSTDAPI UrlCombineA(LPCSTR pszBase, LPCSTR pszRelative, LPSTR pszCombined, LPDWORD pcchCombined, DWORD dwFlags);LWSTDAPI UrlCombineW(LPCWSTR pszBase, LPCWSTR pszRelative, LPWSTR pszCombined, LPDWORD pcchCombined, DWORD dwFlags);LWSTDAPI UrlCanonicalizeA(LPCSTR pszUrl, LPSTR pszCanonicalized, LPDWORD pcchCanonicalized, DWORD dwFlags);LWSTDAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized, LPDWORD pcchCanonicalized, DWORD dwFlags);LWSTDAPI_(BOOL) UrlIsOpaqueA(LPCSTR pszURL);LWSTDAPI_(BOOL) UrlIsOpaqueW(LPCWSTR pszURL);LWSTDAPI_(BOOL) UrlIsNoHistoryA(LPCSTR pszURL);LWSTDAPI_(BOOL) UrlIsNoHistoryW(LPCWSTR pszURL);#define UrlIsFileUrlA(pszURL) UrlIsA(pszURL, URLIS_FILEURL)#define UrlIsFileUrlW(pszURL) UrlIsW(pszURL, URLIS_FILEURL)LWSTDAPI_(BOOL) UrlIsA(LPCSTR pszUrl, URLIS UrlIs);LWSTDAPI_(BOOL) UrlIsW(LPCWSTR pszUrl, URLIS UrlIs);LWSTDAPI_(LPCSTR) UrlGetLocationA(LPCSTR psz1);LWSTDAPI_(LPCWSTR) UrlGetLocationW(LPCWSTR psz1);LWSTDAPI UrlUnescapeA(LPSTR pszUrl, LPSTR pszUnescaped, LPDWORD pcchUnescaped, DWORD dwFlags);LWSTDAPI UrlUnescapeW(LPWSTR pszUrl, LPWSTR pszUnescaped, LPDWORD pcchUnescaped, DWORD dwFlags);LWSTDAPI UrlEscapeA(LPCSTR pszUrl, LPSTR pszEscaped, LPDWORD pcchEscaped, DWORD dwFlags);LWSTDAPI UrlEscapeW(LPCWSTR pszUrl, LPWSTR pszEscaped, LPDWORD pcchEscaped, DWORD dwFlags);LWSTDAPI UrlCreateFromPathA(LPCSTR pszPath, LPSTR pszUrl, LPDWORD pcchUrl, DWORD dwFlags);LWSTDAPI UrlCreateFromPathW(LPCWSTR pszPath, LPWSTR pszUrl, LPDWORD pcchUrl, DWORD dwFlags);LWSTDAPI PathCreateFromUrlA(LPCSTR pszUrl, LPSTR pszPath, LPDWORD pcchPath, DWORD dwFlags);LWSTDAPI PathCreateFromUrlW(LPCWSTR pszUrl, LPWSTR pszPath, LPDWORD pcchPath, DWORD dwFlags);LWSTDAPI UrlHashA(LPCSTR pszUrl, LPBYTE pbHash, DWORD cbHash);LWSTDAPI UrlHashW(LPCWSTR pszUrl, LPBYTE pbHash, DWORD cbHash);LWSTDAPI UrlGetPartW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, DWORD dwPart, DWORD dwFlags);LWSTDAPI UrlGetPartA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut, DWORD dwPart, DWORD dwFlags);LWSTDAPI UrlApplySchemeA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut, DWORD dwFlags);LWSTDAPI UrlApplySchemeW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, DWORD dwFlags);LWSTDAPI HashData(LPBYTE pbData, DWORD cbData, LPBYTE pbHash, DWORD cbHash);
;begin_internalLWSTDAPI UrlFixupW(LPCWSTR pszIn, LPWSTR pszOut, DWORD cchOut);
// NTRAID:108139 akabir We need to move the components stuff from wininet.h to shlwapi.
typedef WORD SHINTERNET_PORT;typedef SHINTERNET_PORT * LPSHINTERNET_PORT;
//// SHINTERNET_SCHEME - enumerated URL scheme type//
typedef enum { SHINTERNET_SCHEME_PARTIAL = -2, SHINTERNET_SCHEME_UNKNOWN = -1, SHINTERNET_SCHEME_DEFAULT = 0, SHINTERNET_SCHEME_FTP, SHINTERNET_SCHEME_GOPHER, SHINTERNET_SCHEME_HTTP, SHINTERNET_SCHEME_HTTPS, SHINTERNET_SCHEME_FILE, SHINTERNET_SCHEME_NEWS, SHINTERNET_SCHEME_MAILTO, SHINTERNET_SCHEME_SOCKS, SHINTERNET_SCHEME_JAVASCRIPT, SHINTERNET_SCHEME_VBSCRIPT, SHINTERNET_SCHEME_RES, SHINTERNET_SCHEME_FIRST = SHINTERNET_SCHEME_FTP, SHINTERNET_SCHEME_LAST = SHINTERNET_SCHEME_RES} SHINTERNET_SCHEME, * LPSHINTERNET_SCHEME;
//// SHURL_COMPONENTS - the constituent parts of an URL. Used in InternetCrackUrl()// and InternetCreateUrl()//// For InternetCrackUrl(), if a pointer field and its corresponding length field// are both 0 then that component is not returned. If the pointer field is NULL// but the length field is not zero, then both the pointer and length fields are// returned if both pointer and corresponding length fields are non-zero then// the pointer field points to a buffer where the component is copied. The// component may be un-escaped, depending on dwFlags//// For InternetCreateUrl(), the pointer fields should be NULL if the component// is not required. If the corresponding length field is zero then the pointer// field is the address of a zero-terminated string. If the length field is not// zero then it is the string length of the corresponding pointer field//
#pragma warning( disable : 4121 ) // disable alignment warning
typedef struct { DWORD dwStructSize; // size of this structure. Used in version check LPTSTR% lpszScheme; // pointer to scheme name DWORD dwSchemeLength; // length of scheme name SHINTERNET_SCHEME nScheme; // enumerated scheme type (if known) LPTSTR% lpszHostName; // pointer to host name DWORD dwHostNameLength; // length of host name SHINTERNET_PORT nPort; // converted port number LPTSTR% lpszUserName; // pointer to user name DWORD dwUserNameLength; // length of user name LPTSTR% lpszPassword; // pointer to password DWORD dwPasswordLength; // length of password LPTSTR% lpszUrlPath; // pointer to URL-path DWORD dwUrlPathLength; // length of URL-path LPTSTR% lpszExtraInfo; // pointer to extra information (e.g. ?foo or #foo) DWORD dwExtraInfoLength; // length of extra information} SHURL_COMPONENTS%, * LPSHURL_COMPONENTS%;
BOOL WINAPI UrlCrackW(LPCWSTR lpszUrl, DWORD dwUrlLength, DWORD dwFlags, LPSHURL_COMPONENTSW lpUrlComponents);
;end_internal
#ifdef UNICODE#define UrlCompare UrlCompareW#define UrlCombine UrlCombineW#define UrlCanonicalize UrlCanonicalizeW#define UrlIsOpaque UrlIsOpaqueW#define UrlIsFileUrl UrlIsFileUrlW#define UrlGetLocation UrlGetLocationW#define UrlUnescape UrlUnescapeW#define UrlEscape UrlEscapeW#define UrlCreateFromPath UrlCreateFromPathW#define PathCreateFromUrl PathCreateFromUrlW#define UrlHash UrlHashW#define UrlGetPart UrlGetPartW#define UrlApplyScheme UrlApplySchemeW#define UrlIs UrlIsW
;begin_internal#define UrlFixup UrlFixupW;end_internal
#else //!UNICODE#define UrlCompare UrlCompareA#define UrlCombine UrlCombineA#define UrlCanonicalize UrlCanonicalizeA#define UrlIsOpaque UrlIsOpaqueA#define UrlIsFileUrl UrlIsFileUrlA#define UrlGetLocation UrlGetLocationA#define UrlUnescape UrlUnescapeA#define UrlEscape UrlEscapeA#define UrlCreateFromPath UrlCreateFromPathA#define PathCreateFromUrl PathCreateFromUrlA#define UrlHash UrlHashA#define UrlGetPart UrlGetPartA#define UrlApplyScheme UrlApplySchemeA#define UrlIs UrlIsA
;begin_internal// no UrlFixupA;end_internal
#endif //UNICODE
#define UrlEscapeSpaces(pszUrl, pszEscaped, pcchEscaped) UrlCanonicalize(pszUrl, pszEscaped, pcchEscaped, URL_ESCAPE_SPACES_ONLY |URL_DONT_ESCAPE_EXTRA_INFO )#define UrlUnescapeInPlace(pszUrl, dwFlags) UrlUnescape(pszUrl, NULL, NULL, dwFlags | URL_UNESCAPE_INPLACE)
;begin_internal//// Internal APIs which we're not yet sure whether to make public//
// Private IHlinkFrame::Navigate flags related to history// This navigate should not go in the History ShellFolder#define SHHLNF_WRITENOHISTORY 0x08000000// This navigate should not automatically select History ShellFolder#define SHHLNF_NOAUTOSELECT 0x04000000
// The order of these flags is important. See the source before// changing these.
#define PFOPEX_NONE 0x00000000#define PFOPEX_PIF 0x00000001#define PFOPEX_COM 0x00000002#define PFOPEX_EXE 0x00000004#define PFOPEX_BAT 0x00000008#define PFOPEX_LNK 0x00000010#define PFOPEX_CMD 0x00000020#define PFOPEX_OPTIONAL 0x00000040 // Search only if Extension not present#define PFOPEX_DEFAULT (PFOPEX_CMD | PFOPEX_COM | PFOPEX_BAT | PFOPEX_PIF | PFOPEX_EXE | PFOPEX_LNK)
LWSTDAPI_(BOOL) PathFileExistsDefExt%(LPTSTR% pszPath, UINT uFlags);LWSTDAPI_(BOOL) PathFindOnPathEx%(LPTSTR% pszPath, LPCTSTR% * ppszOtherDirs, UINT uFlags);LWSTDAPI_(LPCTSTR%) PathSkipLeadingSlashes%(LPCTSTR% pszURL);
LWSTDAPI_(UINT) SHGetSystemWindowsDirectory%(LPTSTR% lpBuffer, UINT uSize);
#if (_WIN32_IE >= 0x0501)//// These are functions that used to be duplicated in shell32, but have// be consolidated here. They are exported privately until someone decides// we really want to document them.//LWSTDAPI_(BOOL) PathFileExistsAndAttributes%(LPCTSTR% pszPath, OPTIONAL DWORD* pdwAttributes);LWSTDAPI_(BOOL) PathFileExistsDefExtAndAttributes%(LPTSTR% pszPath, UINT uFlags, DWORD *pdwAttribs);LWSTDAPI_(void) FixSlashesAndColon%(LPTSTR% pszPath);LWSTDAPI_(LPCTSTR%) NextPath%(LPCTSTR% lpPath, LPTSTR% szPath, int cchPath);LWSTDAPI_(LPTSTR%) CharUpperNoDBCS%(LPTSTR% psz);LWSTDAPI_(LPTSTR%) CharLowerNoDBCS%(LPTSTR% psz);
//// flags for PathIsValidChar()//#define PIVC_ALLOW_QUESTIONMARK 0x00000001 // treat '?' as valid#define PIVC_ALLOW_STAR 0x00000002 // treat '*' as valid#define PIVC_ALLOW_DOT 0x00000004 // treat '.' as valid#define PIVC_ALLOW_SLASH 0x00000008 // treat '\\' as valid#define PIVC_ALLOW_COLON 0x00000010 // treat ':' as valid#define PIVC_ALLOW_SEMICOLON 0x00000020 // treat ';' as valid#define PIVC_ALLOW_COMMA 0x00000040 // treat ',' as valid#define PIVC_ALLOW_SPACE 0x00000080 // treat ' ' as valid#define PIVC_ALLOW_NONALPAHABETIC 0x00000100 // treat non-alphabetic exteneded chars as valid#define PIVC_ALLOW_QUOTE 0x00000200 // treat '"' as valid
//// standard masks for PathIsValidChar()//#define PIVC_SFN_NAME (PIVC_ALLOW_DOT | PIVC_ALLOW_NONALPAHABETIC)#define PIVC_SFN_FULLPATH (PIVC_SFN_NAME | PIVC_ALLOW_COLON | PIVC_ALLOW_SLASH)#define PIVC_LFN_NAME (PIVC_ALLOW_DOT | PIVC_ALLOW_NONALPAHABETIC | PIVC_ALLOW_SEMICOLON | PIVC_ALLOW_COMMA | PIVC_ALLOW_SPACE)#define PIVC_LFN_FULLPATH (PIVC_LFN_NAME | PIVC_ALLOW_COLON | PIVC_ALLOW_SLASH)#define PIVC_SFN_FILESPEC (PIVC_SFN_FULLPATH | PIVC_ALLOW_STAR | PIVC_ALLOW_QUESTIONMARK)#define PIVC_LFN_FILESPEC (PIVC_LFN_FULLPATH | PIVC_ALLOW_STAR | PIVC_ALLOW_QUESTIONMARK)
LWSTDAPI_(BOOL) PathIsValidCharA(UCHAR ch, DWORD dwFlags);LWSTDAPI_(BOOL) PathIsValidCharW(WCHAR ch, DWORD dwFlags);#ifdef UNICODE#define PathIsValidChar PathIsValidCharW#else#define PathIsValidChar PathIsValidCharA#endif // !UNICODE
#endif // (_WIN32_IE >= 0x0501)
// parsed URL information returned by ParseURL()//// Internet_CrackURL is the correct function for external components// to use. URL.DLL calls this function to do some work and the shell// uses this function as a leight-weight parsing function as well.
typedef struct tagPARSEDURL% { DWORD cbSize; // Pointers into the buffer that was provided to ParseURL LPCTSTR% pszProtocol; UINT cchProtocol; LPCTSTR% pszSuffix; UINT cchSuffix; UINT nScheme; // One of URL_SCHEME_* } PARSEDURL%, * PPARSEDURL%;
LWSTDAPI ParseURL%(LPCTSTR% pcszURL, PARSEDURL% * ppu);
;end_internal
;begin_both
#endif // NO_SHLWAPI_PATH
;end_both
;begin_both
#ifndef NO_SHLWAPI_REG////=============== Registry Routines ===================================//
;end_both// SHDeleteEmptyKey mimics RegDeleteKey as it behaves on NT.// SHDeleteKey mimics RegDeleteKey as it behaves on Win95.
LWSTDAPI_(DWORD) SHDeleteEmptyKey%(HKEY hkey, LPCTSTR% pszSubKey);LWSTDAPI_(DWORD) SHDeleteKey%(HKEY hkey, LPCTSTR% pszSubKey);LWSTDAPI_(HKEY) SHRegDuplicateHKey(HKEY hkey);
;begin_internal// BUGBUG (scotth): SHDeleteOrphanKey is the old name for SHDeleteEmptyKey.// This will be removed soon. SHDeleteOrphanKey already// maps to SHDeleteEmptyKey in the DLL exports.
LWSTDAPI_(DWORD) SHDeleteOrphanKey%(HKEY hkey, LPCTSTR% pszSubKey);;end_internal
// These functions open the key, get/set/delete the value, then close// the key.
LWSTDAPI_(DWORD) SHDeleteValue%(HKEY hkey, LPCTSTR% pszSubKey, LPCTSTR% pszValue);LWSTDAPI_(DWORD) SHGetValue%(HKEY hkey, LPCTSTR% pszSubKey, LPCTSTR% pszValue, DWORD *pdwType, void *pvData, DWORD *pcbData);LWSTDAPI_(DWORD) SHSetValue%(HKEY hkey, LPCTSTR% pszSubKey, LPCTSTR% pszValue, DWORD dwType, LPCVOID pvData, DWORD cbData);
// These functions work just like RegQueryValueEx, except if the// data type is REG_EXPAND_SZ, then these will go ahead and expand// out the string. *pdwType will always be massaged to REG_SZ// if this happens. REG_SZ values are also guaranteed to be null// terminated.
LWSTDAPI_(DWORD) SHQueryValueEx%(HKEY hkey, LPCTSTR% pszValue, DWORD *pdwReserved, DWORD *pdwType, void *pvData, DWORD *pcbData);
// Enumeration functions support.
LWSTDAPI_(LONG) SHEnumKeyExA(HKEY hkey, DWORD dwIndex, LPSTR pszName, LPDWORD pcchName);LWSTDAPI_(LONG) SHEnumKeyExW(HKEY hkey, DWORD dwIndex, LPWSTR pszName, LPDWORD pcchName);LWSTDAPI_(LONG) SHEnumValueA(HKEY hkey, DWORD dwIndex, LPSTR pszValueName, LPDWORD pcchValueName, LPDWORD pdwType, void *pvData, LPDWORD pcbData);LWSTDAPI_(LONG) SHEnumValueW(HKEY hkey, DWORD dwIndex, LPWSTR pszValueName, LPDWORD pcchValueName, LPDWORD pdwType, void *pvData, LPDWORD pcbData);LWSTDAPI_(LONG) SHQueryInfoKeyA(HKEY hkey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen);LWSTDAPI_(LONG) SHQueryInfoKeyW(HKEY hkey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen);
// recursive key copyLWSTDAPI_(DWORD) SHCopyKeyA(HKEY hkeySrc, LPCSTR szSrcSubKey, HKEY hkeyDest, DWORD fReserved);LWSTDAPI_(DWORD) SHCopyKeyW(HKEY hkeySrc, LPCWSTR wszSrcSubKey, HKEY hkeyDest, DWORD fReserved);
// Getting and setting file system paths with environment variables
LWSTDAPI_(DWORD) SHRegGetPathA(HKEY hKey, LPCSTR pcszSubKey, LPCSTR pcszValue, LPSTR pszPath, DWORD dwFlags);LWSTDAPI_(DWORD) SHRegGetPathW(HKEY hKey, LPCWSTR pcszSubKey, LPCWSTR pcszValue, LPWSTR pszPath, DWORD dwFlags);LWSTDAPI_(DWORD) SHRegSetPathA(HKEY hKey, LPCSTR pcszSubKey, LPCSTR pcszValue, LPCSTR pcszPath, DWORD dwFlags);LWSTDAPI_(DWORD) SHRegSetPathW(HKEY hKey, LPCWSTR pcszSubKey, LPCWSTR pcszValue, LPCWSTR pcszPath, DWORD dwFlags);
#ifdef UNICODE#define SHEnumKeyEx SHEnumKeyExW#define SHEnumValue SHEnumValueW#define SHQueryInfoKey SHQueryInfoKeyW#define SHCopyKey SHCopyKeyW#define SHRegGetPath SHRegGetPathW#define SHRegSetPath SHRegSetPathW#else#define SHEnumKeyEx SHEnumKeyExA#define SHEnumValue SHEnumValueA#define SHQueryInfoKey SHQueryInfoKeyA#define SHCopyKey SHCopyKeyA#define SHRegGetPath SHRegGetPathA#define SHRegSetPath SHRegSetPathA#endif
//////////////////////////////////////////////// User Specific Registry Access Functions//////////////////////////////////////////////
//// Type definitions.//
typedef enum{ SHREGDEL_DEFAULT = 0x00000000, // Delete's HKCU, or HKLM if HKCU is not found. SHREGDEL_HKCU = 0x00000001, // Delete HKCU only SHREGDEL_HKLM = 0x00000010, // Delete HKLM only. SHREGDEL_BOTH = 0x00000011, // Delete both HKCU and HKLM.} SHREGDEL_FLAGS;
typedef enum{ SHREGENUM_DEFAULT = 0x00000000, // Enumerates HKCU or HKLM if not found. SHREGENUM_HKCU = 0x00000001, // Enumerates HKCU only SHREGENUM_HKLM = 0x00000010, // Enumerates HKLM only. SHREGENUM_BOTH = 0x00000011, // Enumerates both HKCU and HKLM without duplicates. // This option is NYI.} SHREGENUM_FLAGS;
#define SHREGSET_HKCU 0x00000001 // Write to HKCU if empty.#define SHREGSET_FORCE_HKCU 0x00000002 // Write to HKCU.#define SHREGSET_HKLM 0x00000004 // Write to HKLM if empty.#define SHREGSET_FORCE_HKLM 0x00000008 // Write to 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 HUSKEY *PHUSKEY;
LWSTDAPI_(LONG) SHRegCreateUSKeyA(LPCSTR pszPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, DWORD dwFlags);LWSTDAPI_(LONG) SHRegCreateUSKeyW(LPCWSTR pwzPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, DWORD dwFlags);LWSTDAPI_(LONG) SHRegOpenUSKeyA(LPCSTR pszPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, BOOL fIgnoreHKCU);LWSTDAPI_(LONG) SHRegOpenUSKeyW(LPCWSTR pwzPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, BOOL fIgnoreHKCU);LWSTDAPI_(LONG) SHRegQueryUSValueA(HUSKEY hUSKey, LPCSTR pszValue, LPDWORD pdwType, void *pvData, LPDWORD pcbData, BOOL fIgnoreHKCU, void *pvDefaultData, DWORD dwDefaultDataSize);LWSTDAPI_(LONG) SHRegQueryUSValueW(HUSKEY hUSKey, LPCWSTR pwzValue, LPDWORD pdwType, void *pvData, LPDWORD pcbData, BOOL fIgnoreHKCU, void *pvDefaultData, DWORD dwDefaultDataSize);LWSTDAPI_(LONG) SHRegWriteUSValueA(HUSKEY hUSKey, LPCSTR pszValue, DWORD dwType, const void *pvData, DWORD cbData, DWORD dwFlags);LWSTDAPI_(LONG) SHRegWriteUSValueW(HUSKEY hUSKey, LPCWSTR pwzValue, DWORD dwType, const void *pvData, DWORD cbData, DWORD dwFlags);LWSTDAPI_(LONG) SHRegDeleteUSValueA(HUSKEY hUSKey, LPCSTR pszValue, SHREGDEL_FLAGS delRegFlags);LWSTDAPI_(LONG) SHRegDeleteEmptyUSKeyW(HUSKEY hUSKey, LPCWSTR pwzSubKey, SHREGDEL_FLAGS delRegFlags);LWSTDAPI_(LONG) SHRegDeleteEmptyUSKeyA(HUSKEY hUSKey, LPCSTR pszSubKey, SHREGDEL_FLAGS delRegFlags);LWSTDAPI_(LONG) SHRegDeleteUSValueW(HUSKEY hUSKey, LPCWSTR pwzValue, SHREGDEL_FLAGS delRegFlags);LWSTDAPI_(LONG) SHRegEnumUSKeyA(HUSKEY hUSKey, DWORD dwIndex, LPSTR pszName, LPDWORD pcchName, SHREGENUM_FLAGS enumRegFlags);LWSTDAPI_(LONG) SHRegEnumUSKeyW(HUSKEY hUSKey, DWORD dwIndex, LPWSTR pwzName, LPDWORD pcchName, SHREGENUM_FLAGS enumRegFlags);LWSTDAPI_(LONG) SHRegEnumUSValueA(HUSKEY hUSkey, DWORD dwIndex, LPSTR pszValueName, LPDWORD pcchValueName, LPDWORD pdwType, void *pvData, LPDWORD pcbData, SHREGENUM_FLAGS enumRegFlags);LWSTDAPI_(LONG) SHRegEnumUSValueW(HUSKEY hUSkey, DWORD dwIndex, LPWSTR pszValueName, LPDWORD pcchValueName, LPDWORD pdwType, void *pvData, LPDWORD pcbData, SHREGENUM_FLAGS enumRegFlags);LWSTDAPI_(LONG) SHRegQueryInfoUSKeyA(HUSKEY hUSKey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen, SHREGENUM_FLAGS enumRegFlags);LWSTDAPI_(LONG) SHRegQueryInfoUSKeyW(HUSKEY hUSKey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen, SHREGENUM_FLAGS enumRegFlags);LWSTDAPI_(LONG) SHRegCloseUSKey(HUSKEY hUSKey);
// These calls are equal to an SHRegOpenUSKey, SHRegQueryUSValue, and then a SHRegCloseUSKey.LWSTDAPI_(LONG) SHRegGetUSValueA(LPCSTR pszSubKey, LPCSTR pszValue, LPDWORD pdwType, void * pvData, LPDWORD pcbData, BOOL fIgnoreHKCU, void *pvDefaultData, DWORD dwDefaultDataSize);LWSTDAPI_(LONG) SHRegGetUSValueW(LPCWSTR pwzSubKey, LPCWSTR pwzValue, LPDWORD pdwType, void * pvData, LPDWORD pcbData, BOOL fIgnoreHKCU, void *pvDefaultData, DWORD dwDefaultDataSize);LWSTDAPI_(LONG) SHRegSetUSValueA(LPCSTR pszSubKey, LPCSTR pszValue, DWORD dwType, const void *pvData, DWORD cbData, DWORD dwFlags);LWSTDAPI_(LONG) SHRegSetUSValueW(LPCWSTR pwzSubKey, LPCWSTR pwzValue, DWORD dwType, const void *pvData, DWORD cbData, DWORD dwFlags);LWSTDAPI_(int) SHRegGetIntW(HKEY hk, LPCWSTR pwzKey, int iDefault);
#ifdef UNICODE#define SHRegCreateUSKey SHRegCreateUSKeyW#define SHRegOpenUSKey SHRegOpenUSKeyW#define SHRegQueryUSValue SHRegQueryUSValueW#define SHRegWriteUSValue SHRegWriteUSValueW#define SHRegDeleteUSValue SHRegDeleteUSValueW#define SHRegDeleteEmptyUSKey SHRegDeleteEmptyUSKeyW#define SHRegEnumUSKey SHRegEnumUSKeyW#define SHRegEnumUSValue SHRegEnumUSValueW#define SHRegQueryInfoUSKey SHRegQueryInfoUSKeyW#define SHRegGetUSValue SHRegGetUSValueW#define SHRegSetUSValue SHRegSetUSValueW#define SHRegGetInt SHRegGetIntW#else#define SHRegCreateUSKey SHRegCreateUSKeyA#define SHRegOpenUSKey SHRegOpenUSKeyA#define SHRegQueryUSValue SHRegQueryUSValueA#define SHRegWriteUSValue SHRegWriteUSValueA#define SHRegDeleteUSValue SHRegDeleteUSValueA#define SHRegDeleteEmptyUSKey SHRegDeleteEmptyUSKeyA#define SHRegEnumUSKey SHRegEnumUSKeyA#define SHRegEnumUSValue SHRegEnumUSValueA#define SHRegQueryInfoUSKey SHRegQueryInfoUSKeyA#define SHRegGetUSValue SHRegGetUSValueA#define SHRegSetUSValue SHRegSetUSValueA#endif
LWSTDAPI_(BOOL) SHRegGetBoolUSValueA(LPCSTR pszSubKey, LPCSTR pszValue, BOOL fIgnoreHKCU, BOOL fDefault);LWSTDAPI_(BOOL) SHRegGetBoolUSValueW(LPCWSTR pszSubKey, LPCWSTR pszValue, BOOL fIgnoreHKCU, BOOL fDefault);
#ifdef UNICODE#define SHRegGetBoolUSValue SHRegGetBoolUSValueW#else#define SHRegGetBoolUSValue SHRegGetBoolUSValueA#endif
//// Association APIs//// these APIs are to assist in accessing the data in HKCR// getting the Command strings and exe paths// for different verbs and extensions are simplified this way//
enum { ASSOCF_INIT_NOREMAPCLSID = 0x00000001, // do not remap clsids to progids ASSOCF_INIT_BYEXENAME = 0x00000002, // executable is being passed in ASSOCF_OPEN_BYEXENAME = 0x00000002, // executable is being passed in ASSOCF_INIT_DEFAULTTOSTAR = 0x00000004, // treat "*" as the BaseClass ASSOCF_INIT_DEFAULTTOFOLDER = 0x00000008, // treat "Folder" as the BaseClass ASSOCF_NOUSERSETTINGS = 0x00000010, // dont use HKCU ASSOCF_NOTRUNCATE = 0x00000020, // dont truncate the return string ASSOCF_VERIFY = 0x00000040, // verify data is accurate (DISK HITS) ASSOCF_REMAPRUNDLL = 0x00000080, // actually gets info about rundlls target if applicable ASSOCF_NOFIXUPS = 0x00000100, // attempt to fix errors if found ASSOCF_IGNOREBASECLASS = 0x00000200, // dont recurse into the baseclass};
typedef DWORD ASSOCF;
typedef enum { ASSOCSTR_COMMAND = 1, // shell\verb\command string ASSOCSTR_EXECUTABLE, // the executable part of command string ASSOCSTR_FRIENDLYDOCNAME, // friendly name of the document type ASSOCSTR_FRIENDLYAPPNAME, // friendly name of executable ASSOCSTR_NOOPEN, // noopen value ASSOCSTR_SHELLNEWVALUE, // query values under the shellnew key ASSOCSTR_DDECOMMAND, // template for DDE commands ASSOCSTR_DDEIFEXEC, // DDECOMMAND to use if just create a process ASSOCSTR_DDEAPPLICATION, // Application 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_QUICKTIP, // same as ASSOCSTR_INFOTIP, except, this list contains only quickly retrievable properties ASSOCSTR_TILEINFO, // similar to ASSOCSTR_INFOTIP - lists important properties for tileview ASSOCSTR_CONTENTTYPE, // MIME Content type ASSOCSTR_DEFAULTICON, // Default icon source ASSOCSTR_SHELLEXTENSION, // Guid string pointing to the Shellex\Shellextensionhandler value. ASSOCSTR_MAX // last item in enum...} ASSOCSTR;
typedef enum { ASSOCKEY_SHELLEXECCLASS = 1, // the key that should be passed to ShellExec(hkeyClass) ASSOCKEY_APP, // the "Application" key for the association ASSOCKEY_CLASS, // the progid or class key ASSOCKEY_BASECLASS, // the BaseClass key ASSOCKEY_MAX // last item in enum...} ASSOCKEY;
typedef enum { ASSOCDATA_MSIDESCRIPTOR = 1, // Component Descriptor to pass to MSI APIs ASSOCDATA_NOACTIVATEHANDLER, // restrict attempts to activate window ASSOCDATA_QUERYCLASSSTORE, // should check with the NT Class Store ASSOCDATA_HASPERUSERASSOC, // defaults to user specified association ASSOCDATA_EDITFLAGS, // Edit flags. ASSOCDATA_VALUE, // use pszExtra as the Value name ASSOCDATA_MAX} ASSOCDATA;
typedef enum { ASSOCENUM_NONE} ASSOCENUM;
#undef INTERFACE#define INTERFACE IQueryAssociations
DECLARE_INTERFACE_( IQueryAssociations, IUnknown ){ // IUnknown methods STDMETHOD (QueryInterface)(THIS_ REFIID riid, void **ppv) PURE; STDMETHOD_(ULONG, AddRef) ( THIS ) PURE; STDMETHOD_(ULONG, Release) ( THIS ) PURE;
// IQueryAssociations methods STDMETHOD (Init)(THIS_ ASSOCF flags, LPCWSTR pszAssoc, HKEY hkProgid, HWND hwnd) PURE; STDMETHOD (GetString)(THIS_ ASSOCF flags, ASSOCSTR str, LPCWSTR pszExtra, LPWSTR pszOut, DWORD *pcchOut) PURE; STDMETHOD (GetKey)(THIS_ ASSOCF flags, ASSOCKEY key, LPCWSTR pszExtra, HKEY *phkeyOut) PURE; STDMETHOD (GetData)(THIS_ ASSOCF flags, ASSOCDATA data, LPCWSTR pszExtra, LPVOID pvOut, DWORD *pcbOut) PURE; STDMETHOD (GetEnum)(THIS_ ASSOCF flags, ASSOCENUM assocenum, LPCWSTR pszExtra, REFIID riid, LPVOID *ppvOut) PURE;};
;begin_internal
typedef struct tagAssocDDEExec{ LPCWSTR pszDDEExec; LPCWSTR pszApplication; LPCWSTR pszTopic; BOOL fNoActivateHandler;} ASSOCDDEEXEC;
typedef struct tagAssocVerb{ LPCWSTR pszVerb; LPCWSTR pszTitle; LPCWSTR pszFriendlyAppName; LPCWSTR pszApplication; LPCWSTR pszParams; ASSOCDDEEXEC *pDDEExec;} ASSOCVERB;
typedef struct tagAssocShell{ ASSOCVERB *rgVerbs; DWORD cVerbs; DWORD iDefaultVerb;} ASSOCSHELL;
typedef struct tagAssocProgid{ DWORD cbSize; LPCWSTR pszProgid; LPCWSTR pszFriendlyDocName; LPCWSTR pszDefaultIcon; ASSOCSHELL *pShellKey; LPCWSTR pszExtensions;} ASSOCPROGID;
typedef struct tagAssocApp{ DWORD cbSize; LPCWSTR pszFriendlyAppName; ASSOCSHELL *pShellKey;} ASSOCAPP;
enum { ASSOCMAKEF_VERIFY = 0x00000040, // verify data is accurate (DISK HITS) ASSOCMAKEF_USEEXPAND = 0x00000200, // strings have environment vars and need REG_EXPAND_SZ ASSOCMAKEF_SUBSTENV = 0x00000400, // attempt to use std env if they match... ASSOCMAKEF_VOLATILE = 0x00000800, // the progid will not persist between sessions ASSOCMAKEF_DELETE = 0x00002000, // remove this association if possible};
typedef DWORD ASSOCMAKEF;
LWSTDAPI AssocMakeProgid(ASSOCMAKEF flags, LPCWSTR pszApplication, ASSOCPROGID *pProgid, HKEY *phkProgid);LWSTDAPI AssocMakeApp(ASSOCMAKEF flags, LPCWSTR pszApplication, ASSOCAPP *pApp, HKEY *phkApp);
LWSTDAPI AssocMakeApplicationByKey%(ASSOCMAKEF flags, HKEY hkAssoc, LPCTSTR% pszVerb);LWSTDAPI AssocMakeFileExtsToApplication%(ASSOCMAKEF flags, LPCTSTR% pszExt, LPCTSTR% pszApplication);
LWSTDAPI AssocCopyVerbs(HKEY hkSrc, HKEY hkDst);
;end_internal
LWSTDAPI AssocCreate(CLSID clsid, REFIID riid, LPVOID *ppv);
// wrappers for the interfaceLWSTDAPI AssocQueryString%(ASSOCF flags, ASSOCSTR str, LPCTSTR% pszAssoc, LPCTSTR% pszExtra, LPTSTR% pszOut, DWORD *pcchOut);LWSTDAPI AssocQueryStringByKey%(ASSOCF flags, ASSOCSTR str, HKEY hkAssoc, LPCTSTR% pszExtra, LPTSTR% pszOut, DWORD *pcchOut);LWSTDAPI AssocQueryKey%(ASSOCF flags, ASSOCKEY key, LPCTSTR% pszAssoc, LPCTSTR% pszExtra, HKEY *phkeyOut);
// 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.// dangerous file types should be handled more carefully than other file types.//// Parameter: pszAssoc - type to check. may be an extension or progid. (".exe" or "exefile" would both be valid)//// Returns: TRUE if the file type is dangerous.//// NOTES://// this API first checks a hardcoded list of known dangerous types.// then it checks the editflags for the file type looking for the FTA_AlwaysUnsafe bit.// then it checks Safer policies.// LWSTDAPI_(BOOL) AssocIsDangerous(LPCWSTR pszAssoc);
;begin_internal
typedef enum _SHELLKEY{ SKROOT_HKCU = 0x00000001, // internal to the function SKROOT_HKLM = 0x00000002, // internal to the function SKROOT_MASK = 0x0000000F, // internal to the function SKPATH_EXPLORER = 0x00000000, // internal to the function SKPATH_SHELL = 0x00000010, // internal to the function SKPATH_SHELLNOROAM = 0x00000020, // internal to the function SKPATH_CLASSES = 0x00000030, // internal to the function SKPATH_MASK = 0x00000FF0, // internal to the function SKSUB_NONE = 0x00000000, // internal to the function SKSUB_LOCALIZEDNAMES = 0x00001000, // internal to the function SKSUB_HANDLERS = 0x00002000, // internal to the function SKSUB_ASSOCIATIONS = 0x00003000, // internal to the function SKSUB_VOLATILE = 0x00004000, // internal to the function SKSUB_MUICACHE = 0x00005000, // internal to the function SKSUB_FILEEXTS = 0x00006000, // internal to the function SKSUB_MASK = 0x000FF000, // internal to the function
SHELLKEY_HKCU_EXPLORER = SKROOT_HKCU | SKPATH_EXPLORER | SKSUB_NONE, SHELLKEY_HKLM_EXPLORER = SKROOT_HKLM | SKPATH_EXPLORER | SKSUB_NONE, SHELLKEY_HKCU_SHELL = SKROOT_HKCU | SKPATH_SHELL | SKSUB_NONE, SHELLKEY_HKLM_SHELL = SKROOT_HKLM | SKPATH_SHELL | SKSUB_NONE, SHELLKEY_HKCU_SHELLNOROAM = SKROOT_HKCU | SKPATH_SHELLNOROAM | SKSUB_NONE, SHELLKEY_HKCULM_SHELL = SHELLKEY_HKCU_SHELLNOROAM, SHELLKEY_HKCULM_CLASSES = SKROOT_HKCU | SKPATH_CLASSES | SKSUB_NONE, SHELLKEY_HKCU_LOCALIZEDNAMES = SKROOT_HKCU | SKPATH_SHELL | SKSUB_LOCALIZEDNAMES, SHELLKEY_HKCULM_HANDLERS = SKROOT_HKCU | SKPATH_SHELLNOROAM | SKSUB_HANDLERS, SHELLKEY_HKCULM_ASSOCIATIONS = SKROOT_HKCU | SKPATH_SHELLNOROAM | SKSUB_ASSOCIATIONS, SHELLKEY_HKCULM_VOLATILE = SKROOT_HKCU | SKPATH_SHELLNOROAM | SKSUB_VOLATILE, SHELLKEY_HKCULM_MUICACHE = SKROOT_HKCU | SKPATH_SHELLNOROAM | SKSUB_MUICACHE, SHELLKEY_HKCU_FILEEXTS = SKROOT_HKCU | SKPATH_EXPLORER | SKSUB_FILEEXTS,
SHELLKEY_HKCULM_HANDLERS_RO = SHELLKEY_HKCULM_HANDLERS, // deprecated SHELLKEY_HKCULM_HANDLERS_RW = SHELLKEY_HKCULM_HANDLERS, // deprecated SHELLKEY_HKCULM_ASSOCIATIONS_RO = SHELLKEY_HKCULM_ASSOCIATIONS, // deprecated SHELLKEY_HKCULM_ASSOCIATIONS_RW = SHELLKEY_HKCULM_ASSOCIATIONS, // deprecated SHELLKEY_HKCULM_RO = SHELLKEY_HKCU_SHELLNOROAM, // deprecated SHELLKEY_HKCULM_RW = SHELLKEY_HKCU_SHELLNOROAM, // deprecated} SHELLKEY;
LWSTDAPI_(HKEY) SHGetShellKey(SHELLKEY sk, LPCWSTR pszSubKey, BOOL fCreateSub);
LWSTDAPI SKGetValue%(SHELLKEY sk, LPCTSTR% pszSubKey, LPCTSTR% pszValue, DWORD *pdwType, void *pvData, DWORD *pcbData);LWSTDAPI SKSetValue%(SHELLKEY sk, LPCTSTR% pszSubKey, LPCTSTR% pszValue, DWORD dwType, LPCVOID pvData, DWORD cbData);LWSTDAPI SKDeleteValue%(SHELLKEY sk, LPCTSTR% pszSubKey, LPCTSTR% pszValue);LWSTDAPI SKAllocValue%(SHELLKEY sk, LPCTSTR% pszSubKey, LPCTSTR% pszValue, DWORD *pdwType, void **pvData, DWORD *pcbData);
LWSTDAPI QuerySourceCreateFromKey(HKEY hk, PCWSTR pszSub, BOOL fCreate, REFIID riid, void **ppv);
;end_internal
;begin_both
#endif // NO_SHLWAPI_REG
;end_both
;begin_internal
#ifndef NO_SHLWAPI_UALSTR#include <uastrfnc.h>#endif // NO_SHLWAPI_UALSTR
;end_internal;begin_both
#ifndef NO_SHLWAPI_STREAM////=============== Stream Routines ===================================//;end_both;begin_internal//// We must say "struct IStream" instead of "IStream" in case we are// #include'd before <ole2.h>.//;end_internal
LWSTDAPI_(struct IStream *) SHOpenRegStream%(HKEY hkey, LPCTSTR% pszSubkey, LPCTSTR% pszValue, DWORD grfMode);LWSTDAPI_(struct IStream *) SHOpenRegStream2%(HKEY hkey, LPCTSTR% pszSubkey, LPCTSTR% pszValue, DWORD grfMode);// New code always wants new implementation...#undef SHOpenRegStream#define SHOpenRegStream SHOpenRegStream2
LWSTDAPI SHCreateStreamOnFile%(LPCTSTR% pszFile, DWORD grfMode, struct IStream **ppstm);
#if (_WIN32_IE >= 0x0600);begin_internalLWSTDAPI MapWin32ErrorToSTG(HRESULT hrIn);LWSTDAPI ModeToCreateFileFlags(DWORD grfMode, BOOL fCreate, DWORD *pdwDesiredAccess, DWORD *pdwShareMode, DWORD *pdwCreationDisposition);
// SHConvertGraphicsFile Description:// pszFile: The source file name to convert. The file can be a JPEG, GIF, PNG, TIFF, BMP, EMF, WMF, or ICO filetype.// pszDestFile: This is the destination file that will be created. The extension will determine type of// format for the destiation file. If this file already exists, the function will fail with// HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS) unless the flag SHCGF_REPLACEFILE is specified.// Return value: S_OK if the destination file was able to be created, otherwise an HRESULT error.//// NOTE: This is currently internal because: 1) we are using a temporary GDI+ interface, 2)// we can't fix any bugs we find (since they are in GDI+), and 3) it's best if GDI+ owns// the public version of this interface. GDI+ is working on version 1 of their API for// whistler. They don't have time to create this API, make it public, and support it// until version 2, which will be after whistler.//// dwFlags:#define SHCGF_NONE 0x00000000 // Normal behavior#define SHCGF_REPLACEFILE 0x00000001 // If pszDestFile already exists, delete it.
LWSTDAPI SHConvertGraphicsFile(IN LPCWSTR pszFile, IN LPCWSTR pszDestFile, IN DWORD dwFlags);;end_internal
LWSTDAPI SHCreateStreamOnFileEx(LPCWSTR pszFile, DWORD grfMode, DWORD dwAttributes, BOOL fCreate, struct IStream * pstmTemplate, struct IStream **ppstm);
#endif // (_WIN32_IE >= 0x0600)
;begin_internal
LWSTDAPI_(struct IStream *) SHCreateMemStream(LPBYTE pInit, UINT cbInit);
// SHCreateStreamWrapper creates an IStream that spans multiple IStream implementations.// NOTE: STGM_READ is the only mode currently supportedLWSTDAPI SHCreateStreamWrapper(IStream *aStreams[], UINT cStreams, DWORD grfMode, IStream **ppstm);
// These functions read, write, and maintain a list of DATABLOCK_HEADERs.// Blocks can be of any size (cbSize) and they are added, found, and removed// by dwSignature. Each block is guranteed to be aligned on a DWORD boundary// in memory. The stream format is identical to Windows 95 and NT 4// CShellLink's "EXP" data format (with one bug fix: stream data is NULL// terminated on write...)//// SHReadDataBlocks and SHAddDataBlock will allocate your pdbList for you.//// SHFindDataBlock returns a pointer into the pdbList.//// SHAddDataBlock and SHRemoveDataBlock return TRUE if ppdbList modified.//
/* * Temporary definition because the definition doesn't show up until shlobj.w. */
#define LPDATABLOCK_HEADER struct tagDATABLOCKHEADER *#define LPDBLIST struct tagDATABLOCKHEADER *
LWSTDAPI SHWriteDataBlockList(struct IStream* pstm, LPDBLIST pdbList);LWSTDAPI SHReadDataBlockList(struct IStream* pstm, LPDBLIST * ppdbList);LWSTDAPI_(void) SHFreeDataBlockList(LPDBLIST pdbList);LWSTDAPI_(BOOL) SHAddDataBlock(LPDBLIST * ppdbList, LPDATABLOCK_HEADER pdb);LWSTDAPI_(BOOL) SHRemoveDataBlock(LPDBLIST * ppdbList, DWORD dwSignature);LWSTDAPI_(void *) SHFindDataBlock(LPDBLIST pdbList, DWORD dwSignature);
#undef LPDATABLOCK_HEADER#undef LPDBLIST
// FUNCTION: SHCheckDiskForMedia//// hwnd - NULL means no UI will be displayed. Non-NULL means// punkEnableModless - Make caller modal during UI. (OPTIONAL)// pszPath - Path that needs verification.// wFunc - Type of operation (FO_MOVE, FO_COPY, FO_DELETE, FO_RENAME - shellapi.h)//// NOTE: USE NT5's SHPathPrepareForWrite() instead, it's MUCH MUCH BETTER.
LWSTDAPI_(BOOL) SHCheckDiskForMediaA(HWND hwnd, IUnknown * punkEnableModless, LPCSTR pszPath, UINT wFunc);LWSTDAPI_(BOOL) SHCheckDiskForMediaW(HWND hwnd, IUnknown * punkEnableModless, LPCWSTR pwzPath, UINT wFunc);
#ifdef UNICODE#define SHCheckDiskForMedia SHCheckDiskForMediaW#else#define SHCheckDiskForMedia SHCheckDiskForMediaA#endif
;end_internal
;begin_both
#endif // NO_SHLWAPI_STREAM
;end_both
;begin_internal#ifndef NO_SHLWAPI_MLUI////=============== Multi Language UI Routines ===================================//;end_internal
;begin_internal
#define ORD_SHGETWEBFOLDERFILEPATHA 440#define ORD_SHGETWEBFOLDERFILEPATHW 441LWSTDAPI SHGetWebFolderFilePath%(LPCTSTR% pszFileName, LPTSTR% pszMUIPath, UINT cchMUIPath);
// Use MLLoadLibrary to get the ML-resource file. This function tags the file so// all standard shlwapi wrap functions automatically get ML-behavior.//
#define ORD_MLLOADLIBRARYA 377#define ORD_MLLOADLIBRARYW 378LWSTDAPI_(HINSTANCE) MLLoadLibrary%(LPCTSTR% lpLibFileName, HMODULE hModule, DWORD dwCrossCodePage);LWSTDAPI_(BOOL) MLFreeLibrary(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
// If you are a global distributable a-la comctl32 that doesn't follow the IE5// PlugUI resource layout, then load your own hinstance and poke it into shlwapi// using these functions://LWSTDAPI MLSetMLHInstance(HINSTANCE hInst, LANGID lidUI);LWSTDAPI MLClearMLHInstance(HINSTANCE hInst);
// Of course you need to know what UI language to use://#define ORD_MLGETUILANGUAGE 376LWSTDAPI_(LANGID) MLGetUILanguage(void);
// Super internal and you probably don't need this one, but comctl32 does// some font munging in PlugUI cases on your apps behalf://LWSTDAPI_(BOOL) MLIsMLHInstance(HINSTANCE hInst);
LWSTDAPI_(HRESULT) MLBuildResURL%(LPCTSTR% szLibFile, HMODULE hModule, DWORD dwCrossCodePage, LPCTSTR% szResourceName, LPTSTR% pszResURL, int nBufSize);#define ORD_MLWINHELPA 395#define ORD_MLWINHELPW 397LWSTDAPI_(BOOL) MLWinHelp%(HWND hWndCaller, LPCTSTR% lpszHelp, UINT uCommand, DWORD_PTR dwData);#define ORD_MLHTMLHELPA 396#define ORD_MLHTMLHELPW 398LWSTDAPI_(HWND) MLHtmlHelp%(HWND hWndCaller, LPCTSTR% pszFile, UINT uCommand, DWORD_PTR dwData, DWORD dwCrossCodePage);
;end_internal
;begin_internal
#endif // NO_SHLWAPI_MLUI;end_internal
;begin_internal
#ifndef NO_SHLWAPI_HTTP////=============== HTTP helper Routines ===================================// The calling thread must have called CoInitialize() before using this// function - it will create a format enumerator and associate it as a// property with the IShellBrowser passed in, so that it will be reused.//
;begin_internal//// We must say "struct IWhatever" instead of "IWhatever" in case we are// #include'd before <ole2.h>.//;end_internalLWSTDAPI RegisterDefaultAcceptHeaders(struct IBindCtx* pbc, struct IShellBrowser* psb);
LWSTDAPI RunRegCommand(HWND hwnd, HKEY hkey, LPCWSTR pszKey);LWSTDAPI RunIndirectRegCommand(HWND hwnd, HKEY hkey, LPCWSTR pszKey, LPCWSTR pszVerb);LWSTDAPI SHRunIndirectRegClientCommand(HWND hwnd, LPCWSTR pszClient);
LWSTDAPI GetAcceptLanguagesA(LPSTR psz, LPDWORD pcch);LWSTDAPI GetAcceptLanguagesW(LPWSTR pwz, LPDWORD pcch);
#ifdef UNICODE#define GetAcceptLanguages GetAcceptLanguagesW#else#define GetAcceptLanguages GetAcceptLanguagesA#endif
#endif // NO_SHLWAPI_HTTP
;end_internal
;begin_internal
LWSTDAPI_(HWND) SHHtmlHelpOnDemandW(HWND hwnd, LPCWSTR pszFile, UINT uCommand, DWORD_PTR dwData, DWORD dwCrossCodePage, BOOL bUseML);LWSTDAPI_(HWND) SHHtmlHelpOnDemandA(HWND hwnd, LPCSTR pszFile, UINT uCommand, DWORD_PTR dwData, DWORD dwCrossCodePage, BOOL bUseML);LWSTDAPI_(BOOL) SHWinHelpOnDemandW(HWND hwnd, LPCWSTR pszFile, UINT uCommand, DWORD_PTR dwData, BOOL bUseML);LWSTDAPI_(BOOL) SHWinHelpOnDemandA(HWND hwnd, LPCSTR pszFile, UINT uCommand, DWORD_PTR dwData, BOOL bUseML);LWSTDAPI_(BOOL) WINAPI Shell_GetCachedImageIndexWrapW(LPCWSTR pszIconPath, int iIconIndex, UINT uIconFlags);LWSTDAPI_(BOOL) WINAPI Shell_GetCachedImageIndexWrapA(LPCSTR pszIconPath, int iIconIndex, UINT uIconFlags);
#ifdef UNICODE#define SHHtmlHelpOnDemand SHHtmlHelpOnDemandW#define SHWinHelpOnDemand SHWinHelpOnDemandW#define Shell_GetCachedImageIndexWrap Shell_GetCachedImageIndexWrapW#else#define SHHtmlHelpOnDemand SHHtmlHelpOnDemandA#define SHWinHelpOnDemand SHWinHelpOnDemandA#define Shell_GetCachedImageIndexWrap Shell_GetCachedImageIndexWrapA#endif
;end_internal
;begin_internal#ifndef NO_SHLWAPI_STOPWATCH////=============== Performance timing macros and prototypes ================
// StopWatch performance mode flags used in dwFlags param in API's and in Mode key at// HKLM\software\microsoft\windows\currentversion\explorer\performance// NOTE: low word is used for the mode, high word is used to change the default painter timer interval.// If we need more mode bits then we'll need a new reg key for paint timer#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_JAVA 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_MARS 0x00004000#ifndef NO_ETW_TRACING#define SPMODE_EVENTTRACE 0x00008000 // Event Tracing for Windows Enabled#endif#define SPMODE_RESERVED 0xffff0000#ifndef NO_ETW_TRACING#define SPMODES (SPMODE_SHELL | SPMODE_BROWSER | SPMODE_JAVA | SPMODE_MSGTRACE | SPMODE_MEMWATCH | SPMODE_DBMON | SPMODE_MARS | SPMODE_EVENTTRACE)#else#define SPMODES (SPMODE_SHELL | SPMODE_BROWSER | SPMODE_JAVA | SPMODE_MSGTRACE | SPMODE_MEMWATCH | SPMODE_DBMON | SPMODE_MARS)#endif
#ifndef NO_ETW_TRACING// Event tracing capability enabled by setting the mode to SPMODE_EVENTTRACE and// selecting the part of the shell to trace in the "EventTrace" Value in the// following key:// HKLM\software\microsoft\windows\currentversion\explorer\performance
// BROWSER TRACING// Do not use with SPMODE_BROWSER. If SPMODE_EVENT is used, the// STOPWATCH_STOP_EVENT will be signaled when a web page is done loading.#define SPTRACE_BROWSER 0x00000001// Used to turn on/off browser event tracing. Setting the registry key enables// event tracing use, but doesn't turn it on.// {5576F62E-4142-45a8-9516-262A510C13F0}DEFINE_GUID(c_BrowserControlGuid, 0x5576f62e, 0x4142, 0x45a8, 0x95, 0x16, 0x26, 0x2a, 0x51, 0xc, 0x13, 0xf0);
// Maps to the structure sent to ETW. ETW definition in// \nt\sdktools\trace\tracedmp\mofdata.guid// {2B992163-736F-4a68-9153-95BC5F34D884}DEFINE_GUID(c_BrowserTraceGuid, 0x2b992163, 0x736f, 0x4a68, 0x91, 0x53, 0x95, 0xbc, 0x5f, 0x34, 0xd8, 0x84);
// BROWSING EVENTS// See \nt\sdktools\trace\tracedmp\mofdata.guid// The page load starts with a user keystroke message#define EVENT_TRACE_TYPE_BROWSE_USERINPUTRET 10#define EVENT_TRACE_TYPE_BROWSE_USERINPUTBACK 11#define EVENT_TRACE_TYPE_BROWSE_USERINPUTLBUT 12#define EVENT_TRACE_TYPE_BROWSE_USERINPUTNEXT 13#define EVENT_TRACE_TYPE_BROWSE_USERINPUTPRIOR 14#define EVENT_TRACE_TYPE_BROWSE_STARTFRAME 16#define EVENT_TRACE_TYPE_BROWSE_LOADEDPARSED 18#define EVENT_TRACE_TYPE_BROWSE_LAYOUT 19#define EVENT_TRACE_TYPE_BROWSE_LAYOUTTASK 20#define EVENT_TRACE_TYPE_BROWSE_PAINT 21// Url the user types into the address bar.#define EVENT_TRACE_TYPE_BROWSE_ADDRESS 22
#endif
// StopWatch node types used in memory log to identify the type of node#define EMPTY_NODE 0x0#define START_NODE 0x1#define LAP_NODE 0x2#define STOP_NODE 0x3#define OUT_OF_NODES 0x4
// StopWatch timing ids used to identify the type of timing being performed#define SWID_STARTUP 0x0#define SWID_FRAME 0x1#define SWID_COPY 0x2#define SWID_TREE 0x3#define SWID_BROWSER_FRAME 0x4#define SWID_JAVA_APP 0x5#define SWID_MENU 0x6#define SWID_BITBUCKET 0x7#define SWID_EXPLBAR 0x8#define SWID_MSGDISPATCH 0x9#define SWID_TRACEMSG 0xa#define SWID_DBMON_DLLLOAD 0xb#define SWID_DBMON_EXCEPTION 0xc#define SWID_THUMBVW_CACHEREAD 0xd#define SWID_THUMBVW_EXTRACT 0xe#define SWID_THUMBVW_CACHEWRITE 0xf#define SWID_THUMBVW_FETCH 0x10#define SWID_THUMBVW_INIT 0x11#define SWID_MASK_BROWSER_STOPBTN 0x8000000 // identifies BROWSER_FRAME stop caused by stop button
#define SWID_MASKS SWID_MASK_BROWSER_STOPBTN // add any SWID_MASK_* defines here
#define SWID(dwId) (dwId & (~SWID_MASKS))
// The following StopWatch messages are used to drive the timer msg handler. The timer proc is used// as a means of delaying while watching paint messages. If the defined number of timer ticks has// passed without getting any paint messages, then we mark the time of the last paint message we've// saved as the stop time.#define SWMSG_PAINT 1 // paint message rcvd#define SWMSG_TIMER 2 // timer tick#define SWMSG_CREATE 3 // init handler and create timer#define SWMSG_STATUS 4 // get status of whether timing is active or not
#define ID_STOPWATCH_TIMER 0xabcd // Timer id
// Stopwatch defaults#define STOPWATCH_MAX_NODES 100#define STOPWATCH_DEFAULT_PAINT_INTERVAL 1000#define STOPWATCH_DEFAULT_MAX_DISPATCH_TIME 150#define STOPWATCH_DEFAULT_MAX_MSG_TIME 1000#define STOPWATCH_DEFAULT_MAX_MSG_INTERVAL 50#define STOPWATCH_DEFAULT_CLASSNAMES TEXT("Internet Explorer_Server") TEXT("\0") TEXT("SHELLDLL_DefView") TEXT("\0") TEXT("SysListView32") TEXT("\0\0")
#define MEMWATCH_DEFAULT_PAGES 512#define MEMWATCH_DEFAULT_TIME 1000#define MEMWATCH_DEFAULT_FLAGS 0
#ifdef UNICODE#define StopWatch StopWatchW#define StopWatchEx StopWatchExW#else#define StopWatch StopWatchA#define StopWatchEx StopWatchExA#endif
#define StopWatch_Start(dwId, pszDesc, dwFlags) StopWatch(dwId, pszDesc, START_NODE, dwFlags, 0)#define StopWatch_Lap(dwId, pszDesc, dwFlags) StopWatch(dwId, pszDesc, LAP_NODE, dwFlags, 0)#define StopWatch_Stop(dwId, pszDesc, dwFlags) StopWatch(dwId, pszDesc, STOP_NODE, dwFlags, 0)#define StopWatch_StartTimed(dwId, pszDesc, dwFlags, dwCount) StopWatch(dwId, pszDesc, START_NODE, dwFlags, dwCount)#define StopWatch_LapTimed(dwId, pszDesc, dwFlags, dwCount) StopWatch(dwId, pszDesc, LAP_NODE, dwFlags, dwCount)#define StopWatch_StopTimed(dwId, pszDesc, dwFlags, dwCount) StopWatch(dwId, pszDesc, STOP_NODE, dwFlags, dwCount)
#define StopWatch_StartEx(dwId, pszDesc, dwFlags, dwCookie) StopWatchEx(dwId, pszDesc, START_NODE, dwFlags, 0, dwCookie)#define StopWatch_LapEx(dwId, pszDesc, dwFlags, dwCookie) StopWatchEx(dwId, pszDesc, LAP_NODE, dwFlags, 0, dwCookie)#define StopWatch_StopEx(dwId, pszDesc, dwFlags, dwCookie) StopWatchEx(dwId, pszDesc, STOP_NODE, dwFlags, 0, dwCookie)#define StopWatch_StartTimedEx(dwId, pszDesc, dwFlags, dwCount, dwCookie) StopWatchEx(dwId, pszDesc, START_NODE, dwFlags, dwCount, dwCookie)#define StopWatch_LapTimedEx(dwId, pszDesc, dwFlags, dwCount, dwCookie) StopWatchEx(dwId, pszDesc, LAP_NODE, dwFlags, dwCount, dwCookie)#define StopWatch_StopTimedEx(dwId, pszDesc, dwFlags, dwCount, dwCookie) StopWatchEx(dwId, pszDesc, STOP_NODE, dwFlags, dwCount, dwCookie)
VOID InitStopWatchMode(VOID);
// EXPORTED FUNCTIONSDWORD WINAPI StopWatchW(DWORD dwId, LPCWSTR pszDesc, DWORD dwType, DWORD dwFlags, DWORD dwCount);DWORD WINAPI StopWatchA(DWORD dwId, LPCSTR pszDesc, DWORD dwType, DWORD dwFlags, DWORD dwCount);DWORD WINAPI StopWatchExW(DWORD dwId, LPCWSTR pszDesc, DWORD dwType, DWORD dwFlags, DWORD dwCount, DWORD dwUniqueId);DWORD WINAPI StopWatchExA(DWORD dwId, LPCSTR pszDesc, DWORD dwType, DWORD dwFlags, DWORD dwCount, DWORD dwUniqueId);DWORD WINAPI StopWatchMode(VOID);DWORD WINAPI StopWatchFlush(VOID);BOOL WINAPI StopWatch_TimerHandler(HWND hwnd, UINT uInc, DWORD dwFlag, MSG *pmsg);VOID WINAPI StopWatch_CheckMsg(HWND hwnd, MSG msg, LPCSTR lpStr);VOID WINAPI StopWatch_MarkFrameStart(LPCSTR lpExplStr);VOID WINAPI StopWatch_MarkSameFrameStart(HWND hwnd);VOID WINAPI StopWatch_MarkJavaStop(LPCSTR lpStringToSend, HWND hwnd, BOOL fChType);DWORD WINAPI GetPerfTime(VOID);VOID WINAPI StopWatch_SetMsgLastLocation(DWORD dwLast);DWORD WINAPI StopWatch_DispatchTime(BOOL fStartTime, MSG msg, DWORD dwStart);#ifndef NO_ETW_TRACINGVOID WINAPI EventTraceHandler(UCHAR uchEventType, PVOID pvData);#endif
extern DWORD g_dwStopWatchMode;////=============== End Performance timing macros and prototypes ================
#endif //#ifndef NO_SHLWAPI_STOPWATCH
;end_internal
;begin_internal
#ifndef NO_SHLWAPI_INTERNAL////=============== Internal helper routines ===================================
//// Declare some OLE interfaces we need to refer to and which aren't// already defined in objbase.h//
#ifndef RC_INVOKED /* { rc doesn't like these long symbol names */#ifndef __IOleCommandTarget_FWD_DEFINED__#define __IOleCommandTarget_FWD_DEFINED__typedef struct IOleCommandTarget IOleCommandTarget;#endif /* __IOleCommandTarget_FWD_DEFINED__ */
#ifndef __IDropTarget_FWD_DEFINED__#define __IDropTarget_FWD_DEFINED__typedef struct IDropTarget IDropTarget;#endif /* __IDropTarget_FWD_DEFINED__ */
#ifndef __IPropertyBag_FWD_DEFINED__#define __IPropertyBag_FWD_DEFINED__typedef struct IPropertyBag IPropertyBag;#endif /* __IPropertyBag_FWD_DEFINED__ */
#ifndef __IConnectionPoint_FWD_DEFINED__#define __IConnectionPoint_FWD_DEFINED__typedef struct IConnectionPoint IConnectionPoint;#endif /* __IConnectionPoint_FWD_DEFINED__ */
#ifdef __cplusplusextern "C++" { template <typename T> void IUnknown_SafeReleaseAndNullPtr(T *& p) { if (p) { T *pTemp = p; p = NULL; pTemp->Release(); } }}#endif // __cplusplus
LWSTDAPI_(void) IUnknown_AtomicRelease(void ** ppunk); LWSTDAPI_(BOOL) SHIsSameObject(IUnknown* punk1, IUnknown* punk2); LWSTDAPI IUnknown_GetWindow(IUnknown* punk, HWND* phwnd); LWSTDAPI IUnknown_SetOwner(IUnknown* punk, IUnknown* punkOwner); LWSTDAPI IUnknown_SetSite(IUnknown *punk, IUnknown *punkSite); LWSTDAPI IUnknown_GetSite(IUnknown *punk, REFIID riid, void **ppvOut); LWSTDAPI IUnknown_EnableModeless(IUnknown * punk, BOOL fEnabled); LWSTDAPI IUnknown_GetClassID(IUnknown *punk, CLSID *pclsid); LWSTDAPI IUnknown_QueryService(IUnknown* punk, REFGUID guidService, REFIID riid, void ** ppvOut); LWSTDAPI IUnknown_QueryServiceForWebBrowserApp(IUnknown* punk, REFIID riid, void **ppvOut); LWSTDAPI IUnknown_QueryServiceExec(IUnknown* punk, REFGUID guidService, const GUID *guid, DWORD cmdID, DWORD cmdParam, VARIANT* pvarargIn, VARIANT* pvarargOut); LWSTDAPI IUnknown_ShowBrowserBar(IUnknown* punk, REFCLSID clsidBrowserBar, BOOL fShow); LWSTDAPI IUnknown_HandleIRestrict(IUnknown * punk, const GUID * pguidID, DWORD dwRestrictAction, VARIANT * pvarArgs, DWORD * pdwRestrictionResult); LWSTDAPI IUnknown_OnFocusOCS(IUnknown *punk, BOOL fGotFocus); LWSTDAPI IUnknown_TranslateAcceleratorOCS(IUnknown *punk, LPMSG lpMsg, DWORD grfMods); LWSTDAPI_(void) IUnknown_Set(IUnknown ** ppunk, IUnknown * punk); LWSTDAPI IUnknown_ProfferService(IUnknown *punkSite, REFGUID sidWhat, IServiceProvider *punkService, DWORD *pdwCookie); LWSTDAPI IUnknown_QueryServicePropertyBag(IUnknown* punk, DWORD dwFlags, REFIID riid, void ** ppvOut);
LWSTDAPI IUnknown_TranslateAcceleratorIO(IUnknown* punk, LPMSG lpMsg); LWSTDAPI IUnknown_UIActivateIO(IUnknown *punk, BOOL fActivate, LPMSG lpMsg); LWSTDAPI IUnknown_OnFocusChangeIS(IUnknown *punk, IUnknown *punkSrc, BOOL fSetFocus); LWSTDAPI IUnknown_HasFocusIO(IUnknown *punk);
LWSTDAPI SHWeakQueryInterface(IUnknown *punkOuter, IUnknown *punkTarget, REFIID riid, void **ppvOut); LWSTDAPI_(void) SHWeakReleaseInterface(IUnknown *punkOuter, IUnknown **ppunk);
#define IUnknown_EnableModless IUnknown_EnableModeless
// Helper macros for the Weak interface functions. #define SHQueryInnerInterface SHWeakQueryInterface #define SHReleaseInnerInterface SHWeakReleaseInterface #define SHReleaseOuterInterface SHWeakReleaseInterface
__inline HRESULT SHQueryOuterInterface(IUnknown *punkOuter, REFIID riid, void **ppvOut) { return SHWeakQueryInterface(punkOuter, punkOuter, riid, ppvOut); }
#if (_WIN32_IE >= 0x0600) // App compat-aware CoCreateInstance LWSTDAPI SHCoCreateInstanceAC(REFCLSID rclsid, IUnknown *punkOuter, DWORD dwClsCtx, REFIID riid, void **ppvOut);#endif // (_WIN32_IE >= 0x0600)
#if defined(__IOleAutomationTypes_INTERFACE_DEFINED__) && \ defined(__IOleCommandTarget_INTERFACE_DEFINED__) LWSTDAPI IUnknown_QueryStatus(IUnknown *punk, const GUID *pguidCmdGroup, ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pcmdtext); LWSTDAPI IUnknown_Exec(IUnknown* punk, const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut);
// Some of the many connection point helper functions available in // connect.cpp. We export only the ones people actually use. If // you need a helper function, maybe it's already in connect.cpp // and merely needs to be exported.
LWSTDAPI SHPackDispParamsV(DISPPARAMS * pdispparams, VARIANTARG *rgvt, UINT cArgs, va_list arglist); LWSTDAPIV SHPackDispParams(DISPPARAMS * pdispparams, VARIANTARG *rgvt, UINT cArgs, ...);
typedef HRESULT (CALLBACK *SHINVOKECALLBACK)(IDispatch *pdisp, struct SHINVOKEPARAMS *pinv);
#include <pshpack1.h> typedef struct SHINVOKEPARAMS { UINT flags; // mandatory DISPID dispidMember; // mandatory const IID*piid; // IPFL_USEDEFAULTS will fill this in LCID lcid; // IPFL_USEDEFAULTS will fill this in WORD wFlags; // IPFL_USEDEFAULTS will fill this in DISPPARAMS * pdispparams; // mandatory, may be NULL VARIANT * pvarResult; // IPFL_USEDEFAULTS will fill this in EXCEPINFO * pexcepinfo; // IPFL_USEDEFAULTS will fill this in UINT * puArgErr; // IPFL_USEDEFAULTS will fill this in SHINVOKECALLBACK Callback; // required if IPFL_USECALLBACK } SHINVOKEPARAMS, *LPSHINVOKEPARAMS;#include <poppack.h> /* Return to byte packing */
#define IPFL_USECALLBACK 0x0001 #define IPFL_USEDEFAULTS 0x0002
#if 0 // These functions not yet needed LWSTDAPI IConnectionPoint_InvokeIndirect(IConnectionPoint *pcp, SHINVOKEPARAMS *pinv);#endif
LWSTDAPI IConnectionPoint_InvokeWithCancel(IConnectionPoint *pcp, DISPID dispidMember, DISPPARAMS * pdispparams, LPBOOL pfCancel, LPVOID *ppvCancel); LWSTDAPI IConnectionPoint_SimpleInvoke(IConnectionPoint *pcp, DISPID dispidMember, DISPPARAMS * pdispparams);
#if 0 // These functions not yet needed LWSTDAPI IConnectionPoint_InvokeParamV(IConnectionPoint *pcp, DISPID dispidMember, VARIANTARG *rgvarg, UINT cArgs, va_list ap); LWSTDAPIV IConnectionPoint_InvokeParam(IConnectionPoint *pcp, DISPID dispidMember, VARIANTARG *rgvarg, UINT cArgs, ...)#endif
LWSTDAPI IConnectionPoint_OnChanged(IConnectionPoint *pcp, DISPID dispid);
#if 0 // These functions not yet needed LWSTDAPI IUnknown_FindConnectionPoint(IUnknown *punk, REFIID riidCP, IConnectionPoint **pcpOut);#endif
LWSTDAPI IUnknown_CPContainerInvokeIndirect(IUnknown *punk, REFIID riidCP, SHINVOKEPARAMS *pinv); LWSTDAPIV IUnknown_CPContainerInvokeParam(IUnknown *punk, REFIID riidCP, DISPID dispidMember, VARIANTARG *rgvarg, UINT cArgs, ...); LWSTDAPI IUnknown_CPContainerOnChanged(IUnknown *punk, DISPID dispid);
#endif /* IOleAutomationTypes && IOleCommandTarget */#endif /* } !RC_INVOKED */
LWSTDAPI IStream_Read(IStream *pstm, void *pv, ULONG cb); LWSTDAPI IStream_Write(IStream *pstm, const void *pv, ULONG cb); LWSTDAPI IStream_Reset(IStream *pstm); LWSTDAPI IStream_Size(IStream *pstm, ULARGE_INTEGER *pui); LWSTDAPI IStream_WritePidl(IStream *pstm, LPCITEMIDLIST pidlWrite); LWSTDAPI IStream_ReadPidl(IStream *pstm, LPITEMIDLIST *ppidlOut);
LWSTDAPI_(BOOL) SHIsEmptyStream(IStream* pstm);
LWSTDAPI SHSimulateDrop(IDropTarget *pdrop, IDataObject *pdtobj, DWORD grfKeyState, const POINTL *ppt, DWORD *pdwEffect);
LWSTDAPI SHLoadFromPropertyBag(IUnknown* punk, IPropertyBag* ppg);
LWSTDAPI ConnectToConnectionPoint(IUnknown* punkThis, REFIID riidEvent, BOOL fConnect, IUnknown* punkTarget, DWORD* pdwCookie, IConnectionPoint** ppcpOut);
LWSTDAPI SHCreatePropertyBagOnRegKey(HKEY hk, LPCWSTR pszSubKey, DWORD grfMode, REFIID riid, void **ppv);LWSTDAPI SHCreatePropertyBagOnProfileSection(LPCWSTR pszFile, LPCWSTR pszSection, DWORD grfMode, REFIID riid, void **ppv);LWSTDAPI SHCreatePropertyBagOnMemory(DWORD grfMode, REFIID riid, void **ppv);
LWSTDAPI SHPropertyBag_ReadType(IPropertyBag* ppb, LPCWSTR pszPropName, VARIANT* pv, VARTYPE vt);LWSTDAPI SHPropertyBag_ReadStr(IPropertyBag* ppb, LPCWSTR pwzPropName, LPWSTR psz, int cch);LWSTDAPI SHPropertyBag_ReadBSTR(IPropertyBag *ppb, LPCWSTR pwzPropName, BSTR* pbstr);LWSTDAPI SHPropertyBag_WriteStr(IPropertyBag* ppb, LPCWSTR pwzPropName, LPCWSTR psz);LWSTDAPI SHPropertyBag_ReadInt(IPropertyBag* ppb, LPCWSTR pwzPropName, INT* piResult);LWSTDAPI SHPropertyBag_WriteInt(IPropertyBag* ppb, LPCWSTR pwzPropName, INT iValue);LWSTDAPI SHPropertyBag_ReadSHORT(IPropertyBag* ppb, LPCWSTR pwzPropName, SHORT* psh);LWSTDAPI SHPropertyBag_WriteSHORT(IPropertyBag* ppb, LPCWSTR pwzPropName, SHORT sh);LWSTDAPI SHPropertyBag_ReadLONG(IPropertyBag* ppb, LPCWSTR pwzPropName, LONG* pl);LWSTDAPI SHPropertyBag_WriteLONG(IPropertyBag* ppb, LPCWSTR pwzPropName, LONG l);LWSTDAPI SHPropertyBag_ReadDWORD(IPropertyBag* ppb, LPCWSTR pwzPropName, DWORD* pdw);LWSTDAPI SHPropertyBag_WriteDWORD(IPropertyBag* ppb, LPCWSTR pwzPropName, DWORD dw);LWSTDAPI SHPropertyBag_ReadBOOL(IPropertyBag* ppb, LPCWSTR pwzPropName, BOOL* pfResult);LWSTDAPI SHPropertyBag_WriteBOOL(IPropertyBag* ppb, LPCWSTR pwzPropName, BOOL fValue);LWSTDAPI SHPropertyBag_ReadGUID(IPropertyBag* ppb, LPCWSTR pwzPropName, GUID* pguid);LWSTDAPI SHPropertyBag_WriteGUID(IPropertyBag* ppb, LPCWSTR pwzPropName, const GUID* pguid);LWSTDAPI SHPropertyBag_ReadPIDL(IPropertyBag *ppb, LPCWSTR pwzPropName, LPITEMIDLIST* ppidl);LWSTDAPI SHPropertyBag_WritePIDL(IPropertyBag *ppb, LPCWSTR pwzPropName, LPCITEMIDLIST pidl);LWSTDAPI SHPropertyBag_ReadPOINTL(IPropertyBag* ppb, LPCWSTR pwzPropName, POINTL* ppt);LWSTDAPI SHPropertyBag_WritePOINTL(IPropertyBag* ppb, LPCWSTR pwzPropName, const POINTL* ppt);LWSTDAPI SHPropertyBag_ReadPOINTS(IPropertyBag* ppb, LPCWSTR pwzPropName, POINTS* ppt);LWSTDAPI SHPropertyBag_WritePOINTS(IPropertyBag* ppb, LPCWSTR pwzPropName, const POINTS* ppt);LWSTDAPI SHPropertyBag_ReadRECTL(IPropertyBag* ppb, LPCWSTR pwzPropName, RECTL* prc);LWSTDAPI SHPropertyBag_WriteRECTL(IPropertyBag* ppb, LPCWSTR pwzPropName, const RECTL* prc);LWSTDAPI SHPropertyBag_ReadStream(IPropertyBag* ppb, LPCWSTR pwzPropName, IStream** ppstm);LWSTDAPI SHPropertyBag_WriteStream(IPropertyBag* ppb, LPCWSTR pwzPropName, IStream* pstm);LWSTDAPI SHPropertyBag_Delete(IPropertyBag* ppb, LPCWSTR pszPropName);
// Doc'ed for DOJ compliance;end_internal#define SHGVSPB_PERUSER 0x00000001 // must have one of PERUSER or ALLUSERS#define SHGVSPB_ALLUSERS 0x00000002#define SHGVSPB_PERFOLDER 0x00000004 // must have one of PERFOLDER ALLFOLDERS or INHERIT#define SHGVSPB_ALLFOLDERS 0x00000008#define SHGVSPB_INHERIT 0x00000010#define SHGVSPB_ROAM 0x00000020 // modifies the above#define SHGVSPB_NOAUTODEFAULTS 0x80000000 // turns off read delegation to more general property bags
#define SHGVSPB_FOLDER (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER)#define SHGVSPB_FOLDERNODEFAULTS (SHGVSPB_PERUSER | SHGVSPB_PERFOLDER | SHGVSPB_NOAUTODEFAULTS)#define SHGVSPB_USERDEFAULTS (SHGVSPB_PERUSER | SHGVSPB_ALLFOLDERS)#define SHGVSPB_GLOBALDEAFAULTS (SHGVSPB_ALLUSERS | SHGVSPB_ALLFOLDERS)
LWSTDAPI SHGetViewStatePropertyBag(LPCITEMIDLIST pidl, LPCWSTR pszBagName, DWORD dwFlags, REFIID riid, void** ppv);;begin_internal
LWSTDAPI_(ULONG) SHGetPerScreenResName(WCHAR* pszRes, ULONG cch, DWORD dwVersion);
//// SH(Get/Set)IniStringUTF7//// These are just like Get/WriteProfileString except that if the KeyName// begins with SZ_CANBEUNICODE, we will use SHGetIniString instead of// the profile functions. (The SZ_CANBEUNICODE will be stripped off// before calling SHGetIniString.) This allows us to stash unicode// strings into INI files (which are ASCII) by encoding them as UTF7.//// In other words, SHGetIniStringUTF7("Settings", SZ_CANBEUNICODE "Name", ...)// will read from section "Settings", key name "Name", but will also// look at the UTF7-encoded version stashed in the "Settings.W" section.//#define CH_CANBEUNICODEW L'@'
LWSTDAPI_(DWORD) SHGetIniStringUTF7W(LPCWSTR lpSection, LPCWSTR lpKey, LPWSTR lpBuf, DWORD nSize, LPCWSTR lpFile);LWSTDAPI_(BOOL) SHSetIniStringUTF7W(LPCWSTR lpSection, LPCWSTR lpKey, LPCWSTR lpString, LPCWSTR lpFile);#ifdef UNICODE#define SZ_CANBEUNICODE TEXT("@")#define SHSetIniStringUTF7 SHSetIniStringUTF7W#define SHGetIniStringUTF7 SHGetIniStringUTF7W#else#define SZ_CANBEUNICODE TEXT("")#define SHGetIniStringUTF7(lpSection, lpKey, lpBuf, nSize, lpFile) \ GetPrivateProfileStringA(lpSection, lpKey, "", lpBuf, nSize, lpFile)#define SHSetIniStringUTF7 WritePrivateProfileStringA#endif
/* * Like PrivateProfileString except that UNICODE strings are encoded so they * will successfully round-trip. */LWSTDAPI_(DWORD) SHGetIniStringW(LPCWSTR lpSection, LPCWSTR lpKey, LPWSTR lpBuf, DWORD nSize, LPCWSTR lpFile);#define SHGetIniStringA(lpSection, lpKey, lpBuf, nSize, lpFile) \ GetPrivateProfileStringA(lpSection, lpKey, "", lpBuf, nSize, lpFile)
LWSTDAPI_(BOOL) SHSetIniStringW(LPCWSTR lpSection, LPCWSTR lpKey, LPCWSTR lpString, LPCWSTR lpFile);#define SHSetIniStringA WritePrivateProfileStringA
LWSTDAPI CreateURLFileContentsW(LPCWSTR pwszUrl, LPSTR *ppszOut);LWSTDAPI CreateURLFileContentsA(LPCSTR pszUrl, LPSTR *ppszOut);
#ifdef UNICODE#define SHGetIniString SHGetIniStringW#define SHSetIniString SHSetIniStringW#define CreateURLFileContents CreateURLFileContentsW#else#define SHGetIniString SHGetIniStringA#define SHSetIniString SHSetIniStringA#define CreateURLFileContents CreateURLFileContentsA#endif // UNICODE
#define ISHGDN2_CANREMOVEFORPARSING 0x0001LWSTDAPI IShellFolder_GetDisplayNameOf(struct IShellFolder *psf, LPCITEMIDLIST pidl, DWORD uFlags, STRRET *pstr, DWORD dwFlags2);
LWSTDAPI IShellFolder_ParseDisplayName(struct IShellFolder *psf, HWND hwnd, struct IBindCtx *pbc, LPWSTR pszDisplayName, ULONG *pchEaten, LPITEMIDLIST *ppidl, ULONG *pdwAttributes);
LWSTDAPI IShellFolder_CompareIDs(struct IShellFolder *psf, LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
LWSTDAPI IShellFolder_EnumObjects(struct IShellFolder *psf, HWND hwnd, DWORD grfFlags, struct IEnumIDList **ppenumIDList);
LWSTDAPI_(BOOL) SHIsExpandableFolder(struct IShellFolder *psf, LPCITEMIDLIST pidl);LWSTDAPI IContextMenu_Invoke(struct IContextMenu* pcm, HWND hwndOwner, LPCSTR pVerb, UINT fFlags);
#ifdef UNICODE// SHTruncateString takes a BUFFER SIZE, so subtract 1 to properly null terminate.//#define SHTruncateString(wzStr, cch) ((cch) ? ((wzStr)[cch-1]=L'\0', (cch-1)) : 0)#elseLWSTDAPI_(int) SHTruncateString(CHAR *sz, int cchBufferSize);#endif // UNICODE
// 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/98 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 possible#define FDTF_LTRDATE 0x00000100 // Left To Right reading order#define FDTF_RTLDATE 0x00000200 // Right To Left reading order
LWSTDAPI_(int) SHFormatDateTime%(const FILETIME UNALIGNED * pft, DWORD * pdwFlags, LPTSTR% pszBuf, UINT cchBuf);
LWSTDAPI_(SECURITY_ATTRIBUTES*) CreateAllAccessSecurityAttributes(SECURITY_ATTRIBUTES* psa, SECURITY_DESCRIPTOR* psd, PACL *ppacl);
LWSTDAPI_(int) SHAnsiToUnicode(LPCSTR pszSrc, LPWSTR pwszDst, int cwchBuf);LWSTDAPI_(int) SHAnsiToUnicodeCP(UINT uiCP, LPCSTR pszSrc, LPWSTR pwszDst, int cwchBuf);LWSTDAPI_(int) SHAnsiToAnsi(LPCSTR pszSrc, LPSTR pszDst, int cchBuf);LWSTDAPI_(int) SHUnicodeToAnsi(LPCWSTR pwszSrc, LPSTR pszDst, int cchBuf);LWSTDAPI_(int) SHUnicodeToAnsiCP(UINT uiCP, LPCWSTR pwszSrc, LPSTR pszDst, int cchBuf);LWSTDAPI_(int) SHUnicodeToUnicode(LPCWSTR pwzSrc, LPWSTR pwzDst, int cwchBuf);LWSTDAPI_(BOOL) DoesStringRoundTripA(LPCSTR pwszIn, LPSTR pszOut, UINT cchOut);LWSTDAPI_(BOOL) DoesStringRoundTripW(LPCWSTR pwszIn, LPSTR pszOut, UINT cchOut);#ifdef UNICODE#define DoesStringRoundTrip DoesStringRoundTripW#else#define DoesStringRoundTrip DoesStringRoundTripA#endif
// The return value from all SH<Type>To<Type> is the size of szDest including the terminater.#ifdef UNICODE#define SHTCharToUnicode(wzSrc, wzDest, cchSize) SHUnicodeToUnicode(wzSrc, wzDest, cchSize)#define SHTCharToUnicodeCP(uiCP, wzSrc, wzDest, cchSize) SHUnicodeToUnicode(wzSrc, wzDest, cchSize)#define SHTCharToAnsi(wzSrc, szDest, cchSize) SHUnicodeToAnsi(wzSrc, szDest, cchSize)#define SHTCharToAnsiCP(uiCP, wzSrc, szDest, cchSize) SHUnicodeToAnsiCP(uiCP, wzSrc, szDest, cchSize)#define SHUnicodeToTChar(wzSrc, wzDest, cchSize) SHUnicodeToUnicode(wzSrc, wzDest, cchSize)#define SHUnicodeToTCharCP(uiCP, wzSrc, wzDest, cchSize) SHUnicodeToUnicode(wzSrc, wzDest, cchSize)#define SHAnsiToTChar(szSrc, wzDest, cchSize) SHAnsiToUnicode(szSrc, wzDest, cchSize)#define SHAnsiToTCharCP(uiCP, szSrc, wzDest, cchSize) SHAnsiToUnicodeCP(uiCP, szSrc, wzDest, cchSize)#define SHOtherToTChar(szSrc, szDest, cchSize) SHAnsiToUnicode(szSrc, szDest, cchSize)#define SHTCharToOther(szSrc, szDest, cchSize) SHUnicodeToAnsi(szSrc, szDest, cchSize)#else // UNICODE#define SHTCharToUnicode(szSrc, wzDest, cchSize) SHAnsiToUnicode(szSrc, wzDest, cchSize)#define SHTCharToUnicodeCP(uiCP, szSrc, wzDest, cchSize) SHAnsiToUnicodeCP(uiCP, szSrc, wzDest, cchSize)#define SHTCharToAnsi(szSrc, szDest, cchSize) SHAnsiToAnsi(szSrc, szDest, cchSize)#define SHTCharToAnsiCP(uiCP, szSrc, szDest, cchSize) SHAnsiToAnsi(szSrc, szDest, cchSize)#define SHUnicodeToTChar(wzSrc, szDest, cchSize) SHUnicodeToAnsi(wzSrc, szDest, cchSize)#define SHUnicodeToTCharCP(uiCP, wzSrc, szDest, cchSize) SHUnicodeToAnsiCP(uiCP, wzSrc, szDest, cchSize)#define SHAnsiToTChar(szSrc, szDest, cchSize) SHAnsiToAnsi(szSrc, szDest, cchSize)#define SHAnsiToTCharCP(uiCP, szSrc, szDest, cchSize) SHAnsiToAnsi(szSrc, szDest, cchSize)#define SHOtherToTChar(szSrc, szDest, cchSize) SHUnicodeToAnsi(szSrc, szDest, cchSize)#define SHTCharToOther(szSrc, szDest, cchSize) SHAnsiToUnicode(szSrc, szDest, cchSize)#endif // UNICODE
// Internal HRESULT-to-help-topic mapping structuretypedef struct _tagHRESULTHELPMAPPING{ HRESULT hr; LPCSTR szHelpFile; LPCSTR szHelpTopic;} HRESULTHELPMAPPING;
LWSTDAPI_(BOOL) SHRegisterClassA(const WNDCLASSA* pwc);LWSTDAPI_(BOOL) SHRegisterClassW(const WNDCLASSW* pwc);LWSTDAPI_(void) SHUnregisterClassesA(HINSTANCE hinst, const LPCSTR *rgpszClasses, UINT cpsz);LWSTDAPI_(void) SHUnregisterClassesW(HINSTANCE hinst, const LPCWSTR *rgpszClasses, UINT cpsz);LWSTDAPI_(int) SHMessageBoxHelpW(HWND hwnd, LPCWSTR pszText, LPCWSTR pszCaption, UINT uType, HRESULT hrErr, HRESULTHELPMAPPING* prghhm, DWORD chhm);LWSTDAPI_(int) SHMessageBoxHelpA(HWND hwnd, LPCSTR pszText, LPCSTR pszCaption, UINT uType, HRESULT hrErr, HRESULTHELPMAPPING* prghhm, DWORD chhm);LWSTDAPI_(int) SHMessageBoxCheckW(HWND hwnd, LPCWSTR pszText, LPCWSTR pszCaption, UINT uType, int iDefault, LPCWSTR pszRegVal);LWSTDAPI_(int) SHMessageBoxCheckA(HWND hwnd, LPCSTR pszText, LPCSTR pszCaption, UINT uType, int iDefault, LPCSTR pszRegVal);LWSTDAPI_(void) SHRestrictedMessageBox(HWND hwnd);LWSTDAPI_(HMENU) SHGetMenuFromID(HMENU hmMain, UINT uID);LWSTDAPI_(int) SHMenuIndexFromID(HMENU hm, UINT id);LWSTDAPI_(void) SHRemoveDefaultDialogFont(HWND hDlg);LWSTDAPI_(void) SHSetDefaultDialogFont(HWND hDlg, int idCtl);LWSTDAPI_(void) SHRemoveAllSubMenus(HMENU hmenu);LWSTDAPI_(void) SHEnableMenuItem(HMENU hmenu, UINT id, BOOL fEnable);LWSTDAPI_(void) SHCheckMenuItem(HMENU hmenu, UINT id, BOOL fChecked);LWSTDAPI_(DWORD) SHSetWindowBits(HWND hWnd, int iWhich, DWORD dwBits, DWORD dwValue);LWSTDAPI_(HMENU) SHLoadMenuPopup(HINSTANCE hinst, UINT id);
#define SPM_POST 0x0000#define SPM_SEND 0x0001#define SPM_ONELEVEL 0x0002 // default: send to all descendants including grandkids, etc.
LWSTDAPI_(void) SHPropagateMessage(HWND hwndParent, UINT uMsg, WPARAM wParam, LPARAM lParam, int iFlags);LWSTDAPI_(void) SHSetParentHwnd(HWND hwnd, HWND hwndParent);LWSTDAPI_(UINT) SHGetCurColorRes();LWSTDAPI_(DWORD) SHWaitForSendMessageThread(HANDLE hThread, DWORD dwTimeout);LWSTDAPI SHWaitForCOMSendMessageThread(HANDLE hThread, DWORD dwTimeout);LWSTDAPI_(BOOL) SHVerbExistsNA(LPCSTR szExtension, LPCSTR pszVerb, LPSTR pszCommand, DWORD cchCommand);LWSTDAPI_(void) SHFillRectClr(HDC hdc, LPRECT prc, COLORREF clr);LWSTDAPI_(int) SHSearchMapInt(const int *src, const int *dst, int cnt, int val);LWSTDAPI_(CHAR) SHStripMneumonicA(LPSTR pszMenu);LWSTDAPI_(WCHAR) SHStripMneumonicW(LPWSTR pszMenu);LWSTDAPI SHIsChildOrSelf(HWND hwndParent, HWND hwnd);LWSTDAPI_(DWORD) SHGetValueGoodBootA(HKEY hkeyParent, LPCSTR pcszSubKey, LPCSTR pcszValue, PDWORD pdwValueType, PBYTE pbyteBuf, PDWORD pdwcbBufLen);LWSTDAPI_(DWORD) SHGetValueGoodBootW(HKEY hkeyParent, LPCWSTR pcwzSubKey, LPCWSTR pcwzValue, PDWORD pdwValueType, PBYTE pbyteBuf, PDWORD pdwcbBufLen);LWSTDAPI_(LRESULT) SHDefWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
LWSTDAPI_(BOOL) SHGetFileDescription%(LPCTSTR% pszPath, LPCTSTR% pszVersionKeyIn, LPCTSTR% pszCutListIn, LPTSTR% pszDesc, UINT *pcchDesc);
LWSTDAPI_(int) SHMessageBoxCheckEx%(HWND hwnd, HINSTANCE hinst, LPCTSTR% pszTemplateName, DLGPROC pDlgProc, LPVOID pData, int iDefault, LPCTSTR% pszRegVal);
#define IDC_MESSAGEBOXCHECKEX 0x1202
// Prevents shell hang do to hung window on broadcastLWSTDAPI_(LRESULT) SHSendMessageBroadcast%(UINT uMsg, WPARAM wParam, LPARAM lParam);
#ifdef UNICODE#define SHGetValueGoodBoot SHGetValueGoodBootW#define SHStripMneumonic SHStripMneumonicW#define SHMessageBoxHelp SHMessageBoxHelpW#define SHMessageBoxCheck SHMessageBoxCheckW#define SHRegisterClass SHRegisterClassW#define SHUnregisterClasses SHUnregisterClassesW#define SHSendMessageBroadcast SHSendMessageBroadcastW#else // UNICODE#define SHGetValueGoodBoot SHGetValueGoodBootA#define SHStripMneumonic SHStripMneumonicA#define SHMessageBoxHelp SHMessageBoxHelpA#define SHMessageBoxCheck SHMessageBoxCheckA#define SHRegisterClass SHRegisterClassA#define SHUnregisterClasses SHUnregisterClassesA#define SHSendMessageBroadcast SHSendMessageBroadcastA#endif // UNICODE
// old IsOS() flags -- don't use these// we have to keep them public since we shipped them in win2k ;internal#define OS_MEMPHIS OS_WIN98ORGREATER // don't use this#define OS_MEMPHIS_GOLD OS_WIN98_GOLD // don't use this#define OS_WIN95GOLD OS_WIN95_GOLD#define OS_WIN2000EMBED OS_EMBEDDED#define OS_WIN2000 OS_WIN2000ORGREATER // lame, but IsOS(WIN2000) meant >= win2k#define OS_WIN95 OS_WIN95ORGREATER // lame, but IsOS(WIN95) meant >= win95#define OS_NT4 OS_NT4ORGREATER // lame, but IsOS(NT4) meant >= NT4#define OS_NT5 OS_WIN2000ORGREATER // lame, but IsOS(NT5) meant >= wink2#define OS_WIN98 OS_WIN98ORGREATER // lame, but IsOS(OS_WIN98) meant >= win98#define OS_MILLENNIUM OS_MILLENNIUMORGREATER // lame, but IsOS(OS_MILLENNIUM) meant >= winMe// end old flags
// Returns TRUE/FALSE depending on question#define OS_WINDOWS 0 // windows vs. NT#define OS_NT 1 // windows vs. NT#define OS_WIN95ORGREATER 2 // Win95 or greater#define OS_NT4ORGREATER 3 // NT4 or greater// don't use (used to be OS_NT5) 4 // this flag is redundant w/ OS_WIN2000ORGREATER, use that instead ;internal#define OS_WIN98ORGREATER 5 // Win98 or greater#define OS_WIN98_GOLD 6 // Win98 Gold (Version 4.10 build 1998)#define OS_WIN2000ORGREATER 7 // Some derivative of Win2000
;begin_internal// NOTE: these flags are bogus, they check explicitly for (dwMajorVersion == 5) so they will fail when majorversion is bumped to 6// !!! DO NOT USE THESE FLAGS !!!#define OS_WIN2000PRO 8 // Windows 2000 Professional (Workstation)#define OS_WIN2000SERVER 9 // Windows 2000 Server#define OS_WIN2000ADVSERVER 10 // Windows 2000 Advanced Server#define OS_WIN2000DATACENTER 11 // Windows 2000 Data Center Server#define OS_WIN2000TERMINAL 12 // Windows 2000 Terminal Server in "Application Server" mode (now simply called "Terminal Server")// END bogus flags;end_internal
#define OS_EMBEDDED 13 // Embedded Windows Edition#define OS_TERMINALCLIENT 14 // Windows Terminal Client (eg user is comming in via tsclient)#define OS_TERMINALREMOTEADMIN 15 // Terminal Server in "Remote Administration" mode#define OS_WIN95_GOLD 16 // Windows 95 Gold (Version 4.0 Build 1995)#define OS_MILLENNIUMORGREATER 17 // Windows Millennium (Version 5.0)
// BUGBUG - when were these added?? We didn't ship win2k w/ these, right?#define OS_WHISTLERORGREATER 18 // Whistler or greater#define OS_PERSONAL 19 // Personal (eg NOT Professional, Server, Advanced Server, or Datacenter)#if (_WIN32_IE >= 0x0600)#define OS_PROFESSIONAL 20 // Professional (aka Workstation; eg NOT Server, Advanced Server, or Datacenter)#define OS_DATACENTER 21 // Datacenter (eg NOT Server, Advanced Server, Professional, or Personal)#define OS_ADVSERVER 22 // Advanced Server (eg NOT Datacenter, Server, Professional, or Personal) #define OS_SERVER 23 // Server (eg NOT Datacenter, Advanced Server, Professional, or Personal)
#define OS_TERMINALSERVER 24 // Terminal Server - server running in what used to be called "Application Server" mode (now simply called "Terminal Server")// OS_TERMINALREMOTEADMIN 15 // Terminal Server - server running in "Remote Administration" mode#define OS_PERSONALTERMINALSERVER 25 // Personal Terminal Server - per/pro machine running in single user TS mode#define OS_FASTUSERSWITCHING 26 // Fast User Switching#define OS_FRIENDLYLOGONUI 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 server? (eg datacenter or advanced server or server)?#define OS_WOW6432 30 // Is this process a 32-bit process running on an 64-bit platform?#define OS_TABLETPC 33 // Are we running on a TabletPC?
#define OS_MEDIACENTER 35 // eHome Freestyle Project
#endif // _WIN32_IE >= 0x0600
LWSTDAPI_(BOOL) IsOS(DWORD dwOS);
///// BEGIN Private CommandTarget helpers//*** IOleCommandTarget helpers {
//*** octd -- OleCT direction// NOTES// used both as a return value from IsXxxForward, and as an iUpDown// param for MayXxxForward.enum octd { // do *not* change these values; we rely upon all 3 of: // - sign +/- // - powers of 2 // - (?) broadcast > down OCTD_DOWN=+1, OCTD_DOWNBROADCAST=+2, OCTD_UP=-1};
#ifndef RC_INVOKED /* { rc doesn't like these long symbol names */#ifdef __IOleCommandTarget_INTERFACE_DEFINED__ HRESULT IsQSForward(const GUID *pguidCmdGroup, int cCmds, OLECMD rgCmds[]); // WARNING: note the hoaky cast of nCmdID to a struct ptr #define IsExecForward(pguidCmdGroup, nCmdID) \ IsQSForward(pguidCmdGroup, 1, (OLECMD *) &nCmdID)
HRESULT MayQSForward(IUnknown *punk, int iUpDown, const GUID *pguidCmdGroup, ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pcmdtext); HRESULT MayExecForward(IUnknown *punk, int iUpDown, const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut);#endif //__IOleCommandTarget_INTERFACE_DEFINED__#endif /* } !RC_INVOKED */// }///// end
typedef struct _FDSA { // cItem *must* be at beginning of struct for GetItemCount() to work int cItem; // # elements void * aItem; // data for elements (either static or dynamic) int cItemAlloc; // # of elements currently alloc'ed (>= cItem) int cItemGrow:8; // # of elements to grow cItemAlloc by int cbItem:8; // sizeof element DWORD fAllocated:1; // 1:overflowed from static to dynamic array DWORD unused:15;} FDSA, *PFDSA;
LWSTDAPI_(BOOL) FDSA_Initialize(int cbItem, int cItemGrow, PFDSA pfdsa, void * aItemStatic, int cItemStatic);LWSTDAPI_(BOOL) FDSA_Destroy(PFDSA pfdsa);LWSTDAPI_(int) FDSA_InsertItem(PFDSA pfdsa, int index, void * pitem);LWSTDAPI_(BOOL) FDSA_DeleteItem(PFDSA pfdsa, int index);
#define FDSA_AppendItem(pfdsa, pitem) FDSA_InsertItem(pfdsa, DA_LAST, pitem)#define FDSA_GetItemPtr(pfdsa, i, type) (&(((type *)((pfdsa)->aItem))[(i)]))#define FDSA_GetItemCount(hdsa) (*(int *)(hdsa))
#if defined( __LPGUID_DEFINED__ )// Copied from OLE source code// format for string form of GUID is:// ????{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}#define GUIDSTR_MAX (1+ 8 + 1 + 4 + 1 + 4 + 1 + 4 + 1 + 12 + 1 + 1)
LWSTDAPI_(BOOL) GUIDFromString%(LPCTSTR% psz, LPGUID pguid);
#endif
#ifdef _REFGUID_DEFINEDLWSTDAPI_(int) SHStringFromGUID%(UNALIGNED REFGUID rguid, LPTSTR% psz, int cchMax);
LWSTDAPI SHRegGetCLSIDKey%(UNALIGNED REFGUID rguid, LPCTSTR% lpszSubKey, BOOL fUserSpecific, BOOL fCreate, HKEY *phkey);
LWSTDAPI_(HANDLE) SHGlobalCounterCreate(REFGUID rguid);LWSTDAPI_(HANDLE) SHGlobalCounterCreateNamed%(LPCTSTR% szName, LONG lInitialValue);LWSTDAPI_(long) SHGlobalCounterGetValue(HANDLE hCounter);LWSTDAPI_(long) SHGlobalCounterIncrement(HANDLE hCounter);LWSTDAPI_(long) SHGlobalCounterDecrement(HANDLE hCounter);#define SHGlobalCounterDestroy CloseHandle#endif
// WNDPROCs are thunked by user to send ANSI/UNICODE messages (ex: WM_WININICHANGE)// so providing a W version that automatically thunks to the A version// is dangerous. but we do it anyway. if a caller needs to work on both win95 and NT// it needs to be aware that on win95 the W version actually calls the A version.// thus all worker windows on win95 are ANSI. this should rarely affect worker wndprocs// because they are internal, and the messages are usually custom. but system messages// like WM_WININICHANGE, and the WM_DDE* messages will be changed accordinglyHWND SHCreateWorkerWindowA(WNDPROC pfnWndProc, HWND hwndParent, DWORD dwExStyle, DWORD dwFlags, HMENU hmenu, void * p);HWND SHCreateWorkerWindowW(WNDPROC pfnWndProc, HWND hwndParent, DWORD dwExStyle, DWORD dwFlags, HMENU hmenu, void * p);#ifdef UNICODE#define SHCreateWorkerWindow SHCreateWorkerWindowW#else#define SHCreateWorkerWindow SHCreateWorkerWindowA#endif
BOOL SHAboutInfoA(LPSTR lpszInfo, DWORD cchSize);BOOL SHAboutInfoW(LPWSTR lpszInfo, DWORD cchSize);
#ifdef UNICODE#define SHAboutInfo SHAboutInfoW#else#define SHAboutInfo SHAboutInfoA#endif
// Types for SHIsLowMemoryMachine#define ILMM_IE4 0 // 1997-style machine
LWSTDAPI_(BOOL) SHIsLowMemoryMachine(DWORD dwType);
LWSTDAPI_(HINSTANCE) SHPinDllOfCLSID(const CLSID *pclsid);
// Menu HelpersLWSTDAPI_(int) GetMenuPosFromID(HMENU hmenu, UINT id);
LWSTDAPI SHGetInverseCMAP(BYTE *pbMap, ULONG cbMap);
//// Shared memory apis//
LWSTDAPI_(HANDLE) SHAllocShared(const void *pvData, DWORD dwSize, DWORD dwProcessId);LWSTDAPI_(BOOL) SHFreeShared(HANDLE hData,DWORD dwProcessId);LWSTDAPI_(void *) SHLockShared(HANDLE hData, DWORD dwProcessId);LWSTDAPI_(void *) SHLockSharedEx(HANDLE hData, DWORD dwProcessId, BOOL fForWriting);LWSTDAPI_(BOOL) SHUnlockShared(void *pvData);LWSTDAPI_(HANDLE) SHMapHandle(HANDLE h, DWORD dwProcSrc, DWORD dwProcDest, DWORD dwDesiredAccess, DWORD dwFlags);
//// Shared memory structs//
#define MAPHEAD_SIG 0xbaff1aff
typedef struct _shmapheader { DWORD dwSize; DWORD dwSig; DWORD dwSrcId; DWORD dwDstId;} SHMAPHEADER; // NOTE: should always be QUADWORD alignment
#ifdef UNIX#include <urlmon.h>#endif /* UNIX */
//// Zone Security APIs//LWSTDAPI ZoneCheckPathA(LPCSTR pszPath, DWORD dwActionType, DWORD dwFlags, IInternetSecurityMgrSite * pisms);LWSTDAPI ZoneCheckPathW(LPCWSTR pwzPath, DWORD dwActionType, DWORD dwFlags, IInternetSecurityMgrSite * pisms);
LWSTDAPI ZoneCheckUrlA(LPCSTR pszUrl, DWORD dwActionType, DWORD dwFlags, IInternetSecurityMgrSite * pisms);LWSTDAPI ZoneCheckUrlW(LPCWSTR pwzUrl, DWORD dwActionType, DWORD dwFlags, IInternetSecurityMgrSite * pisms);LWSTDAPI ZoneCheckUrlExA(LPCSTR pszUrl, DWORD * pdwPolicy, DWORD dwPolicySize, DWORD * pdwContext, DWORD dwContextSize, DWORD dwActionType, DWORD dwFlags, IInternetSecurityMgrSite * pisms);LWSTDAPI ZoneCheckUrlExW(LPCWSTR pwzUrl, DWORD * pdwPolicy, DWORD dwPolicySize, DWORD * pdwContext, DWORD dwContextSize, DWORD dwActionType, DWORD dwFlags, IInternetSecurityMgrSite * pisms);LWSTDAPI ZoneCheckUrlExCacheA(LPCSTR pszUrl, DWORD * pdwPolicy, DWORD dwPolicySize, DWORD * pdwContext, DWORD dwContextSize, DWORD dwActionType, DWORD dwFlags, IInternetSecurityMgrSite * pisms, IInternetSecurityManager ** ppismCache);LWSTDAPI ZoneCheckUrlExCacheW(LPCWSTR pwzUrl, DWORD * pdwPolicy, DWORD dwPolicySize, DWORD * pdwContext, DWORD dwContextSize, DWORD dwActionType, DWORD dwFlags, IInternetSecurityMgrSite * pisms, IInternetSecurityManager ** ppismCache);
LWSTDAPI ZoneCheckHost(IInternetHostSecurityManager * pihsm, DWORD dwActionType, DWORD dwFlags);LWSTDAPI ZoneCheckHostEx(IInternetHostSecurityManager * pihsm, DWORD * pdwPolicy, DWORD dwPolicySize, DWORD * pdwContext, DWORD dwContextSize, DWORD dwActionType, DWORD dwFlags);LWSTDAPI_(int) ZoneComputePaneSize(HWND hwndStatus);LWSTDAPI_(void) ZoneConfigureW(HWND hwnd, LPCWSTR pwszUrl);
#ifdef UNICODE#define ZoneCheckUrl ZoneCheckUrlW#define ZoneCheckPath ZoneCheckPathW#define ZoneCheckUrlEx ZoneCheckUrlExW#define ZoneCheckUrlExCache ZoneCheckUrlExCacheW#else // UNICODE#define ZoneCheckUrl ZoneCheckUrlA#define ZoneCheckPath ZoneCheckPathA#define ZoneCheckUrlEx ZoneCheckUrlExA#define ZoneCheckUrlExCache ZoneCheckUrlExCacheA#endif // UNICODE
LWSTDAPI SHRegisterValidateTemplate(LPCWSTR pwzTemplate, DWORD dwFlags);
// Flags for SHRegisterValidateTemplate#define SHRVT_REGISTER 0x00000001#define SHRVT_VALIDATE 0x00000002#define SHRVT_PROMPTUSER 0x00000004#define SHRVT_REGISTERIFPROMPTOK 0x00000008#define SHRVT_ALLOW_INTRANET 0x00000010#define SHRVT_VALID 0x0000001f
BOOL RegisterGlobalHotkeyW(WORD wOldHotkey, WORD wNewHotkey,LPCWSTR pcwszPath);BOOL RegisterGlobalHotkeyA(WORD wOldHotkey, WORD wNewHotkey,LPCSTR pcszPath);
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
#ifdef UNICODE#define RegisterGlobalHotkey RegisterGlobalHotkeyW#else // UNICODE#define RegisterGlobalHotkey RegisterGlobalHotkeyA#endif // UNICODE
// qistub {
//*** 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;// }
typedef struct{ const IID * piid; int dwOffset;} QITAB, *LPQITAB;typedef const QITAB *LPCQITAB;
#define QITABENTMULTI(Cthis, Ifoo, Iimpl) \ { (IID*) &IID_##Ifoo, OFFSETOFCLASS(Iimpl, Cthis) }
#define QITABENTMULTI2(Cthis, Ifoo, Iimpl) \ { (IID*) &Ifoo, OFFSETOFCLASS(Iimpl, Cthis) }
#define QITABENT(Cthis, Ifoo) QITABENTMULTI(Cthis, Ifoo, Ifoo)
STDAPI QISearch(void* that, LPCQITAB pqit, REFIID riid, void **ppv);
#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
// } qistub
#if (_WIN32_IE >= 0x0500)
// SHRestrictionLookuptypedef struct{ INT iFlag; LPCWSTR pszKey; LPCWSTR pszValue;} SHRESTRICTIONITEMS;
LWSTDAPI_(DWORD) SHRestrictionLookup(INT iFlag, LPCWSTR pszBaseKey, const SHRESTRICTIONITEMS *pRestrictions, DWORD* rdwRestrictionItemValues);LWSTDAPI_(DWORD) SHGetRestriction(LPCWSTR pszBaseKey, LPCWSTR pszGroup, LPCWSTR pszSubKey);
typedef INT_PTR (CALLBACK* SHDLGPROC)(void *lpData, HWND, UINT, WPARAM, LPARAM);LWSTDAPI_(INT_PTR) SHDialogBox(HINSTANCE hInstance, LPCWSTR lpTemplateName, HWND hwndParent, SHDLGPROC lpDlgFunc, void*lpData);
LWSTDAPI SHInvokeDefaultCommand(HWND hwnd, struct IShellFolder* psf, LPCITEMIDLIST pidl);LWSTDAPI SHInvokeCommand(HWND hwnd, struct IShellFolder* psf, LPCITEMIDLIST pidl, LPCSTR lpVerb);LWSTDAPI SHInvokeCommandOnContextMenu(HWND hwnd, struct IUnknown* punk, struct IContextMenu *pcm, DWORD fMask, LPCSTR lpVerb);LWSTDAPI SHInvokeCommandsOnContextMenu(HWND hwnd, struct IUnknown* punk, struct IContextMenu *pcm, DWORD fMask, const LPCSTR rgszVerbs[], UINT cVerbs);LWSTDAPI SHForwardContextMenuMsg(struct IContextMenu* pcm, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT* plResult, BOOL fAllowICM2);LWSTDAPI IUnknown_DoContextMenuPopup(struct IUnknown *punkSite, struct IContextMenu* pcm, UINT fFlags, POINT pt);
#endif // _WIN32_IE >= 0x0500
//============= Internal Routines that are always to be built ================LWSTDAPI_(DWORD)GetLongPathNameWrapW( LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer);
LWSTDAPI_(DWORD)GetLongPathNameWrapA( LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD cchBuffer);
#ifdef UNICODE#define GetLongPathNameWrap GetLongPathNameWrapW#else#define GetLongPathNameWrap GetLongPathNameWrapA#endif //UNICODE
//=============== Unicode Wrapper Routines ===================================
#if (_WIN32_IE >= 0x0500) && !defined(NO_SHLWAPI_UNITHUNK)
//// There are two styles of usage for the wrap functions.//// * Explicit wrapping.//// If you explicitly call GetPropWrap (for example), then// your UNICODE build will call the wrapper function, and your ANSI// build will call the normal ANSI API directly.//// Calls to GetProp, GetPropW, and GetPropA still go// directly to the underlying system DLL that implements them.//// This lets you select which calls to UNICODE APIs should get// wrapped and which should go straight through to the OS// (and most likely fail on Win95).//// * Automatic wrapping.//// If you #include <w95wraps.h>, then when you call GetProp,// your UNICODE build will call the wrapper function, and your ANSI// ANSI build will call the normal ANSI API directly.//// This lets you just call the UNICODE APIs normally throughout// your code, and the wrappers will do their best.//// Here's a table explaining what you get under the various scenarios.//// You Get// <w95wraps.h> <w95wraps.h>// You Write UNICODE ANSI UNICODE ANSI// ============ ============ ============ ============ ============// GetProp GetPropW GetPropA GetPropWrapW GetPropA// GetPropWrap GetPropWrapW GetPropA GetPropWrapW GetPropA//// GetPropW GetPropW GetPropW GetPropWrapW GetPropWrapW// GetPropA GetPropA GetPropA GetPropA GetPropA// GetPropWrapW GetPropWrapW GetPropWrapW GetPropWrapW GetPropWrapW// GetPropWrapA GetPropA GetPropA GetPropA GetPropA//// Final quirk: If you are running on a non-x86 platform, then the// wrap functions are forwarded to the unwrapped functions, since// the only OS that runs on non-x86 is NT.//// Before using the wrapper functions, see the warnings at the top of// <w95wraps.h> to make sure you understand the consequences.//LWSTDAPI_(BOOL) IsCharAlphaWrapW(IN WCHAR ch);LWSTDAPI_(BOOL) IsCharUpperWrapW(IN WCHAR ch);LWSTDAPI_(BOOL) IsCharLowerWrapW(IN WCHAR ch);LWSTDAPI_(BOOL) IsCharAlphaNumericWrapW(IN WCHAR ch);
LWSTDAPI_(BOOL)AppendMenuWrapW( IN HMENU hMenu, IN UINT uFlags, IN UINT_PTR uIDNewItem, IN LPCWSTR lpNewItem );
LWSTDAPI_(LRESULT)CallWindowProcWrapW( WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
#ifdef POST_IE5_BETALWSTDAPI_(BOOL) CallMsgFilterWrapW(LPMSG lpMsg, int nCode);#endif
LWSTDAPI_(LPWSTR) CharLowerWrapW( LPWSTR pch );
LWSTDAPI_(DWORD) CharLowerBuffWrapW( LPWSTR pch, DWORD cchLength );
LWSTDAPI_(LPWSTR) CharNextWrapW(LPCWSTR lpszCurrent);LWSTDAPI_(LPWSTR) CharPrevWrapW(LPCWSTR lpszStart, LPCWSTR lpszCurrent);LWSTDAPI_(BOOL) CharToOemWrapW(LPCWSTR lpszSrc, LPSTR lpszDst);LWSTDAPI_(LPWSTR) CharUpperWrapW( LPWSTR pch );LWSTDAPI_(DWORD) CharUpperBuffWrapW( LPWSTR pch, DWORD cchLength );
LWSTDAPI_(HRESULT) CLSIDFromStringWrap(LPOLESTR lpsz, LPCLSID pclsid);LWSTDAPI_(HRESULT) CLSIDFromProgIDWrap(LPCOLESTR lpszProgID, LPCLSID lpclsid);
LWSTDAPI_(int)CompareStringWrapW( LCID Locale, DWORD dwCmpFlags, LPCWSTR lpString1, int cchCount1, LPCWSTR lpString2, int cchCount2);
LWSTDAPI_(int)CopyAcceleratorTableWrapW( HACCEL hAccelSrc, LPACCEL lpAccelDst, int cAccelEntries);
LWSTDAPI_(HACCEL)CreateAcceleratorTableWrapW(LPACCEL lpAccel, int cEntries);
LWSTDAPI_(HDC)CreateDCWrapW( LPCWSTR lpszDriver, LPCWSTR lpszDevice, LPCWSTR lpszOutput, CONST DEVMODEW * lpInitData);
LWSTDAPI_(BOOL)CreateDirectoryWrapW( LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
LWSTDAPI_(HANDLE)CreateEventWrapW( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCWSTR lpName);
LWSTDAPI_(HANDLE)CreateFileWrapW( LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
LWSTDAPI_(HFONT)CreateFontIndirectWrapW(CONST LOGFONTW * plfw);
LWSTDAPI_(HDC)CreateICWrapW( LPCWSTR lpszDriver, LPCWSTR lpszDevice, LPCWSTR lpszOutput, CONST DEVMODEW * lpInitData);
LWSTDAPI_(HWND)CreateWindowExWrapW( DWORD dwExStyle, LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, void * lpParam);
LWSTDAPI_(LRESULT)DefWindowProcWrapW(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
LWSTDAPI_(BOOL) DeleteFileWrapW(LPCWSTR pwsz);
LWSTDAPI_(LRESULT)DispatchMessageWrapW(CONST MSG * lpMsg);
LWSTDAPI_(int)DrawTextWrapW( HDC hDC, LPCWSTR lpString, int nCount, LPRECT lpRect, UINT uFormat);
LWSTDAPI_(int)EnumFontFamiliesWrapW( HDC hdc, LPCWSTR lpszFamily, FONTENUMPROCW lpEnumFontProc, LPARAM lParam);
LWSTDAPI_(int)EnumFontFamiliesExWrapW( HDC hdc, LPLOGFONTW lplfw, FONTENUMPROCW lpEnumFontProc, LPARAM lParam, DWORD dwFlags );
LWSTDAPI_(BOOL)EnumResourceNamesWrapW( HINSTANCE hModule, LPCWSTR lpType, ENUMRESNAMEPROCW lpEnumFunc, LONG_PTR lParam);
LWSTDAPI_(BOOL)ExtTextOutWrapW( HDC hdc, int x, int y, UINT fuOptions, CONST RECT * lprc, LPCWSTR lpString, UINT nCount, CONST INT * lpDx);
LWSTDAPI_(HANDLE)FindFirstFileWrapW( LPCWSTR lpFileName, LPWIN32_FIND_DATAW pwszFd);
LWSTDAPI_(HRSRC)FindResourceWrapW(HINSTANCE hModule, LPCWSTR lpName, LPCWSTR lpType);
LWSTDAPI_(HWND)FindWindowWrapW(LPCWSTR lpClassName, LPCWSTR lpWindowName);
LWSTDAPI_(DWORD)FormatMessageWrapW( DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPWSTR lpBuffer, DWORD nSize, va_list * Arguments);
LWSTDAPI_(BOOL)GetClassInfoWrapW(HINSTANCE hModule, LPCWSTR lpClassName, LPWNDCLASSW lpWndClassW);
LWSTDAPI_(DWORD)GetClassLongWrapW(HWND hWnd, int nIndex);
LWSTDAPI_(int)GetClassNameWrapW(HWND hWnd, LPWSTR lpClassName, int nMaxCount);
LWSTDAPI_(int)GetClipboardFormatNameWrapW(UINT format, LPWSTR lpFormatName, int cchFormatName);
LWSTDAPI_(DWORD)GetCurrentDirectoryWrapW(DWORD nBufferLength, LPWSTR lpBuffer);
LWSTDAPI_(UINT)GetDlgItemTextWrapW( HWND hWndDlg, int idControl, LPWSTR lpsz, int cchMax);
LWSTDAPI_(DWORD)GetFileAttributesWrapW(LPCWSTR lpFileName);
// Cannot be LWSTDAPI because winver.h declares the function as STDAPI and not DLLIMPORTSTDAPI_(BOOL)GetFileVersionInfoWrapW(LPWSTR pwzFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData);
// Cannot be LWSTDAPI because winver.h declares the function as STDAPI and not DLLIMPORTSTDAPI_(DWORD)GetFileVersionInfoSizeWrapW(LPWSTR pwzFilename, LPDWORD lpdwHandle);
LWSTDAPI_(DWORD)GetFullPathNameWrapW( LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR *lpFilePart);
LWSTDAPI_(int)GetLocaleInfoWrapW(LCID Locale, LCTYPE LCType, LPWSTR lpsz, int cchData);
LWSTDAPI_(int)GetMenuStringWrapW( HMENU hMenu, UINT uIDItem, LPWSTR lpString, int nMaxCount, UINT uFlag);
LWSTDAPI_(BOOL)GetMessageWrapW( LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax);
LWSTDAPI_(DWORD)GetModuleFileNameWrapW(HINSTANCE hModule, LPWSTR pwszFilename, DWORD nSize);
LWSTDAPI_(UINT)GetSystemDirectoryWrapW(LPWSTR lpBuffer, UINT uSize);
LWSTDAPI_(DWORD)GetEnvironmentVariableWrapW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize);
LWSTDAPI_(DWORD)SearchPathWrapW( LPCWSTR lpPathName, LPCWSTR lpFileName, LPCWSTR lpExtension, DWORD cchReturnBuffer, LPWSTR lpReturnBuffer, LPWSTR * plpfilePart);
LWSTDAPI_(HMODULE)GetModuleHandleWrapW(LPCWSTR lpModuleName);
LWSTDAPI_(int)GetObjectWrapW(HGDIOBJ hgdiObj, int cbBuffer, void *lpvObj);
LWSTDAPI_(UINT)GetPrivateProfileIntWrapW( LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault, LPCWSTR lpFileName);
LWSTDAPI_(DWORD)GetProfileStringWrapW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpBuffer, DWORD dwBuffersize);
LWSTDAPI_(HANDLE)GetPropWrapW(HWND hWnd, LPCWSTR lpString);
LWSTDAPI_(ATOM)GlobalAddAtomWrapW(LPCWSTR lpAtomName);
LWSTDAPI_(ATOM)GlobalFindAtomWrapW(LPCWSTR lpAtomName);
LWSTDAPI_(DWORD)GetShortPathNameWrapW( LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWORD cchBuffer);
LWSTDAPI_(BOOL)GetStringTypeExWrapW(LCID lcid, DWORD dwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType);
LWSTDAPI_(UINT)GetTempFileNameWrapW( LPCWSTR lpPathName, LPCWSTR lpPrefixString, UINT uUnique, LPWSTR lpTempFileName);
LWSTDAPI_(DWORD)GetTempPathWrapW(DWORD nBufferLength, LPWSTR lpBuffer);
LWSTDAPI_(BOOL)GetTextExtentPoint32WrapW( HDC hdc, LPCWSTR pwsz, int cb, LPSIZE pSize);
LWSTDAPI_(int)GetTextFaceWrapW( HDC hdc, int cch, LPWSTR lpFaceName);
LWSTDAPI_(BOOL)GetTextMetricsWrapW(HDC hdc, LPTEXTMETRICW lptm);
LWSTDAPI_(BOOL)GetUserNameWrapW(LPWSTR lpUserName, LPDWORD lpcchName);
LWSTDAPI_(LONG)GetWindowLongWrapW(HWND hWnd, int nIndex);
LWSTDAPI_(int)GetWindowTextWrapW(HWND hWnd, LPWSTR lpString, int nMaxCount);
LWSTDAPI_(int)GetWindowTextLengthWrapW(HWND hWnd);
LWSTDAPI_(UINT)GetWindowsDirectoryWrapW(LPWSTR lpWinPath, UINT cch);
LWSTDAPI_(BOOL)InsertMenuWrapW( HMENU hMenu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCWSTR lpNewItem);
LWSTDAPI_(BOOL)IsDialogMessageWrapW(HWND hWndDlg, LPMSG lpMsg);
LWSTDAPI_(HACCEL)LoadAcceleratorsWrapW(HINSTANCE hInstance, LPCWSTR lpTableName);
LWSTDAPI_(HBITMAP)LoadBitmapWrapW(HINSTANCE hInstance, LPCWSTR lpBitmapName);
LWSTDAPI_(HCURSOR)LoadCursorWrapW(HINSTANCE hInstance, LPCWSTR lpCursorName);
LWSTDAPI_(HICON)LoadIconWrapW(HINSTANCE hInstance, LPCWSTR lpIconName);
LWSTDAPI_(HANDLE)LoadImageWrapA( HINSTANCE hInstance, LPCSTR lpName, UINT uType, int cxDesired, int cyDesired, UINT fuLoad);
LWSTDAPI_(HANDLE)LoadImageWrapW( HINSTANCE hInstance, LPCWSTR lpName, UINT uType, int cxDesired, int cyDesired, UINT fuLoad);
LWSTDAPI_(HINSTANCE)LoadLibraryExWrapW( LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
LWSTDAPI_(HMENU)LoadMenuWrapW(HINSTANCE hInstance, LPCWSTR lpMenuName);
LWSTDAPI_(int)LoadStringWrapW(HINSTANCE hInstance, UINT uID, LPWSTR lpBuffer, int nBufferMax);
#ifndef UNIXLWSTDAPI_(BOOL)MessageBoxIndirectWrapW(CONST MSGBOXPARAMSW *pmbp);#elseLWSTDAPI_(int)MessageBoxIndirectWrapW(LPMSGBOXPARAMSW pmbp);#endif /* UNIX */
LWSTDAPI_(BOOL)ModifyMenuWrapW( HMENU hMenu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCWSTR lpNewItem);
LWSTDAPI_(BOOL)GetCharWidth32WrapW( HDC hdc, UINT iFirstChar, UINT iLastChar, LPINT lpBuffer);
LWSTDAPI_(DWORD)GetCharacterPlacementWrapW( HDC hdc, // handle to device context LPCWSTR lpString, // pointer to string int nCount, // number of characters in string int nMaxExtent, // maximum extent for displayed string LPGCP_RESULTSW lpResults, // pointer to buffer for placement result DWORD dwFlags // placement flags );
LWSTDAPI_(BOOL)CopyFileWrapW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, BOOL bFailIfExists);
LWSTDAPI_(BOOL)MoveFileWrapW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName);
LWSTDAPI_(BOOL)OemToCharWrapW(LPCSTR lpszSrc, LPWSTR lpszDst);
LWSTDAPI_(HANDLE)OpenEventWrapW( DWORD fdwAccess, BOOL fInherit, LPCWSTR lpszEventName);
LWSTDAPI_(void)OutputDebugStringWrapW(LPCWSTR lpOutputString);
LWSTDAPI_(BOOL)PeekMessageWrapW( LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg);
LWSTDAPI_(BOOL)PlaySoundWrapW( LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound);
LWSTDAPI_(BOOL)PostMessageWrapW( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
LWSTDAPI_(BOOL)PostThreadMessageWrapW( DWORD idThread, UINT Msg, WPARAM wParam, LPARAM lParam);
LWSTDAPI_(LONG)RegCreateKeyWrapW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult);
LWSTDAPI_(LONG)RegCreateKeyExWrapW(HKEY hKey, LPCWSTR lpSubKey, DWORD Reserved, LPWSTR lpClass, DWORD dwOptions, REGSAM samDesired, LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition);
LWSTDAPI_(LONG)RegDeleteKeyWrapW(HKEY hKey, LPCWSTR pwszSubKey);
LWSTDAPI_(LONG)RegDeleteValueWrapW(HKEY hKey, LPCWSTR pwszSubKey);
LWSTDAPI_(LONG)RegEnumKeyWrapW( HKEY hKey, DWORD dwIndex, LPWSTR lpName, DWORD cbName);
LWSTDAPI_(LONG)RegEnumKeyExWrapW( HKEY hKey, DWORD dwIndex, LPWSTR lpName, LPDWORD lpcbName, LPDWORD lpReserved, LPWSTR lpClass, LPDWORD lpcbClass, PFILETIME lpftLastWriteTime);
LWSTDAPI_(LONG)RegOpenKeyWrapW(HKEY hKey, LPCWSTR pwszSubKey, PHKEY phkResult);
LWSTDAPI_(LONG)RegOpenKeyExWrapW( HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult);
LWSTDAPI_(LONG)RegQueryInfoKeyWrapW( HKEY hKey, LPWSTR lpClass, LPDWORD lpcbClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcbMaxSubKeyLen, LPDWORD lpcbMaxClassLen, LPDWORD lpcValues, LPDWORD lpcbMaxValueNameLen, LPDWORD lpcbMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime);
LWSTDAPI_(LONG)RegQueryValueWrapW( HKEY hKey, LPCWSTR pwszSubKey, LPWSTR pwszValue, PLONG lpcbValue);
LWSTDAPI_(LONG)RegQueryValueExWrapW( HKEY hKey, LPCWSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);
LWSTDAPI_(LONG)RegSetValueWrapW( HKEY hKey, LPCWSTR lpSubKey, DWORD dwType, LPCWSTR lpData, DWORD cbData);
LWSTDAPI_(LONG)RegSetValueExWrapW( HKEY hKey, LPCWSTR lpValueName, DWORD Reserved, DWORD dwType, CONST BYTE* lpData, DWORD cbData);
LWSTDAPI_(ATOM)RegisterClassWrapW(CONST WNDCLASSW * lpWndClass);
LWSTDAPI_(UINT)RegisterClipboardFormatWrapW(LPCWSTR lpString);
LWSTDAPI_(UINT)RegisterWindowMessageWrapW(LPCWSTR lpString);
LWSTDAPI_(BOOL)RemoveDirectoryWrapW(LPCWSTR lpszDir);
LWSTDAPI_(HANDLE)RemovePropWrapW( HWND hWnd, LPCWSTR lpString);
LWSTDAPI_(LRESULT)SendDlgItemMessageWrapW( HWND hDlg, int nIDDlgItem, UINT Msg, WPARAM wParam, LPARAM lParam);
LWSTDAPI_(LRESULT)SendMessageWrapW( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
LWSTDAPI_(LRESULT)SendMessageTimeoutWrapW( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT uFlags, UINT uTimeout, PULONG_PTR lpdwResult);
LWSTDAPI_(BOOL)SetCurrentDirectoryWrapW(LPCWSTR lpszCurDir);
LWSTDAPI_(BOOL)SetDlgItemTextWrapW(HWND hDlg, int nIDDlgItem, LPCWSTR lpString);
LWSTDAPI_(BOOL)SetMenuItemInfoWrapW( HMENU hMenu, UINT uItem, BOOL fByPosition, LPCMENUITEMINFOW lpmiiW);
LWSTDAPI_(BOOL)SetPropWrapW( HWND hWnd, LPCWSTR lpString, HANDLE hData);
LWSTDAPI_(LONG)SetWindowLongWrapW(HWND hWnd, int nIndex, LONG dwNewLong);
LWSTDAPI_(HHOOK)SetWindowsHookExWrapW( int idHook, HOOKPROC lpfn, HINSTANCE hmod, DWORD dwThreadId);
LWSTDAPI_(int)StartDocWrapW( HDC hDC, const DOCINFOW * lpdi );
LWSTDAPI_(BOOL)SystemParametersInfoWrapW( UINT uiAction, UINT uiParam, void *pvParam, UINT fWinIni);
LWSTDAPI_(BOOL)TrackPopupMenuWrap(HMENU hMenu, UINT uFlags, int x, int y, int nReserved, HWND hWnd, CONST RECT *prcRect);
LWSTDAPI_(BOOL)TrackPopupMenuExWrap(HMENU hMenu, UINT uFlags, int x, int y, HWND hWnd, LPTPMPARAMS lptpm);
LWSTDAPI_(int)TranslateAcceleratorWrapW(HWND hWnd, HACCEL hAccTable, LPMSG lpMsg);
LWSTDAPI_(BOOL)UnregisterClassWrapW(LPCWSTR lpClassName, HINSTANCE hInstance);
// Cannot be LWSTDAPI because winver.h declares the function as STDAPI and not DLLIMPORTSTDAPI_(BOOL)VerQueryValueWrapW(const LPVOID pBlock, LPWSTR pwzSubBlock, LPVOID *ppBuffer, PUINT puLen);
LWSTDAPI_(SHORT)VkKeyScanWrapW(WCHAR ch);
LWSTDAPI_(BOOL)WinHelpWrapW(HWND hwnd, LPCWSTR szFile, UINT uCmd, DWORD_PTR dwData);
LWSTDAPI_(int)wvsprintfWrapW(LPWSTR pwszOut, LPCWSTR pwszFormat, va_list arglist);
// Cannot be LWSTDAPI because winnetp.h declares the function as STDAPI and not DLLIMPORTSTDAPI_(DWORD) WNetRestoreConnectionWrapW(IN HWND hwndParent, IN LPCWSTR pwzDevice);// Cannot be LWSTDAPI because winnetwk.h declares the function as STDAPI and not DLLIMPORTSTDAPI_(DWORD) WNetGetLastErrorWrapW(OUT LPDWORD pdwError, OUT LPWSTR pwzErrorBuf, IN DWORD cchErrorBufSize, OUT LPWSTR pwzNameBuf, IN DWORD cchNameBufSize);
LWSTDAPI_(int) DrawTextExWrapW(HDC hdc, LPWSTR pwzText, int cchText, LPRECT lprc, UINT dwDTFormat, LPDRAWTEXTPARAMS lpDTParams);LWSTDAPI_(BOOL) GetMenuItemInfoWrapW(HMENU hMenu, UINT uItem, BOOL fByPosition, LPMENUITEMINFOW pmiiW);LWSTDAPI_(BOOL) InsertMenuItemWrapW(HMENU hMenu, UINT uItem, BOOL fByPosition, LPCMENUITEMINFOW pmiiW);
LWSTDAPI_(HFONT) CreateFontWrapW(int nHeight, int nWidth, int nEscapement, int nOrientation, int fnWeight, DWORD fdwItalic, DWORD fdwUnderline, DWORD fdwStrikeOut, DWORD fdwCharSet, DWORD fdwOutputPrecision, DWORD fdwClipPrecision, DWORD fdwQuality, DWORD fdwPitchAndFamily, LPCWSTR lpszFace);LWSTDAPI_(HDC) CreateMetaFileWrapW(LPCWSTR pwzFile);LWSTDAPI_(HANDLE) CreateMutexWrapW(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCWSTR pwzName);LWSTDAPI_(DWORD) ExpandEnvironmentStringsWrapW(LPCWSTR pwszSrc, LPWSTR pwszDst, DWORD cchSize);LWSTDAPI_(DWORD) SHExpandEnvironmentStrings%(LPCTSTR% pszSrc, LPTSTR% pszDst, DWORD cchSize);LWSTDAPI_(DWORD) SHExpandEnvironmentStringsForUser%(HANDLE hToken, LPCTSTR% pszSrc, LPTSTR% pszDst, DWORD cchSize);
LWSTDAPI_(HANDLE) CreateSemaphoreWrapW(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCWSTR pwzName);LWSTDAPI_(BOOL) IsBadStringPtrWrapW(LPCWSTR pwzString, UINT_PTR ucchMax);LWSTDAPI_(HINSTANCE) LoadLibraryWrapW(LPCWSTR pwzLibFileName);LWSTDAPI_(int) GetTimeFormatWrapW(LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpTime, LPCWSTR pwzFormat, LPWSTR pwzTimeStr, int cchTime);LWSTDAPI_(int) GetDateFormatWrapW(LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpDate, LPCWSTR pwzFormat, LPWSTR pwzDateStr, int cchDate);LWSTDAPI_(DWORD) GetPrivateProfileStringWrapW(LPCWSTR pwzAppName, LPCWSTR pwzKeyName, LPCWSTR pwzDefault, LPWSTR pwzReturnedString, DWORD cchSize, LPCWSTR pwzFileName);LWSTDAPI_(BOOL) WritePrivateProfileStringWrapW(LPCWSTR pwzAppName, LPCWSTR pwzKeyName, LPCWSTR pwzString, LPCWSTR pwzFileName);
#ifndef SHFILEINFO_DEFINED#define SHFILEINFO_DEFINED
/* * The SHGetFileInfo API provides an easy way to get attributes * for a file given a pathname. * * PARAMETERS * * pszPath file name to get info about * dwFileAttributes file attribs, only used with SHGFI_USEFILEATTRIBUTES * psfi place to return file info * cbFileInfo size of structure * uFlags flags * * RETURN * TRUE if things worked */
typedef struct _SHFILEINFO%{ HICON hIcon; // out: icon int iIcon; // out: icon index DWORD dwAttributes; // out: SFGAO_ flags TCHAR% szDisplayName[MAX_PATH]; // out: display name (or path) TCHAR% szTypeName[80]; // out: type name} SHFILEINFO%;
// NOTE: This is also in shellapi.h. Please keep in synch.#endif // !SHFILEINFO_DEFINEDLWSTDAPI_(DWORD_PTR) SHGetFileInfoWrapW(LPCWSTR pwzPath, DWORD dwFileAttributes, SHFILEINFOW *psfi, UINT cbFileInfo, UINT uFlags);
LWSTDAPI_(ATOM) RegisterClassExWrapW(CONST WNDCLASSEXW *pwcx);LWSTDAPI_(BOOL) GetClassInfoExWrapW(HINSTANCE hinst, LPCWSTR pwzClass, LPWNDCLASSEXW lpwcx);
// This allows us to be included either before or after shellapi.h#ifdef STRICTLWSTDAPI_(UINT) DragQueryFileWrapW(struct HDROP__*,UINT,LPWSTR,UINT);#elseLWSTDAPI_(UINT) DragQueryFileWrapW(HANDLE,UINT,LPWSTR,UINT);#endif
LWSTDAPI_(HWND) FindWindowExWrapW(HWND hwndParent, HWND hwndChildAfter, LPCWSTR pwzClassName, LPCWSTR pwzWindowName);LWSTDAPI_(LPITEMIDLIST) SHBrowseForFolderWrapW(struct _browseinfoW * pbiW);LWSTDAPI_(BOOL) SHGetPathFromIDListWrapW(LPCITEMIDLIST pidl, LPWSTR pwzPath);LWSTDAPI_(BOOL) SHGetNewLinkInfoWrapW(LPCWSTR pszpdlLinkTo, LPCWSTR pszDir, LPWSTR pszName, BOOL *pfMustCopy, UINT uFlags);LWSTDAPI SHDefExtractIconWrapW(LPCWSTR pszIconFile, int iIndex, UINT uFlags, HICON *phiconLarge, HICON *phiconSmall, UINT nIconSize);LWSTDAPI_(BOOL) GetUserNameWrapW(LPWSTR pszBuffer, LPDWORD pcch);LWSTDAPI_(LONG) RegEnumValueWrapW(HKEY hkey, DWORD dwIndex, LPWSTR lpValueName, LPDWORD lpcbValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);LWSTDAPI_(BOOL) WritePrivateProfileStructWrapW(LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile);LWSTDAPI_(BOOL) GetPrivateProfileStructWrapW(LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile);LWSTDAPI_(BOOL) CreateProcessWrapW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes,LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory,LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);LWSTDAPI_(HICON) ExtractIconWrapW(HINSTANCE hInst, LPCWSTR lpszExeFileName, UINT nIconIndex);#ifndef WIN32_LEAN_AND_MEAN// Cannot be LWSTDAPI because ddeml.h declares the function as STDAPI and not DLLIMPORTSTDAPI_(UINT) DdeInitializeWrapW(LPDWORD pidInst, PFNCALLBACK pfnCallback, DWORD afCmd, DWORD ulRes);STDAPI_(HSZ) DdeCreateStringHandleWrapW(DWORD idInst, LPCWSTR psz, int iCodePage);STDAPI_(DWORD) DdeQueryStringWrapW(DWORD idInst, HSZ hsz, LPWSTR psz, DWORD cchMax, int iCodePage);
LWSTDAPI_(BOOL) GetSaveFileNameWrapW(LPOPENFILENAMEW lpofn);LWSTDAPI_(BOOL) GetOpenFileNameWrapW(LPOPENFILENAMEW lpofn);LWSTDAPI_(BOOL) PrintDlgWrapW(LPPRINTDLGW lppd);LWSTDAPI_(BOOL) PageSetupDlgWrapW(LPPAGESETUPDLGW lppsd);#endifLWSTDAPI_(void) SHChangeNotifyWrap(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2);LWSTDAPI_(void) SHFlushSFCacheWrap(void);LWSTDAPI_(BOOL) ShellExecuteExWrapW(struct _SHELLEXECUTEINFOW * pExecInfoW);LWSTDAPI_(int) SHFileOperationWrapW(struct _SHFILEOPSTRUCTW * pFileOpW);LWSTDAPI_(UINT) ExtractIconExWrapW(LPCWSTR pwzFile, int nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIcons);LWSTDAPI_(BOOL) SetFileAttributesWrapW(LPCWSTR pwzFile, DWORD dwFileAttributes);LWSTDAPI_(int) GetNumberFormatWrapW(LCID Locale, DWORD dwFlags, LPCWSTR pwzValue, CONST NUMBERFMTW * pFormatW, LPWSTR pwzNumberStr, int cchNumber);LWSTDAPI_(int) MessageBoxWrapW(HWND hwnd, LPCWSTR pwzText, LPCWSTR pwzCaption, UINT uType);LWSTDAPI_(BOOL) FindNextFileWrapW(HANDLE hSearchHandle, LPWIN32_FIND_DATAW pFindFileDataW);
#ifdef UNICODE
#define IsCharAlphaWrap IsCharAlphaWrapW#define IsCharUpperWrap IsCharUpperWrapW#define IsCharLowerWrap IsCharLowerWrapW#define IsCharAlphaNumericWrap IsCharAlphaNumericWrapW#define AppendMenuWrap AppendMenuWrapW#ifdef POST_IE5_BETA#define CallMsgFilterWrap CallMsgFilterWrapW#endif#define CallWindowProcWrap CallWindowProcWrapW#define CharLowerWrap CharLowerWrapW#define CharLowerBuffWrap CharLowerBuffWrapW#define CharNextWrap CharNextWrapW#define CharPrevWrap CharPrevWrapW#define CharToOemWrap CharToOemWrapW#define CharUpperWrap CharUpperWrapW#define CharUpperBuffWrap CharUpperBuffWrapW#define CompareStringWrap CompareStringWrapW#define CopyAcceleratorTableWrap CopyAcceleratorTableWrapW#define CreateAcceleratorTableWrap CreateAcceleratorTableWrapW#define CreateDCWrap CreateDCWrapW#define CreateDirectoryWrap CreateDirectoryWrapW#define CreateEventWrap CreateEventWrapW#define CreateFontWrap CreateFontWrapW#define CreateFileWrap CreateFileWrapW#define CreateFontIndirectWrap CreateFontIndirectWrapW#define CreateICWrap CreateICWrapW#define CreateMetaFileWrap CreateMetaFileWrapW#define CreateMutexWrap CreateMutexWrapW#define CreateSemaphoreWrap CreateSemaphoreWrapW#define CreateWindowExWrap CreateWindowExWrapW#define DefWindowProcWrap DefWindowProcWrapW#define DeleteFileWrap DeleteFileWrapW#define DispatchMessageWrap DispatchMessageWrapW#define DrawTextExWrap DrawTextExWrapW#define DrawTextWrap DrawTextWrapW#define EnumFontFamiliesWrap EnumFontFamiliesWrapW#define EnumFontFamiliesExWrap EnumFontFamiliesExWrapW#define EnumResourceNamesWrap EnumResourceNamesWrapW#define ExpandEnvironmentStringsWrap ExpandEnvironmentStringsWrapW#define ExtractIconExWrap ExtractIconExWrapW#define ExtTextOutWrap ExtTextOutW#define FindFirstFileWrap FindFirstFileWrapW#define FindNextFileWrap FindNextFileWrapW#define FindResourceWrap FindResourceWrapW#define FindWindowWrap FindWindowWrapW#define FindWindowExWrap FindWindowExWrapW#define FormatMessageWrap FormatMessageWrapW#define GetClassInfoWrap GetClassInfoWrapW#define GetClassInfoExWrap GetClassInfoExWrapW#define GetClassLongWrap GetClassLongWrapW#define GetClassNameWrap GetClassNameWrapW#define GetClipboardFormatNameWrap GetClipboardFormatNameWrapW#define GetCurrentDirectoryWrap GetCurrentDirectoryWrapW#define GetDlgItemTextWrap GetDlgItemTextWrapW#define GetFileAttributesWrap GetFileAttributesWrapW#define GetFullPathNameWrap GetFullPathNameWrapW#define GetLocaleInfoWrap GetLocaleInfoWrapW#define GetMenuItemInfoWrap GetMenuItemInfoWrapW#define GetMenuStringWrap GetMenuStringWrapW#define GetMessageWrap GetMessageWrapW#define GetModuleFileNameWrap GetModuleFileNameWrapW#define GetNumberFormatWrap GetNumberFormatWrapW#define GetSystemDirectoryWrap GetSystemDirectoryWrapW#define GetEnvironmentVariableWrap GetEnvironmentVariableWrapW#define GetModuleHandleWrap GetModuleHandleWrapW#define GetObjectWrap GetObjectWrapW#define GetPrivateProfileIntWrap GetPrivateProfileIntWrapW#define GetProfileStringWrap GetProfileStringWrapW#define GetPrivateProfileStringWrap GetPrivateProfileStringWrapW#define WritePrivateProfileStringWrap WritePrivateProfileStringWrapW#define GetPropWrap GetPropWrapW#define GetStringTypeExWrap GetStringTypeExWrapW#define GetTempFileNameWrap GetTempFileNameWrapW#define GetTempPathWrap GetTempPathWrapW#define GetTextExtentPoint32Wrap GetTextExtentPoint32WrapW#define GetTextFaceWrap GetTextFaceWrapW#define GetTextMetricsWrap GetTextMetricsWrapW#define GetTimeFormatWrap GetTimeFormatWrapW#define GetDateFormatWrap GetDateFormatWrapW#define GetUserNameWrap GetUserNameWrapW#define GetWindowLongWrap GetWindowLongWrapW#define GetWindowTextWrap GetWindowTextWrapW#define GetWindowTextLengthWrap GetWindowTextLengthWrapW#define GetWindowsDirectoryWrap GetWindowsDirectoryWrapW#define InsertMenuItemWrap InsertMenuItemWrapW#define InsertMenuWrap InsertMenuWrapW#define IsBadStringPtrWrap IsBadStringPtrWrapW#define IsDialogMessageWrap IsDialogMessageWrapW#define LoadAcceleratorsWrap LoadAcceleratorsWrapW#define LoadBitmapWrap LoadBitmapWrapW#define LoadCursorWrap LoadCursorWrapW#define LoadIconWrap LoadIconWrapW#define LoadImageWrap LoadImageWrapW#define LoadLibraryWrap LoadLibraryWrapW#define LoadLibraryExWrap LoadLibraryExWrapW#define LoadMenuWrap LoadMenuWrapW#define LoadStringWrap LoadStringWrapW#define MessageBoxIndirectWrap MessageBoxIndirectWrapW#define MessageBoxWrap MessageBoxWrapW#define ModifyMenuWrap ModifyMenuWrapW#define GetCharWidth32Wrap GetCharWidth32WrapW#define GetCharacterPlacementWrap GetCharacterPlacementWrapW#define CopyFileWrap CopyFileWrapW#define MoveFileWrap MoveFileWrapW#define OemToCharWrap OemToCharWrapW#define OutputDebugStringWrap OutputDebugStringWrapW#define PeekMessageWrap PeekMessageWrapW#define PostMessageWrap PostMessageWrapW#define PostThreadMessageWrap PostThreadMessageWrapW#define RegCreateKeyWrap RegCreateKeyWrapW#define RegCreateKeyExWrap RegCreateKeyExWrapW#define RegDeleteKeyWrap RegDeleteKeyWrapW#define RegDeleteValueWrap RegDeleteValueWrapW#define RegEnumKeyWrap RegEnumKeyWrapW#define RegEnumKeyExWrap RegEnumKeyExWrapW#define RegOpenKeyWrap RegOpenKeyWrapW#define RegOpenKeyExWrap RegOpenKeyExWrapW#define RegQueryInfoKeyWrap RegQueryInfoKeyWrapW#define RegQueryValueWrap RegQueryValueWrapW#define RegQueryValueExWrap RegQueryValueExWrapW#define RegSetValueWrap RegSetValueWrapW#define RegSetValueExWrap RegSetValueExWrapW#define RegisterClassWrap RegisterClassWrapW#define RegisterClassExWrap RegisterClassExWrapW#define RegisterClipboardFormatWrap RegisterClipboardFormatWrapW#define RegisterWindowMessageWrap RegisterWindowMessageWrapW#define RemovePropWrap RemovePropWrapW#define SearchPathWrap SearchPathWrapW#define SendDlgItemMessageWrap SendDlgItemMessageWrapW#define SendMessageWrap SendMessageWrapW#define SendMessageTimeoutWrap SendMessageTimeoutWrapW#define SetCurrentDirectoryWrap SetCurrentDirectoryWrapW#define SetDlgItemTextWrap SetDlgItemTextWrapW#define SetMenuItemInfoWrap SetMenuItemInfoWrapW#define SetPropWrap SetPropWrapW#define SetFileAttributesWrap SetFileAttributesWrapW#define SetWindowLongWrap SetWindowLongWrapW#define SetWindowsHookExWrap SetWindowsHookExWrapW#define SHBrowseForFolderWrap SHBrowseForFolderWrapW#define ShellExecuteExWrap ShellExecuteExWrapW#define SHFileOperationWrap SHFileOperationWrapW#define SHGetFileInfoWrap SHGetFileInfoWrapW#define SHGetPathFromIDListWrap SHGetPathFromIDListWrapW#define StartDocWrap StartDocWrapW#define SystemParametersInfoWrap SystemParametersInfoWrapW#define TranslateAcceleratorWrap TranslateAcceleratorWrapW#define UnregisterClassWrap UnregisterClassWrapW#define VkKeyScanWrap VkKeyScanWrapW#define WinHelpWrap WinHelpWrapW#define WNetRestoreConnectionWrap WNetRestoreConnectionWrapW#define WNetGetLastErrorWrap WNetGetLastErrorWrapW#define wvsprintfWrap wvsprintfWrapW#define CreateFontWrap CreateFontWrapW#define DrawTextExWrap DrawTextExWrapW#define GetMenuItemInfoWrap GetMenuItemInfoWrapW#define SetMenuItemInfoWrap SetMenuItemInfoWrapW#define InsertMenuItemWrap InsertMenuItemWrapW#define DragQueryFileWrap DragQueryFileWrapW
#else
#define IsCharAlphaWrap IsCharAlphaA#define IsCharUpperWrap IsCharUpperA#define IsCharLowerWrap IsCharLowerA#define IsCharAlphaNumericWrap IsCharAlphaNumericA#define AppendMenuWrap AppendMenuA#ifdef POST_IE5_BETA#define CallMsgFilterWrap CallMsgFilterA#endif#define CallWindowProcWrap CallWindowProcA#define CharLowerWrap CharLowerA#define CharLowerBuffWrap CharLowerBuffA#define CharNextWrap CharNextA#define CharPrevWrap CharPrevA#define CharToOemWrap CharToOemA#define CharUpperWrap CharUpperA#define CharUpperBuffWrap CharUpperBuffA#define CompareStringWrap CompareStringA#define CopyAcceleratorTableWrap CopyAcceleratorTableA#define CreateAcceleratorTableWrap CreateAcceleratorTableA#define CreateDCWrap CreateDCA#define CreateDirectoryWrap CreateDirectoryA#define CreateEventWrap CreateEventA#define CreateFontWrap CreateFontA#define CreateFileWrap CreateFileA#define CreateFontIndirectWrap CreateFontIndirectA#define CreateICWrap CreateICA#define CreateMetaFileWrap CreateMetaFileA#define CreateMutexWrap CreateMutexA#define CreateSemaphoreWrap CreateSemaphoreA#define CreateWindowExWrap CreateWindowExA#define DefWindowProcWrap DefWindowProcA#define DeleteFileWrap DeleteFileA#define DispatchMessageWrap DispatchMessageA#define DrawTextExWrap DrawTextExA#define DrawTextWrap DrawTextA#define EnumFontFamiliesWrap EnumFontFamiliesA#define EnumFontFamiliesExWrap EnumFontFamiliesExA#define EnumResourceNamesWrap EnumResourceNamesA#define ExpandEnvironmentStringsWrap ExpandEnvironmentStringsA#define ExtractIconExWrap ExtractIconExA#define ExtTextOutWrap ExtTextOutA#define FindFirstFileWrap FindFirstFileA#define FindResourceWrap FindResourceA#define FindNextFileWrap FindNextFileA#define FindWindowWrap FindWindowA#define FindWindowExWrap FindWindowExA#define FormatMessageWrap FormatMessageA#define GetClassInfoWrap GetClassInfoA#define GetClassInfoExWrap GetClassInfoExA#define GetClassLongWrap GetClassLongA#define GetClassNameWrap GetClassNameA#define GetClipboardFormatNameWrap GetClipboardFormatNameA#define GetCurrentDirectoryWrap GetCurrentDirectoryA#define GetDlgItemTextWrap GetDlgItemTextA#define GetFileAttributesWrap GetFileAttributesA#define GetFullPathNameWrap GetFullPathNameA#define GetLocaleInfoWrap GetLocaleInfoA#define GetMenuItemInfoWrap GetMenuItemInfoA#define GetMenuStringWrap GetMenuStringA#define GetMessageWrap GetMessageA#define GetModuleFileNameWrap GetModuleFileNameA#define GetNumberFormatWrap GetNumberFormatA#define GetPrivateProfileStringWrap GetPrivateProfileStringA#define WritePrivateProfileStringWrap WritePrivateProfileStringA#define GetSystemDirectoryWrap GetSystemDirectoryA#define GetEnvironmentVariableWrap GetEnvironmentVariableA#define SearchPathWrap SearchPathA#define GetModuleHandleWrap GetModuleHandleA#define GetObjectWrap GetObjectA#define GetPrivateProfileIntWrap GetPrivateProfileIntA#define GetProfileStringWrap GetProfileStringA#define GetPropWrap GetPropA#define GetStringTypeExWrap GetStringTypeExA#define GetTempFileNameWrap GetTempFileNameA#define GetTempPathWrap GetTempPathA#define GetTextExtentPoint32Wrap GetTextExtentPoint32A#define GetTextFaceWrap GetTextFaceA#define GetTextMetricsWrap GetTextMetricsA#define GetTimeFormatWrap GetTimeFormatA#define GetDateFormatWrap GetDateFormatA#define GetUserNameWrap GetUserNameA#define GetWindowLongWrap GetWindowLongA#define GetWindowTextWrap GetWindowTextA#define GetWindowTextLengthWrap GetWindowTextLengthA#define GetWindowsDirectoryWrap GetWindowsDirectoryA#define InsertMenuItemWrap InsertMenuItemA#define InsertMenuWrap InsertMenuA#define IsBadStringPtrWrap IsBadStringPtrA#define IsDialogMessageWrap IsDialogMessageA#define LoadAcceleratorsWrap LoadAcceleratorsA#define LoadBitmapWrap LoadBitmapA#define LoadCursorWrap LoadCursorA#define LoadIconWrap LoadIconA#define LoadImageWrap LoadImageWrapA#define LoadLibraryWrap LoadLibraryA#define LoadLibraryExWrap LoadLibraryExA#define LoadMenuWrap LoadMenuA#define LoadStringWrap LoadStringA#define MessageBoxIndirectWrap MessageBoxIndirectA#define MessageBoxWrap MessageBoxA#define ModifyMenuWrap ModifyMenuA#define GetCharWidth32Wrap GetCharWidth32A#define GetCharacterPlacementWrap GetCharacterPlacementA#define CopyFileWrap CopyFileA#define MoveFileWrap MoveFileA#define OemToCharWrap OemToCharA#define OutputDebugStringWrap OutputDebugStringA#define PeekMessageWrap PeekMessageA#define PostMessageWrap PostMessageA#define PostThreadMessageWrap PostThreadMessageA#define RegCreateKeyWrap RegCreateKeyA#define RegCreateKeyExWrap RegCreateKeyExA#define RegDeleteKeyWrap RegDeleteKeyA#define RegDeleteValueWrap RegDeleteValueA#define RegEnumKeyWrap RegEnumKeyA#define RegEnumKeyExWrap RegEnumKeyExA#define RegOpenKeyWrap RegOpenKeyA#define RegOpenKeyExWrap RegOpenKeyExA#define RegQueryInfoKeyWrap RegQueryInfoKeyA#define RegQueryValueWrap RegQueryValueA#define RegQueryValueExWrap RegQueryValueExA#define RegSetValueWrap RegSetValueA#define RegSetValueExWrap RegSetValueExA#define RegisterClassWrap RegisterClassA#define RegisterClassExWrap RegisterClassExA#define RegisterClipboardFormatWrap RegisterClipboardFormatA#define RegisterWindowMessageWrap RegisterWindowMessageA#define RemovePropWrap RemovePropA#define SendDlgItemMessageWrap SendDlgItemMessageA#define SendMessageWrap SendMessageA#define SendMessageTimeoutWrap SendMessageTimeoutA#define SetCurrentDirectoryWrap SetCurrentDirectoryA#define SetDlgItemTextWrap SetDlgItemTextA#define SetMenuItemInfoWrap SetMenuItemInfoA#define SetPropWrap SetPropA#define SetWindowLongWrap SetWindowLongA#define SHBrowseForFolderWrap SHBrowseForFolderA#define ShellExecuteExWrap ShellExecuteExA#define SHFileOperationWrap SHFileOperationA#define SHGetFileInfoWrap SHGetFileInfoA#define SHGetPathFromIDListWrap SHGetPathFromIDListA#define SetFileAttributesWrap SetFileAttributesA#define SetWindowsHookExWrap SetWindowsHookExA#define StartDocWrap StartDocA#define SystemParametersInfoWrap SystemParametersInfoA#define TranslateAcceleratorWrap TranslateAcceleratorA#define UnregisterClassWrap UnregisterClassA#define VkKeyScanWrap VkKeyScanA#define WinHelpWrap WinHelpA#define WNetRestoreConnectionWrap WNetRestoreConnectionA#define WNetGetLastErrorWrap WNetGetLastErrorA#define wvsprintfWrap wvsprintfA#define CreateFontWrap CreateFontA#define DrawTextExWrap DrawTextExA#define GetMenuItemInfoWrap GetMenuItemInfoA#define SetMenuItemInfoWrap SetMenuItemInfoA#define InsertMenuItemWrap InsertMenuItemA#define DragQueryFileWrap DragQueryFileA#endif
#endif // (_WIN32_IE >= 0x0500) && !defined(NO_SHLWAPI_UNITHUNK)
#if defined(UNIX) && defined(NO_SHLWAPI_UNITHUNK)#define SHFlushSFCacheWrap()
#ifdef UNICODE#define IsCharAlphaWrapW IsCharAlphaW#define IsCharUpperWrapW IsCharUpperW#define IsCharLowerWrapW IsCharLowerW#define IsCharAlphaNumericWrapW IsCharAlphaNumericW#define AppendMenuWrapW AppendMenuW#ifdef POST_IE5_BETA#define CallMsgFilterWrapW CallMsgFilterW#endif#define CallWindowProcWrapW CallWindowProcW#define CharLowerWrapW CharLowerW#define CharLowerBuffWrapW CharLowerBuffW#define CharNextWrapW CharNextW#define CharPrevWrapW CharPrevW#define CharToOemWrapW CharToOemW#define CharUpperWrapW CharUpperW#define CharUpperBuffWrapW CharUpperBuffW#define CompareStringWrapW CompareStringW#define CopyAcceleratorTableWrapW CopyAcceleratorTableW#define CreateAcceleratorTableWrapW CreateAcceleratorTableW#define CreateDCWrapW CreateDCW#define CreateDirectoryWrapW CreateDirectoryW#define CreateEventWrapW CreateEventW#define CreateFontWrapW CreateFontW#define CreateFileWrapW CreateFileW#define CreateFontIndirectWrapW CreateFontIndirectW#define CreateICWrapW CreateICW#define CreateMetaFileWrapW CreateMetaFileW#define CreateMutexWrapW CreateMutexW#define CreateSemaphoreWrapW CreateSemaphoreW#define CreateWindowExWrapW CreateWindowExW#define DefWindowProcWrapW DefWindowProcW#define DeleteFileWrapW DeleteFileW#define DispatchMessageWrapW DispatchMessageW#define DrawTextExWrapW DrawTextExW#define DrawTextWrapW DrawTextW#define EnumFontFamiliesWrapW EnumFontFamiliesW#define EnumFontFamiliesExWrapW EnumFontFamiliesExW#define EnumResourceNamesWrapW EnumResourceNamesW#define ExpandEnvironmentStringsWrapW ExpandEnvironmentStringsW#define ExtractIconExWrapW ExtractIconExW#define ExtTextOutWrapW ExtTextOutW#define FindFirstFileWrapW FindFirstFileW#define FindNextFileWrapW FindNextFileW#define FindResourceWrapW FindResourceW#define FindWindowWrapW FindWindowW#define FindWindowExWrapW FindWindowExW#define FormatMessageWrapW FormatMessageW#define GetClassInfoWrapW GetClassInfoW#define GetClassInfoExWrapW GetClassInfoExW#define GetClassLongWrapW GetClassLongW#define GetClassNameWrapW GetClassNameW#define GetClipboardFormatNameWrapW GetClipboardFormatNameW#define GetCurrentDirectoryWrapW GetCurrentDirectoryW#define GetDlgItemTextWrapW GetDlgItemTextW#define GetFileAttributesWrapW GetFileAttributesW#define GetFullPathNameWrapW GetFullPathNameW#define GetLocaleInfoWrapW GetLocaleInfoW#define GetMenuStringWrapW GetMenuStringW#define GetMessageWrapW GetMessageW#define GetModuleFileNameWrapW GetModuleFileNameW#define GetNumberFormatWrapW GetNumberFormatW#define GetSystemDirectoryWrapW GetSystemDirectoryW#define GetModuleHandleWrapW GetModuleHandleW#define GetObjectWrapW GetObjectW#define GetPrivateProfileIntWrapW GetPrivateProfileIntW#define GetProfileStringWrapW GetProfileStringW#define GetPrivateProfileStringWrapW GetPrivateProfileStringW#define WritePrivateProfileStringWrapW WritePrivateProfileStringW#define GetPropWrapW GetPropW#define GetStringTypeExWrapW GetStringTypeExW#define GetTempFileNameWrapW GetTempFileNameW#define GetTempPathWrapW GetTempPathW#define GetTextExtentPoint32WrapW GetTextExtentPoint32W#define GetTextFaceWrapW GetTextFaceW#define GetTextMetricsWrapW GetTextMetricsW#define GetTimeFormatWrapW GetTimeFormatW#define GetDateFormatWrapW GetDateFormatW#define GetUserNameWrapW GetUserNameW#define GetWindowLongWrapW GetWindowLongW#define GetWindowTextWrapW GetWindowTextW#define GetWindowTextLengthWrapW GetWindowTextLengthW#define GetWindowsDirectoryWrapW GetWindowsDirectoryW#define InsertMenuItemWrapW InsertMenuItemW#define InsertMenuWrapW InsertMenuW#define IsBadStringPtrWrapW IsBadStringPtrW#define IsDialogMessageWrapW IsDialogMessageW#define LoadAcceleratorsWrapW LoadAcceleratorsW#define LoadBitmapWrapW LoadBitmapW#define LoadCursorWrapW LoadCursorW#define LoadIconWrapW LoadIconW#define LoadImageWrapW LoadImageW#define LoadLibraryWrapW LoadLibraryW#define LoadLibraryExWrapW LoadLibraryExW#define LoadMenuWrapW LoadMenuW#define LoadStringWrapW LoadStringW#define MessageBoxIndirectWrapW MessageBoxIndirectW#define MessageBoxWrapW MessageBoxW#define ModifyMenuWrapW ModifyMenuW#define GetCharWidth32WrapW GetCharWidth32W#define GetCharacterPlacementWrapW GetCharacterPlacementW#define CopyFileWrapW CopyFileW#define MoveFileWrapW MoveFileW#define OemToCharWrapW OemToCharW#define OutputDebugStringWrapW OutputDebugStringW#define PeekMessageWrapW PeekMessageW#define PostMessageWrapW PostMessageW#define PostThreadMessageWrapW PostThreadMessageW#define RegCreateKeyWrapW RegCreateKeyW#define RegCreateKeyExWrapW RegCreateKeyExW#define RegDeleteKeyWrapW RegDeleteKeyW#define RegDeleteValueWrapW RegDeleteValueW#define RegEnumKeyWrapW RegEnumKeyW#define RegEnumKeyExWrapW RegEnumKeyExW#define RegOpenKeyWrapW RegOpenKeyW#define RegOpenKeyExWrapW RegOpenKeyExW#define RegQueryInfoKeyWrapW RegQueryInfoKeyW#define RegQueryValueWrapW RegQueryValueW#define RegQueryValueExWrapW RegQueryValueExW#define RegSetValueWrapW RegSetValueW#define RegSetValueExWrapW RegSetValueExW#define RegisterClassWrapW RegisterClassW#define RegisterClassExWrapW RegisterClassExW#define RegisterClipboardFormatWrapWRegisterClipboardFormatW#define RegisterWindowMessageWrapW RegisterWindowMessageW#define RemovePropWrapW RemovePropW#define SearchPathWrapW SearchPathW#define SendDlgItemMessageWrapW SendDlgItemMessageW#define SendMessageWrapW SendMessageW#define SetCurrentDirectoryWrapW SetCurrentDirectoryW#define SetDlgItemTextWrapW SetDlgItemTextW#define SetMenuItemInfoWrapW SetMenuItemInfoW#define SetPropWrapW SetPropW#define SetFileAttributesWrapW SetFileAttributesW#define SetWindowLongWrapW SetWindowLongW#define SetWindowsHookExWrapW SetWindowsHookExW#define SHBrowseForFolderWrapW SHBrowseForFolderW#define ShellExecuteExWrapW ShellExecuteExW#define SHFileOperationWrapW SHFileOperationW#define SHGetFileInfoWrapW SHGetFileInfoW#define SHGetPathFromIDListWrapW SHGetPathFromIDListW#define StartDocWrapW StartDocW#define SystemParametersInfoWrapW SystemParametersInfoW#define TranslateAcceleratorWrapW TranslateAcceleratorW#define UnregisterClassWrapW UnregisterClassW#define VkKeyScanWrapW VkKeyScanW#define WinHelpWrapW WinHelpW#define WNetRestoreConnectionWrapW WNetRestoreConnectionW#define WNetGetLastErrorWrapW WNetGetLastErrorW#define wvsprintfWrapW wvsprintfW#define CreateFontWrapW CreateFontW#define DrawTextExWrapW DrawTextExW#define SetMenuItemInfoWrapW SetMenuItemInfoW#define InsertMenuItemWrapW InsertMenuItemW#define DragQueryFileWrapW DragQueryFileW
#define IsCharAlphaWrap IsCharAlphaW#define IsCharUpperWrap IsCharUpperW#define IsCharLowerWrap IsCharLowerW#define IsCharAlphaNumericWrap IsCharAlphaNumericW#define AppendMenuWrap AppendMenuW#ifdef POST_IE5_BETA#define CallMsgFilterWrap CallMsgFilterW#endif#define CallWindowProcWrap CallWindowProcW#define CharLowerWrap CharLowerW#define CharLowerBuffWrap CharLowerBuffW#define CharNextWrap CharNextW#define CharPrevWrap CharPrevW#define CharToOemWrap CharToOemW#define CharUpperWrap CharUpperW#define CharUpperBuffWrap CharUpperBuffW#define CompareStringWrap CompareStringW#define CopyAcceleratorTableWrap CopyAcceleratorTableW#define CreateAcceleratorTableWrap CreateAcceleratorTableW#define CreateDCWrap CreateDCW#define CreateDirectoryWrap CreateDirectoryW#define CreateEventWrap CreateEventW#define CreateFontWrap CreateFontW#define CreateFileWrap CreateFileW#define CreateFontIndirectWrap CreateFontIndirectW#define CreateICWrap CreateICW#define CreateMetaFileWrap CreateMetaFileW#define CreateMutexWrap CreateMutexW#define CreateSemaphoreWrap CreateSemaphoreW#define CreateWindowExWrap CreateWindowExW#define DefWindowProcWrap DefWindowProcW#define DeleteFileWrap DeleteFileW#define DispatchMessageWrap DispatchMessageW#define DrawTextExWrap DrawTextExW#define DrawTextWrap DrawTextW#define EnumFontFamiliesWrap EnumFontFamiliesW#define EnumFontFamiliesExWrap EnumFontFamiliesExW#define EnumResourceNamesWrap EnumResourceNamesW#define ExpandEnvironmentStringsWrap ExpandEnvironmentStringsW#define ExtractIconExWrap ExtractIconExW#define ExtTextOutWrap ExtTextOutW#define FindFirstFileWrap FindFirstFileW#define FindNextFileWrap FindNextFileW#define FindResourceWrap FindResourceW#define FindWindowWrap FindWindowW#define FindWindowExWrap FindWindowExW#define FormatMessageWrap FormatMessageW#define GetClassInfoWrap GetClassInfoW#define GetClassInfoExWrap GetClassInfoExW#define GetClassLongWrap GetClassLongW#define GetClassNameWrap GetClassNameW#define GetClipboardFormatNameWrap GetClipboardFormatNameW#define GetCurrentDirectoryWrap GetCurrentDirectoryW#define GetDlgItemTextWrap GetDlgItemTextW#define GetFileAttributesWrap GetFileAttributesW#define GetFullPathNameWrap GetFullPathNameW#define GetLocaleInfoWrap GetLocaleInfoW#define GetMenuItemInfoWrap GetMenuItemInfoWrapW#define GetMenuStringWrap GetMenuStringW#define GetMessageWrap GetMessageW#define GetModuleFileNameWrap GetModuleFileNameW#define GetNumberFormatWrap GetNumberFormatW#define GetSystemDirectoryWrap GetSystemDirectoryW#define GetModuleHandleWrap GetModuleHandleW#define GetObjectWrap GetObjectW#define GetPrivateProfileIntWrap GetPrivateProfileIntW#define GetProfileStringWrap GetProfileStringW#define GetPrivateProfileStringWrap GetPrivateProfileStringW#define WritePrivateProfileStringWrap WritePrivateProfileStringW#define GetPropWrap GetPropW#define GetStringTypeExWrap GetStringTypeExW#define GetTempFileNameWrap GetTempFileNameW#define GetTempPathWrap GetTempPathW#define GetTextExtentPoint32Wrap GetTextExtentPoint32W#define GetTextFaceWrap GetTextFaceW#define GetTextMetricsWrap GetTextMetricsW#define GetTimeFormatWrap GetTimeFormatW#define GetDateFormatWrap GetDateFormatW#define GetUserNameWrap GetUserNameW#define GetWindowLongWrap GetWindowLongW#define GetWindowTextWrap GetWindowTextW#define GetWindowTextLengthWrap GetWindowTextLengthW#define GetWindowsDirectoryWrap GetWindowsDirectoryW#define InsertMenuItemWrap InsertMenuItemW#define InsertMenuWrap InsertMenuW#define IsBadStringPtrWrap IsBadStringPtrW#define IsDialogMessageWrap IsDialogMessageW#define LoadAcceleratorsWrap LoadAcceleratorsW#define LoadBitmapWrap LoadBitmapW#define LoadCursorWrap LoadCursorW#define LoadIconWrap LoadIconW#define LoadImageWrap LoadImageW#define LoadLibraryWrap LoadLibraryW#define LoadLibraryExWrap LoadLibraryExW#define LoadMenuWrap LoadMenuW#define LoadStringWrap LoadStringW#define MessageBoxIndirectWrap MessageBoxIndirectW#define MessageBoxWrap MessageBoxW#define ModifyMenuWrap ModifyMenuW#define GetCharWidth32Wrap GetCharWidth32W#define GetCharacterPlacementWrap GetCharacterPlacementW#define CopyFileWrap CopyFileW#define MoveFileWrap MoveFileW#define OemToCharWrap OemToCharW#define OutputDebugStringWrap OutputDebugStringW#define PeekMessageWrap PeekMessageW#define PostMessageWrap PostMessageW#define PostThreadMessageWrap PostThreadMessageW#define RegCreateKeyWrap RegCreateKeyW#define RegCreateKeyExWrap RegCreateKeyExW#define RegDeleteKeyWrap RegDeleteKeyW#define RegDeleteValueWrap RegDeleteValueW#define RegEnumKeyWrap RegEnumKeyW#define RegEnumKeyExWrap RegEnumKeyExW#define RegOpenKeyWrap RegOpenKeyW#define RegOpenKeyExWrap RegOpenKeyExW#define RegQueryInfoKeyWrap RegQueryInfoKeyW#define RegQueryValueWrap RegQueryValueW#define RegQueryValueExWrap RegQueryValueExW#define RegSetValueWrap RegSetValueW#define RegSetValueExWrap RegSetValueExW#define RegisterClassWrap RegisterClassW#define RegisterClassExWrap RegisterClassExW#define RegisterClipboardFormatWrap RegisterClipboardFormatW#define RegisterWindowMessageWrap RegisterWindowMessageW#define RemovePropWrap RemovePropW#define SearchPathWrap SearchPathW#define SendDlgItemMessageWrap SendDlgItemMessageW#define SendMessageWrap SendMessageW#define SetCurrentDirectoryWrap SetCurrentDirectoryW#define SetDlgItemTextWrap SetDlgItemTextW#define SetMenuItemInfoWrap SetMenuItemInfoW#define SetPropWrap SetPropW#define SetFileAttributesWrap SetFileAttributesW#define SetWindowLongWrap SetWindowLongW#define SetWindowsHookExWrap SetWindowsHookExW#define SHBrowseForFolderWrap SHBrowseForFolderW#define ShellExecuteExWrap ShellExecuteExW#define SHFileOperationWrap SHFileOperationW#define SHGetFileInfoWrap SHGetFileInfoW#define SHGetPathFromIDListWrap SHGetPathFromIDListW#define StartDocWrap StartDocW#define SystemParametersInfoWrap SystemParametersInfoW#define TranslateAcceleratorWrap TranslateAcceleratorW#define UnregisterClassWrap UnregisterClassW#define VkKeyScanWrap VkKeyScanW#define WinHelpWrap WinHelpW#define WNetRestoreConnectionWrap WNetRestoreConnectionW#define WNetGetLastErrorWrap WNetGetLastErrorW#define wvsprintfWrap wvsprintfW#define CreateFontWrap CreateFontW#define DrawTextExWrap DrawTextExW#define GetMenuItemInfoWrap GetMenuItemInfoWrapW#define SetMenuItemInfoWrap SetMenuItemInfoW#define InsertMenuItemWrap InsertMenuItemW#define DragQueryFileWrap DragQueryFileW
#else
#define IsCharAlphaWrap IsCharAlphaA#define IsCharUpperWrap IsCharUpperA#define IsCharLowerWrap IsCharLowerA#define IsCharAlphaNumericWrap IsCharAlphaNumericA#define AppendMenuWrap AppendMenuA#ifdef POST_IE5_BETA#define CallMsgFilterWrap CallMsgFilterA#endif#define CallWindowProcWrap CallWindowProcA#define CharLowerWrap CharLowerA#define CharLowerBuffWrap CharLowerBuffA#define CharNextWrap CharNextA#define CharPrevWrap CharPrevA#define CharToOemWrap CharToOemA#define CharUpperWrap CharUpperA#define CharUpperBuffWrap CharUpperBuffA#define CompareStringWrap CompareStringA#define CopyAcceleratorTableWrap CopyAcceleratorTableA#define CreateAcceleratorTableWrap CreateAcceleratorTableA#define CreateDCWrap CreateDCA#define CreateDirectoryWrap CreateDirectoryA#define CreateEventWrap CreateEventA#define CreateFontWrap CreateFontA#define CreateFileWrap CreateFileA#define CreateFontIndirectWrap CreateFontIndirectA#define CreateICWrap CreateICA#define CreateMetaFileWrap CreateMetaFileA#define CreateMutexWrap CreateMutexA#define CreateSemaphoreWrap CreateSemaphoreA#define CreateWindowExWrap CreateWindowExA#define DefWindowProcWrap DefWindowProcA#define DeleteFileWrap DeleteFileA#define DispatchMessageWrap DispatchMessageA#define DrawTextExWrap DrawTextExA#define DrawTextWrap DrawTextA#define EnumFontFamiliesWrap EnumFontFamiliesA#define EnumFontFamiliesExWrap EnumFontFamiliesExA#define EnumResourceNamesWrap EnumResourceNamesA#define ExpandEnvironmentStringsWrap ExpandEnvironmentStringsA#define ExtractIconExWrap ExtractIconExA#define ExtTextOutWrap ExtTextOutA#define FindFirstFileWrap FindFirstFileA#define FindResourceWrap FindResourceA#define FindNextFileWrap FindNextFileA#define FindWindowWrap FindWindowA#define FindWindowExWrap FindWindowExA#define FormatMessageWrap FormatMessageA#define GetClassInfoWrap GetClassInfoA#define GetClassInfoExWrap GetClassInfoExA#define GetClassLongWrap GetClassLongA#define GetClassNameWrap GetClassNameA#define GetClipboardFormatNameWrap GetClipboardFormatNameA#define GetCurrentDirectoryWrap GetCurrentDirectoryA#define GetDlgItemTextWrap GetDlgItemTextA#define GetFileAttributesWrap GetFileAttributesA#define GetFullPathNameWrap GetFullPathNameA#define GetLocaleInfoWrap GetLocaleInfoA#define GetMenuItemInfoWrap GetMenuItemInfoA#define GetMenuStringWrap GetMenuStringA#define GetMessageWrap GetMessageA#define GetModuleFileNameWrap GetModuleFileNameA#define GetNumberFormatWrap GetNumberFormatA#define GetPrivateProfileStringWrap GetPrivateProfileStringA#define WritePrivateProfileStringWrap WritePrivateProfileStringA#define GetSystemDirectoryWrap GetSystemDirectoryA#define SearchPathWrap SearchPathA#define GetModuleHandleWrap GetModuleHandleA#define GetObjectWrap GetObjectA#define GetPrivateProfileIntWrap GetPrivateProfileIntA#define GetProfileStringWrap GetProfileStringA#define GetPropWrap GetPropA#define GetStringTypeExWrap GetStringTypeExA#define GetTempFileNameWrap GetTempFileNameA#define GetTempPathWrap GetTempPathA#define GetTextExtentPoint32Wrap GetTextExtentPoint32A#define GetTextFaceWrap GetTextFaceA#define GetTextMetricsWrap GetTextMetricsA#define GetTimeFormatWrap GetTimeFormatA#define GetDateFormatWrap GetDateFormatA#define GetUserNameWrap GetUserNameA#define GetWindowLongWrap GetWindowLongA#define GetWindowTextWrap GetWindowTextA#define GetWindowTextLengthWrap GetWindowTextLengthA#define GetWindowsDirectoryWrap GetWindowsDirectoryA#define InsertMenuItemWrap InsertMenuItemA#define InsertMenuWrap InsertMenuA#define IsBadStringPtrWrap IsBadStringPtrA#define IsDialogMessageWrap IsDialogMessageA#define LoadAcceleratorsWrap LoadAcceleratorsA#define LoadBitmapWrap LoadBitmapA#define LoadCursorWrap LoadCursorA#define LoadIconWrap LoadIconA#define LoadImageWrap LoadImageWrapA#define LoadLibraryWrap LoadLibraryA#define LoadLibraryExWrap LoadLibraryExA#define LoadMenuWrap LoadMenuA#define LoadStringWrap LoadStringA#define MessageBoxIndirectWrap MessageBoxIndirectA#define MessageBoxWrap MessageBoxA#define ModifyMenuWrap ModifyMenuA#define GetCharWidth32Wrap GetCharWidth32A#define GetCharacterPlacementWrap GetCharacterPlacementA#define CopyFileWrap CopyFileA#define MoveFileWrap MoveFileA#define OemToCharWrap OemToCharA#define OutputDebugStringWrap OutputDebugStringA#define PeekMessageWrap PeekMessageA#define PostMessageWrap PostMessageA#define PostThreadMessageWrap PostThreadMessageA#define RegCreateKeyWrap RegCreateKeyA#define RegCreateKeyExWrap RegCreateKeyExA#define RegDeleteKeyWrap RegDeleteKeyA#define RegDeleteValueWrap RegDeleteValueA#define RegEnumKeyWrap RegEnumKeyA#define RegEnumKeyExWrap RegEnumKeyExA#define RegOpenKeyWrap RegOpenKeyA#define RegOpenKeyExWrap RegOpenKeyExA#define RegQueryInfoKeyWrap RegQueryInfoKeyA#define RegQueryValueWrap RegQueryValueA#define RegQueryValueExWrap RegQueryValueExA#define RegSetValueWrap RegSetValueA#define RegSetValueExWrap RegSetValueExA#define RegisterClassWrap RegisterClassA#define RegisterClassExWrap RegisterClassExA#define RegisterClipboardFormatWrap RegisterClipboardFormatA#define RegisterWindowMessageWrap RegisterWindowMessageA#define RemovePropWrap RemovePropA#define SendDlgItemMessageWrap SendDlgItemMessageA#define SendMessageWrap SendMessageA#define SetCurrentDirectoryWrap SetCurrentDirectoryA#define SetDlgItemTextWrap SetDlgItemTextA#define SetMenuItemInfoWrap SetMenuItemInfoA#define SetPropWrap SetPropA#define SetWindowLongWrap SetWindowLongA#define SHBrowseForFolderWrap SHBrowseForFolderA#define ShellExecuteExWrap ShellExecuteExA#define SHFileOperationWrap SHFileOperationA#define SHGetFileInfoWrap SHGetFileInfoA#define SHGetPathFromIDListWrap SHGetPathFromIDListA#define SetFileAttributesWrap SetFileAttributesA#define SetWindowsHookExWrap SetWindowsHookExA#define StartDocWrap StartDocA#define SystemParametersInfoWrap SystemParametersInfoA#define TranslateAcceleratorWrap TranslateAcceleratorA#define UnregisterClassWrap UnregisterClassA#define VkKeyScanWrap VkKeyScanA#define WinHelpWrap WinHelpA#define WNetRestoreConnectionWrap WNetRestoreConnectionA#define WNetGetLastErrorWrap WNetGetLastErrorA#define wvsprintfWrap wvsprintfA#define CreateFontWrap CreateFontA#define DrawTextExWrap DrawTextExA#define GetMenuItemInfoWrap GetMenuItemInfoA#define SetMenuItemInfoWrap SetMenuItemInfoA#define InsertMenuItemWrap InsertMenuItemA#define DragQueryFileWrap DragQueryFileA#endif#endif // defined(UNIX) && defined(NO_SHLWAPI_UNITHUNK)
// Some functions are used to wrap unicode win95 functions AND to provide ML wrappers,// so they are needed unless BOTH NO_SHLWAPI_UNITHUNG and NO_SHLWAPI_MLUI are defined//#if (_WIN32_IE >= 0x0500) && (!defined(NO_SHLWAPI_UNITHUNK) || !defined(NO_SHLWAPI_MLUI))
LWSTDAPI_(HWND)CreateDialogIndirectParamWrapW( HINSTANCE hInstance, LPCDLGTEMPLATEW hDialogTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
LWSTDAPI_(HWND)CreateDialogParamWrapW( HINSTANCE hInstance, LPCWSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
LWSTDAPI_(INT_PTR)DialogBoxIndirectParamWrapW( HINSTANCE hInstance, LPCDLGTEMPLATEW hDialogTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
LWSTDAPI_(INT_PTR)DialogBoxParamWrapW( HINSTANCE hInstance, LPCWSTR lpszTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
LWSTDAPI_(BOOL) SetWindowTextWrapW(HWND hWnd, LPCWSTR lpString);
LWSTDAPI_(BOOL) DeleteMenuWrap(HMENU hMenu, UINT uPosition, UINT uFlags);
LWSTDAPI_(BOOL) DestroyMenuWrap(HMENU hMenu);
#ifdef UNICODE
#define CreateDialogIndirectParamWrap CreateDialogIndirectParamWrapW#define CreateDialogParamWrap CreateDialogParamWrapW#define DialogBoxIndirectParamWrap DialogBoxIndirectParamWrapW#define DialogBoxParamWrap DialogBoxParamWrapW#define SetWindowTextWrap SetWindowTextWrapW
#else
#define CreateDialogIndirectParamWrap CreateDialogIndirectParamA#define CreateDialogParamWrap CreateDialogParamA#define DialogBoxIndirectParamWrap DialogBoxIndirectParamA#define DialogBoxParamWrap DialogBoxParamA#define SetWindowTextWrap SetWindowTextA
#endif // UNICODE
#endif // (_WIN32_IE >= 0x0500) && !defined(NO_SHLWAPI_UNITHUNK) && !defined (NO_SHLWAPI_MLUI)
//=============== Thread Pool Services ===================================
#if (_WIN32_IE >= 0x0500) && !defined(NO_SHLWAPI_TPS)
//// SHLWAPIP versions of KERNEL32 Thread Pool Services APIs//
typedef void (NTAPI * WAITORTIMERCALLBACKFUNC)(void *, BOOLEAN);typedef void (NTAPI * WORKERCALLBACKFUNC)(void *); // BUGBUG - why declare this?typedef WAITORTIMERCALLBACKFUNC WAITORTIMERCALLBACK;
LWSTDAPI_(HANDLE)SHRegisterWaitForSingleObject( IN HANDLE hObject, IN WAITORTIMERCALLBACKFUNC pfnCallback, IN LPVOID pContext, IN DWORD dwMilliseconds, IN LPCSTR lpszLibrary OPTIONAL, IN DWORD dwFlags );
//// flags for SHRegisterWaitForSingleObject (keep separate from other TPS flags)//
//// SRWSO_NOREMOVE - if set, the handle is not to be removed from the list once// signalled. Intended for use with auto-reset events that the caller wants to// keep until unregistered//
#define SRWSO_NOREMOVE 0x00000100
#define SRWSO_VALID_FLAGS (SRWSO_NOREMOVE)
#define SRWSO_INVALID_FLAGS (~SRWSO_VALID_FLAGS)
LWSTDAPI_(BOOL)SHUnregisterWait( IN HANDLE hWait );
typedef struct { DWORD dwStructSize; DWORD dwMinimumWorkerThreads; DWORD dwMaximumWorkerThreads; DWORD dwMaximumWorkerQueueDepth; DWORD dwWorkerThreadIdleTimeout; DWORD dwWorkerThreadCreationDelta; DWORD dwMinimumIoWorkerThreads; DWORD dwMaximumIoWorkerThreads; DWORD dwMaximumIoWorkerQueueDepth; DWORD dwIoWorkerThreadCreationDelta;} SH_THREAD_POOL_LIMITS, *PSH_THREAD_POOL_LIMITS;
LWSTDAPI_(BOOL)SHSetThreadPoolLimits( IN PSH_THREAD_POOL_LIMITS pLimits );
LWSTDAPI_(BOOL)SHTerminateThreadPool( VOID );
LWSTDAPI_(BOOL)SHQueueUserWorkItem( IN LPTHREAD_START_ROUTINE pfnCallback, IN LPVOID pContext, IN LONG lPriority, IN DWORD_PTR dwTag, OUT DWORD_PTR * pdwId OPTIONAL, IN LPCSTR pszModule OPTIONAL, IN DWORD dwFlags );
LWSTDAPI_(DWORD)SHCancelUserWorkItems( IN DWORD_PTR dwTagOrId, IN BOOL bTag );
LWSTDAPI_(HANDLE)SHCreateTimerQueue( VOID );
LWSTDAPI_(BOOL)SHDeleteTimerQueue( IN HANDLE hQueue );
LWSTDAPI_(HANDLE)SHSetTimerQueueTimer( IN HANDLE hQueue, IN WAITORTIMERCALLBACK pfnCallback, IN LPVOID pContext, IN DWORD dwDueTime, IN DWORD dwPeriod, IN LPCSTR lpszLibrary OPTIONAL, IN DWORD dwFlags );
LWSTDAPI_(BOOL)SHChangeTimerQueueTimer( IN HANDLE hQueue, IN HANDLE hTimer, IN DWORD dwDueTime, IN DWORD dwPeriod );
LWSTDAPI_(BOOL)SHCancelTimerQueueTimer( IN HANDLE hQueue, IN HANDLE hTimer );
//// Thread Pool Services flags//
//// TPS_EXECUTEIO - execute in I/O thread (via APC). Default is non-IO thread//
#define TPS_EXECUTEIO 0x00000001
//// TPS_TAGGEDITEM - the dwTag parameter is meaningful//
#define TPS_TAGGEDITEM 0x00000002
//// TPS_DEMANDTHREAD - always create a new thread if none currently available.// Used in situations where immediate response required//
#define TPS_DEMANDTHREAD 0x00000004
//// TPS_LONGEXECTIME - the work item will take relatively long time to execute.// Used as management hint to TPS//
#define TPS_LONGEXECTIME 0x00000008
//// TPS_RESERVED_FLAGS - mask of bits reserved for internal use//
#define TPS_RESERVED_FLAGS 0xFF000000
#define TPS_VALID_FLAGS (TPS_EXECUTEIO \ | TPS_TAGGEDITEM \ | TPS_DEMANDTHREAD \ | TPS_LONGEXECTIME \ )#define TPS_INVALID_FLAGS (~TPS_VALID_FLAGS)
#endif // (_WIN32_IE >= 0x0500) && !defined(NO_SHLWAPI_TPS)
//// Private MIME helper functions used by shdocvw & shell32//#if (_WIN32_IE >= 0x0500)
LWSTDAPI_(BOOL) GetMIMETypeSubKeyA(LPCSTR pszMIMEType, LPSTR pszBuf, UINT cchBuf);LWSTDAPI_(BOOL) GetMIMETypeSubKeyW(LPCWSTR pszMIMEType, LPWSTR pszBuf, UINT cchBuf);
LWSTDAPI_(BOOL) RegisterMIMETypeForExtensionA(LPCSTR pcszExtension, LPCSTR pcszMIMEContentType);LWSTDAPI_(BOOL) RegisterMIMETypeForExtensionW(LPCWSTR pcszExtension, LPCWSTR pcszMIMEContentType);
LWSTDAPI_(BOOL) UnregisterMIMETypeForExtensionA(LPCSTR pcszExtension);LWSTDAPI_(BOOL) UnregisterMIMETypeForExtensionW(LPCWSTR pcszExtension);
LWSTDAPI_(BOOL) RegisterExtensionForMIMETypeA(LPCSTR pcszExtension, LPCSTR pcszMIMEContentType);LWSTDAPI_(BOOL) RegisterExtensionForMIMETypeW(LPCWSTR pcszExtension, LPCWSTR pcszMIMEContentType);
LWSTDAPI_(BOOL) UnregisterExtensionForMIMETypeA(LPCSTR pcszMIMEContentType);LWSTDAPI_(BOOL) UnregisterExtensionForMIMETypeW(LPCWSTR pcszMIMEContentType);
LWSTDAPI_(BOOL) MIME_GetExtensionA(LPCSTR pcszMIMEType, LPSTR pszExtensionBuf, UINT ucExtensionBufLen);LWSTDAPI_(BOOL) MIME_GetExtensionW(LPCWSTR pcszMIMEType, LPWSTR pszExtensionBuf, UINT ucExtensionBufLen);
#ifdef UNICODE#define GetMIMETypeSubKey GetMIMETypeSubKeyW#define RegisterMIMETypeForExtension RegisterMIMETypeForExtensionW#define UnregisterMIMETypeForExtension UnregisterMIMETypeForExtensionW#define RegisterExtensionForMIMEType RegisterExtensionForMIMETypeW#define UnregisterExtensionForMIMEType UnregisterExtensionForMIMETypeW#define MIME_GetExtension MIME_GetExtensionW#else#define GetMIMETypeSubKey GetMIMETypeSubKeyA#define RegisterMIMETypeForExtension RegisterMIMETypeForExtensionA#define UnregisterMIMETypeForExtension UnregisterMIMETypeForExtensionA#define RegisterExtensionForMIMEType RegisterExtensionForMIMETypeA#define UnregisterExtensionForMIMEType UnregisterExtensionForMIMETypeA#define MIME_GetExtension MIME_GetExtensionA#endif
// Options for SHGetMachineInfo
//// Note that GMI_DOCKSTATE is unreliable for ACPI laptops.//#define GMI_DOCKSTATE 0x0000 // Return values for SHGetMachineInfo(GMI_DOCKSTATE) #define GMID_NOTDOCKABLE 0 // Cannot be docked #define GMID_UNDOCKED 1 // Is undocked #define GMID_DOCKED 2 // Is docked
//// GMI_BATTERYSTATE reports on the presence and status of non-UPS// batteries.//#define GMI_BATTERYSTATE 0x0001 // Return value for SHGetMachineInfo(GMI_BATTERYSTATE) is a bitmask #define GMIB_HASBATTERY 0x0001 // Can run on batteries #define GMIB_ONBATTERY 0x0002 // Is now on batteries
//// WARNING! DANGER! EVIL!//// GMI_LAPTOP is not perfect. It can be fooled by particular hardware// configurations. You are much better off asking specifically why you// care about laptops and use one of the above GMI values instead. For// example, if you want to scale back some intensive operation so you// don't drain the battery, use GMI_BATTERYSTATE instead.//#define GMI_LAPTOP 0x0002 // Returns nonzero if might be a laptop
#if (_WIN32_IE >= 0x0501)
//// GMI_TSCLIENT tells you whether you are running as a Terminal Server// client and should disable your animations.//#define GMI_TSCLIENT 0x0003 // Returns nonzero if TS client
#endif // (_WIN32_IE >= 0x0501)
LWSTDAPI_(DWORD_PTR) SHGetMachineInfo(UINT gmi);
// support InterlockedCompareExchange() on Win95
LWSTDAPI_(void *) SHInterlockedCompareExchange(void **ppDest, void *pExch, void *pComp);
#if !defined(_X86_)// Win95 doesn't run on Alpha/UNIX so we can use the OS function directly// Use a #define instead of a forwarder because it's an intrinsic on most// compilers.#define SHInterlockedCompareExchange InterlockedCompareExchangePointer#endif
LWSTDAPI_(BOOL) SHMirrorIcon(HICON* phiconSmall, HICON* phiconLarge);
#endif // (_WIN32_IE >= 0x0500)
// Raw Accelerator Table API//// Allows an accelerator table grep without having to invoke ::TranslateAccelerator.// Useful for dealing with parent-child window accelerator conflicts.//
// HANDLE SHLoadRawAccelerators( HINSTANCE hInst, LPCTSTR lpTableName );// Loads the raw accelerator table.// hInst Module instance containing the accelerator resource.// lpTableName Names the accelerator table resource to load.
// The return value is a handle that can be passed to a SHQueryRawAcceleratorXXX function.// When the handle is no longer required, it should be freed with LocalFree().LWSTDAPI_(HANDLE) SHLoadRawAccelerators ( HINSTANCE hInst, LPCTSTR lpTableName );
// BOOL SHQueryRawAccelerator ( HANDLE hcaAcc, IN BYTE fVirtMask, IN BYTE fVirt, IN WPARAM wKey, OUT OPTIONAL UINT* puCmdID );// Queries the raw accelererator table for the specified key// hcaAcc Handle returned from SHLoadRawAccelerators().// fVirtMask Relevant accelerator flags (any combo of FALT|FCONTROL|FNOINVERT|FSHIFT|FVIRTKEY)// fVirt Accelerator flags to test (any combo of FALT|FCONTROL|FNOINVERT|FSHIFT|FVIRTKEY).// wKey Accelerator key. This can either be a virtual key (FVIRTKEY) or an ASCII char code.// puCmdID Optional address to receive command identifier for the accelerator entry if// the key is in the table.// Returns nonzero if the key is in the accelerator table; otherwise 0.LWSTDAPI_(BOOL) SHQueryRawAccelerator ( HANDLE hcaAcc, IN BYTE fVirtMask, IN BYTE fVirt, IN WPARAM wKey, OUT OPTIONAL UINT* puCmdID );
// BOOL SHQueryRawAcceleratorMsg( HANDLE hcaAcc, MSG* pmsg, OUT OPTIONAL UINT* puCmdID );// Determines whether the specified message is an accelerator message mapping to// an entry in the raw accelerator table.// hcaAcc Handle returned from SHLoadRawAccelerators().// pmsg Address of the message to test.// puCmdID Optional address to receive command identifier for the accelerator entry if// the message maps to an accelerator in the table.// Returns nonzero if the message is a WM_KEYUP or WM_KEYDOWN and the key is in// the accelerator table; otherwise 0.LWSTDAPI_(BOOL) SHQueryRawAcceleratorMsg( HANDLE hcaAcc, MSG* pmsg, OUT OPTIONAL UINT* puCmdID );////
LWSTDAPI_(BOOL) SHBoolSystemParametersInfo(UINT uiAction, DWORD *pdwParam);
LWSTDAPI_(BOOL) SHAreIconsEqual(HICON hIcon1, HICON hIcon2);
////====== End Internal functions ===============================================//#endif // NO_SHLWAPI_INTERNAL
;end_internal
#if (_WIN32_IE >= 0x0500)
// SHAutoComplete// hwndEdit - HWND of editbox, ComboBox or ComboBoxEx.// dwFlags - Flags to indicate what to AutoAppend or AutoSuggest for the editbox.//// WARNING:// Caller needs to have called CoInitialize() or OleInitialize()// and cannot call CoUninit/OleUninit until after// WM_DESTROY on hwndEdit.//// dwFlags values:#define SHACF_DEFAULT 0x00000000 // Currently (SHACF_FILESYSTEM | SHACF_URLALL)#define SHACF_FILESYSTEM 0x00000001 // This includes the File System as well as the rest of the shell (Desktop\My Computer\Control Panel\)#define SHACF_URLALL (SHACF_URLHISTORY | SHACF_URLMRU)#define SHACF_URLHISTORY 0x00000002 // URLs in the User's History#define SHACF_URLMRU 0x00000004 // URLs in the User's Recently 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_FILESYS_ONLY 0x00000010 // This includes the File System
#if (_WIN32_IE >= 0x0600)#define SHACF_FILESYS_DIRS 0x00000020 // Same as SHACF_FILESYS_ONLY except it only includes directories, UNC servers, and UNC server shares.#endif // (_WIN32_IE >= 0x0600)
#define SHACF_AUTOSUGGEST_FORCE_ON 0x10000000 // Ignore the registry default and force the feature on.#define SHACF_AUTOSUGGEST_FORCE_OFF 0x20000000 // Ignore the registry default and force the feature off.#define SHACF_AUTOAPPEND_FORCE_ON 0x40000000 // Ignore the registry default and force the feature on. (Also know as AutoComplete)#define SHACF_AUTOAPPEND_FORCE_OFF 0x80000000 // Ignore the registry default and force the feature off. (Also know as AutoComplete)
LWSTDAPI SHAutoComplete(HWND hwndEdit, DWORD dwFlags);
LWSTDAPI SHSetThreadRef(IUnknown *punk);LWSTDAPI SHGetThreadRef(IUnknown **ppunk);
LWSTDAPI_(BOOL) SHSkipJunction(struct IBindCtx* pbc, const CLSID *pclsid);#endif // (_WIN32_IE >= 0x0500)
#define CTF_INSIST 0x00000001 // SHCreateThread() dwFlags - call pfnThreadProc synchronously if CreateThread() fails#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 FreeLibraryAndExitThread() 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 alive#define CTF_WAIT_ALLOWCOM 0x00000040 // while waiting for pfnCallback, allow COM marshaling to the blocked calling thread
LWSTDAPI_(BOOL) SHCreateThread(LPTHREAD_START_ROUTINE pfnThreadProc, void *pData, DWORD dwFlags, LPTHREAD_START_ROUTINE pfnCallback);
LWSTDAPI SHReleaseThreadRef(); // release a CTF_THREAD_REF reference earlier than the return of pfnThreadProc
#ifndef NO_SHLWAPI_GDI////====== GDI helper functions ================================================//
LWSTDAPI_(HPALETTE) SHCreateShellPalette(HDC hdc);
#if (_WIN32_IE >= 0x0500)
LWSTDAPI_(void) ColorRGBToHLS(COLORREF clrRGB, WORD* pwHue, WORD* pwLuminance, WORD* pwSaturation);LWSTDAPI_(COLORREF) ColorHLSToRGB(WORD wHue, WORD wLuminance, WORD wSaturation);LWSTDAPI_(COLORREF) ColorAdjustLuma(COLORREF clrRGB, int n, BOOL fScale);
;begin_internal#ifdef NOTYET // BUGBUG (scotth): once this is implemented, make this public// SHGetCommonResourceID//// (use MAKEINTRESOURCE on the following IDs)
// These values are indexes into an internal table. Be careful. ;internal#define SHGCR_BITMAP_WINDOWS_LOGO MAKEINTRESOURCE(1)#define SHGCR_AVI_FLASHLIGHT MAKEINTRESOURCE(2)#define SHGCR_AVI_FINDFILE MAKEINTRESOURCE(3)#define SHGCR_AVI_FINDCOMPUTER MAKEINTRESOURCE(4)#define SHGCR_AVI_FILEMOVE MAKEINTRESOURCE(5)#define SHGCR_AVI_FILECOPY MAKEINTRESOURCE(6)#define SHGCR_AVI_FILEDELETE MAKEINTRESOURCE(7)#define SHGCR_AVI_EMPTYWASTEBASKET MAKEINTRESOURCE(8)#define SHGCR_AVI_FILEREALDELETE MAKEINTRESOURCE(9) // Bypass Recycle Bin#define SHGCR_AVI_DOWNLOAD MAKEINTRESOURCE(10)
LWSTDAPI SHGetCommonResourceIDA(IN LPCSTR pszID, IN DWORD dwRes, OUT HMODULE * phmod, OUT UINT * pnID);LWSTDAPI SHGetCommonResourceIDA(IN LPCSTR pszID, IN DWORD dwRes, OUT HMODULE * phmod, OUT UINT * pnID);
#ifdef UNICODE#define SHGetCommonResourceID SHGetCommonResourceIDW#else#define SHGetCommonResourceID SHGetCommonResourceIDW#endif#endif // NOTYET;end_internal
#endif // _WIN32_IE >= 0x0500
#endif // NO_SHLWAPI_GDI
////====== DllGetVersion =======================================================//
typedef struct _DLLVERSIONINFO{ DWORD cbSize; DWORD dwMajorVersion; // Major version DWORD dwMinorVersion; // Minor version DWORD dwBuildNumber; // Build number DWORD dwPlatformID; // DLLVER_PLATFORM_*} DLLVERSIONINFO;
// Platform IDs for DLLVERSIONINFO#define DLLVER_PLATFORM_WINDOWS 0x00000001 // Windows 95#define DLLVER_PLATFORM_NT 0x00000002 // Windows NT
#if (_WIN32_IE >= 0x0501)
typedef struct _DLLVERSIONINFO2{ DLLVERSIONINFO info1; // dwFlags is really for alignment purposes ;Internal DWORD dwFlags; // No flags currently defined ULONGLONG ullVersion; // Encoded as: // Major 0xFFFF 0000 0000 0000 // Minor 0x0000 FFFF 0000 0000 // Build 0x0000 0000 FFFF 0000 // QFE 0x0000 0000 0000 FFFF} DLLVERSIONINFO2;
#define DLLVER_MAJOR_MASK 0xFFFF000000000000#define DLLVER_MINOR_MASK 0x0000FFFF00000000#define DLLVER_BUILD_MASK 0x00000000FFFF0000#define DLLVER_QFE_MASK 0x000000000000FFFF
#endif
#define MAKEDLLVERULL(major, minor, build, qfe) \ (((ULONGLONG)(major) << 48) | \ ((ULONGLONG)(minor) << 32) | \ ((ULONGLONG)(build) << 16) | \ ((ULONGLONG)( qfe) << 0))
//// The caller should always GetProcAddress("DllGetVersion"), not// implicitly link to it.//
typedef HRESULT (CALLBACK* DLLGETVERSIONPROC)(DLLVERSIONINFO *);
// DllInstall (to be implemented by self-installing DLLs)STDAPI DllInstall(BOOL bInstall, LPCWSTR pszCmdLine);
;begin_internal#if (_WIN32_IE >= 0x0501)//// ======== SHGetAppCompatFlags ================================================//
//===========================================================================// Shell Application Compatability flags
// SHGetAppCompatFlags flags#define ACF_NONE 0x00000000#define ACF_CONTEXTMENU 0x00000001#define ACF_CORELINTERNETENUM 0x00000004 // corel suite 8 has this same problem as suite 7 but does not have context menu one so need new bit#define ACF_OLDCREATEVIEWWND 0x00000004 // PowerDesk relies on CreateViewWindow returning S_OK#define ACF_WIN95DEFVIEW 0x00000004 // for apps that depend on win95 defview behavior#define ACF_DOCOBJECT 0x00000002#define ACF_FLUSHNOWAITALWAYS 0x00000001#define ACF_MYCOMPUTERFIRST 0x00000008 // MyComp must be first item on the desktop#define ACF_OLDREGITEMGDN 0x00000010 // Win95-compatible GetDisplayNameOf on regitems#define ACF_LOADCOLUMNHANDLER 0x00000040 // Dont delay load column handler.#define ACF_ANSI 0x00000080 // For Apps that Pass in ANSI Strings#define ACF_STRIPFOLDERBIT 0x00000100 // nuke the folder GAO in file dialog (for folder shortcuts, zip & cab files)#define ACF_WIN95SHLEXEC 0x00000200 // dont use DDEWAIT when thunking to ShellExecEx()#define ACF_STAROFFICE5PRINTER 0x00000400 // special return values from printer folder GAO#define ACF_NOVALIDATEFSIDS 0x00000800 // FS pidls should not be validated.#define ACF_FILEOPENNEEDSEXT 0x00001000 // Need to show extensioin in the name box of the open file common dialog#define ACF_WIN95BINDTOOBJECT 0x00002000 // Win95 BindToObject behavior dependencies#define ACF_IGNOREENUMRESET 0x00004000 // App relies on IEnumIDList::Reset returning E_NOTIMPL#define ACF_ANSIDISPLAYNAMES 0x00010000 // calling process requires the ISF::GDN in ansi#define ACF_FILEOPENBOGUSCTRLID 0x00020000 // Requires that the toolbar in fileopen have ctrl ID == ID_OK#define ACF_FORCELFNIDLIST 0x00040000 // forces no AltName in the FS pidls (for apps that read directly from the pidl)#define ACF_APPISOFFICE 0x01000000 // calling app is office (95, 97, 2000, ++)#define ACF_KNOWPERPROCESS 0x80000000 // We know the per process flags already.
// The flags that are per-process#define ACF_PERPROCESSFLAGS (ACF_CONTEXTMENU | ACF_CORELINTERNETENUM | ACF_OLDCREATEVIEWWND | ACF_WIN95DEFVIEW | \ ACF_DOCOBJECT | ACF_FLUSHNOWAITALWAYS | ACF_MYCOMPUTERFIRST | ACF_OLDREGITEMGDN | \ ACF_LOADCOLUMNHANDLER | ACF_ANSI | ACF_WIN95SHLEXEC | ACF_STAROFFICE5PRINTER | \ ACF_NOVALIDATEFSIDS | ACF_FILEOPENNEEDSEXT | ACF_WIN95BINDTOOBJECT | \ ACF_IGNOREENUMRESET | ACF_ANSIDISPLAYNAMES | ACF_FILEOPENBOGUSCTRLID | ACF_FORCELFNIDLIST)
// Flags that are per caller#define ACF_PERCALLFLAGS (ACF_APPISOFFICE | ACF_STRIPFOLDERBIT)
LWSTDAPI_(DWORD) SHGetAppCompatFlags (DWORD dwFlagsNeeded);
enum { OBJCOMPATF_OTNEEDSSFCACHE = 0x00000001, OBJCOMPATF_NO_WEBVIEW = 0x00000002, OBJCOMPATF_UNBINDABLE = 0x00000004, OBJCOMPATF_PINDLL = 0x00000008, OBJCOMPATF_NEEDSFILESYSANCESTOR = 0x00000010, OBJCOMPATF_NOTAFILESYSTEM = 0x00000020, OBJCOMPATF_CTXMENU_NOVERBS = 0x00000040, OBJCOMPATF_CTXMENU_LIMITEDQI = 0x00000080, OBJCOMPATF_COCREATESHELLFOLDERONLY = 0x00000100, OBJCOMPATF_NEEDSSTORAGEANCESTOR = 0x00000200, OBJCOMPATF_NOLEGACYWEBVIEW = 0x00000400, OBJCOMPATF_BLOCKSHELLSERVICEOBJECT = 0x00000800,} ;
typedef DWORD OBJCOMPATFLAGS;
LWSTDAPI_(OBJCOMPATFLAGS) SHGetObjectCompatFlags(IUnknown *punk, const CLSID *pclsid);
#endif // (_WIN32_IE >= 0x0501)
#if (_WIN32_IE >= 0x0560)LWSTDAPI_(UINT) GetUIVersion();#endif // (_WIN32_IE >= 0x0560)
;end_internal
;begin_both
#ifdef __cplusplus}#endif
#ifdef _WIN32#include <poppack.h>#endif
#endif
;end_both
#endif // _INC_SHLWAPIP ;internal#endif // _INC_SHLWAPI
|
