able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/published/inc/shlwapi.w
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

4859 lines
205 KiB
OpenEdge ABL
Raw Blame History

;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 UNIX
typedef 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 __cplusplus
extern "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_both
LWSTDAPI_(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);
#endif
LWSTDAPI_(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_internal
LWSTDAPI_(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 439
LWSTDAPI 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_both
LWSTDAPI_(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" group
extern const SHELL_USER_SID susAdministrators; // the "Administrators" group
extern const SHELL_USER_SID susPowerUsers; // the "Power Users" group
extern const SHELL_USER_SID susGuests; // the "Guests" group
extern 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_internal
LWSTDAPI 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 copy
LWSTDAPI_(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 interface
LWSTDAPI 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_internal
LWSTDAPI 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 supported
LWSTDAPI 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 441
LWSTDAPI 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 378
LWSTDAPI_(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 376
LWSTDAPI_(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 397
LWSTDAPI_(BOOL) MLWinHelp%(HWND hWndCaller, LPCTSTR% lpszHelp, UINT uCommand, DWORD_PTR dwData);
#define ORD_MLHTMLHELPA 396
#define ORD_MLHTMLHELPW 398
LWSTDAPI_(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_internal
LWSTDAPI 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 FUNCTIONS
DWORD 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_TRACING
VOID 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 __cplusplus
extern "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 0x0001
LWSTDAPI 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)
#else
LWSTDAPI_(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 structure
typedef 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 broadcast
LWSTDAPI_(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_DEFINED
LWSTDAPI_(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 accordingly
HWND 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 Helpers
LWSTDAPI_(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)
// SHRestrictionLookup
typedef 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_BETA
LWSTDAPI_(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 DLLIMPORT
STDAPI_(BOOL)
GetFileVersionInfoWrapW(LPWSTR pwzFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData);
// Cannot be LWSTDAPI because winver.h declares the function as STDAPI and not DLLIMPORT
STDAPI_(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 UNIX
LWSTDAPI_(BOOL)
MessageBoxIndirectWrapW(CONST MSGBOXPARAMSW *pmbp);
#else
LWSTDAPI_(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 DLLIMPORT
STDAPI_(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 DLLIMPORT
STDAPI_(DWORD) WNetRestoreConnectionWrapW(IN HWND hwndParent, IN LPCWSTR pwzDevice);
// Cannot be LWSTDAPI because winnetwk.h declares the function as STDAPI and not DLLIMPORT
STDAPI_(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_DEFINED
LWSTDAPI_(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 STRICT
LWSTDAPI_(UINT) DragQueryFileWrapW(struct HDROP__*,UINT,LPWSTR,UINT);
#else
LWSTDAPI_(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 DLLIMPORT
STDAPI_(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);
#endif
LWSTDAPI_(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
Reference in a new issue View git blame Copy permalink