mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4858 lines
205 KiB
4858 lines
205 KiB
;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
|