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.
1123 lines
41 KiB
1123 lines
41 KiB
//
|
|
// CCSHELL stock definition and declaration header
|
|
//
|
|
|
|
|
|
#ifndef __CCSTOCK_H__
|
|
#define __CCSTOCK_H__
|
|
|
|
#include <malloc.h> // for _alloca
|
|
|
|
#ifndef RC_INVOKED
|
|
|
|
// NT and Win95 environments set warnings differently. This makes
|
|
// our project consistent across environments.
|
|
|
|
#pragma warning(3:4101) // Unreferenced local variable
|
|
|
|
//
|
|
// Sugar-coating
|
|
//
|
|
|
|
#define PUBLIC
|
|
#define PRIVATE
|
|
#define IN
|
|
#define OUT
|
|
#define BLOCK
|
|
|
|
#ifndef DECLARE_STANDARD_TYPES
|
|
|
|
/*
|
|
* For a type "FOO", define the standard derived types PFOO, CFOO, and PCFOO.
|
|
*/
|
|
|
|
#define DECLARE_STANDARD_TYPES(type) typedef type *P##type; \
|
|
typedef const type C##type; \
|
|
typedef const type *PC##type;
|
|
|
|
#endif
|
|
|
|
#ifndef DECLARE_STANDARD_TYPES_U
|
|
|
|
/*
|
|
* For a type "FOO", define the standard derived UNALIGNED types PFOO, CFOO, and PCFOO.
|
|
* WINNT: RISC boxes care about ALIGNED, intel does not.
|
|
*/
|
|
|
|
#define DECLARE_STANDARD_TYPES_U(type) typedef UNALIGNED type *P##type; \
|
|
typedef UNALIGNED const type C##type; \
|
|
typedef UNALIGNED const type *PC##type;
|
|
|
|
#endif
|
|
|
|
// For string constants that are always wide
|
|
#define __TEXTW(x) L##x
|
|
#define TEXTW(x) __TEXTW(x)
|
|
|
|
//
|
|
// Count of characters to count of bytes
|
|
//
|
|
#define CbFromCchW(cch) ((cch)*sizeof(WCHAR))
|
|
#define CbFromCchA(cch) ((cch)*sizeof(CHAR))
|
|
#ifdef UNICODE
|
|
#define CbFromCch CbFromCchW
|
|
#else // UNICODE
|
|
#define CbFromCch CbFromCchA
|
|
#endif // UNICODE
|
|
|
|
//
|
|
// General flag macros
|
|
//
|
|
#define SetFlag(obj, f) do {obj |= (f);} while (0)
|
|
#define ToggleFlag(obj, f) do {obj ^= (f);} while (0)
|
|
#define ClearFlag(obj, f) do {obj &= ~(f);} while (0)
|
|
#define IsFlagSet(obj, f) (BOOL)(((obj) & (f)) == (f))
|
|
#define IsFlagClear(obj, f) (BOOL)(((obj) & (f)) != (f))
|
|
|
|
//
|
|
// String macros
|
|
//
|
|
#define IsSzEqual(sz1, sz2) (BOOL)(lstrcmpi(sz1, sz2) == 0)
|
|
#define IsSzEqualC(sz1, sz2) (BOOL)(lstrcmp(sz1, sz2) == 0)
|
|
|
|
#define lstrnicmpA(sz1, sz2, cch) StrCmpNIA(sz1, sz2, cch)
|
|
#define lstrnicmpW(sz1, sz2, cch) StrCmpNIW(sz1, sz2, cch)
|
|
#define lstrncmpA(sz1, sz2, cch) StrCmpNA(sz1, sz2, cch)
|
|
#define lstrncmpW(sz1, sz2, cch) StrCmpNW(sz1, sz2, cch)
|
|
|
|
//
|
|
// lstrcatnA and lstrcatnW are #defined here to StrCatBuff which is implemented
|
|
// in shlwapi. We do this here (and not in shlwapi.h or shlwapip.h) in case the
|
|
// kernel guys ever decided to implement this.
|
|
//
|
|
#define lstrcatnA(sz1, sz2, cchBuffSize) StrCatBuffA(sz1, sz2, cchBuffSize)
|
|
#define lstrcatnW(sz1, sz2, cchBuffSize) StrCatBuffW(sz1, sz2, cchBuffSize)
|
|
#ifdef UNICODE
|
|
#define lstrcatn lstrcatnW
|
|
#else
|
|
#define lstrcatn lstrcatnA
|
|
#endif // UNICODE
|
|
|
|
#ifdef UNICODE
|
|
#define lstrnicmp lstrnicmpW
|
|
#define lstrncmp lstrncmpW
|
|
#else
|
|
#define lstrnicmp lstrnicmpA
|
|
#define lstrncmp lstrncmpA
|
|
#endif
|
|
|
|
#ifndef SIZEOF
|
|
#define SIZEOF(a) sizeof(a)
|
|
#endif
|
|
|
|
#ifndef ARRAYSIZE
|
|
#define ARRAYSIZE(a) (sizeof(a)/sizeof(a[0]))
|
|
#endif
|
|
#define SIZECHARS(sz) (sizeof(sz)/sizeof(sz[0]))
|
|
|
|
#define InRange(id, idFirst, idLast) ((UINT)((id)-(idFirst)) <= (UINT)((idLast)-(idFirst)))
|
|
#define IsInRange InRange
|
|
|
|
// ATOMICRELEASE
|
|
//
|
|
#ifndef ATOMICRELEASE
|
|
# ifdef __cplusplus
|
|
# define ATOMICRELEASET(p, type) { if(p) { type* punkT=p; p=NULL; punkT->Release();} }
|
|
# else
|
|
# define ATOMICRELEASET(p, type) { if(p) { type* punkT=p; p=NULL; punkT->lpVtbl->Release(punkT);} }
|
|
# endif
|
|
|
|
// doing this as a function instead of inline seems to be a size win.
|
|
//
|
|
# ifdef NOATOMICRELESEFUNC
|
|
# define ATOMICRELEASE(p) ATOMICRELEASET(p, IUnknown)
|
|
# else
|
|
# ifdef __cplusplus
|
|
# define ATOMICRELEASE(p) IUnknown_SafeReleaseAndNullPtr(p)
|
|
# else
|
|
# define ATOMICRELEASE(p) IUnknown_AtomicRelease((void **)&p)
|
|
# endif
|
|
# endif
|
|
#endif //ATOMICRELEASE
|
|
|
|
//
|
|
// IID_PPV_ARG(IType, ppType)
|
|
// IType is the type of pType
|
|
// ppType is the variable of type IType that will be filled
|
|
//
|
|
// RESULTS in: IID_IType, ppvType
|
|
// will create a compiler error if wrong level of indirection is used.
|
|
//
|
|
// macro for QueryInterface and related functions
|
|
// that require a IID and a (void **)
|
|
// this will insure that the cast is safe and appropriate on C++
|
|
//
|
|
// IID_PPV_ARG_NULL(IType, ppType)
|
|
//
|
|
// Just like IID_PPV_ARG, except that it sticks a NULL between the
|
|
// IID and PPV (for IShellFolder::GetUIObjectOf).
|
|
//
|
|
// IID_X_PPV_ARG(IType, X, ppType)
|
|
//
|
|
// Just like IID_PPV_ARG, except that it sticks X between the
|
|
// IID and PPV (for SHBindToObject).
|
|
//
|
|
//
|
|
#ifdef __cplusplus
|
|
#define IID_PPV_ARG(IType, ppType) IID_##IType, reinterpret_cast<void**>(static_cast<IType**>(ppType))
|
|
#define IID_X_PPV_ARG(IType, X, ppType) IID_##IType, X, reinterpret_cast<void**>(static_cast<IType**>(ppType))
|
|
#else
|
|
#define IID_PPV_ARG(IType, ppType) &IID_##IType, (void**)(ppType)
|
|
#define IID_X_PPV_ARG(IType, X, ppType) &IID_##IType, X, (void**)(ppType)
|
|
#endif
|
|
#define IID_PPV_ARG_NULL(IType, ppType) IID_X_PPV_ARG(IType, NULL, ppType)
|
|
|
|
#define PPUNK_SET(ppunkDst, punkSrc) \
|
|
{ ATOMICRELEASE(*ppunkDst); \
|
|
if (punkSrc) \
|
|
{ punkSrc->AddRef(); \
|
|
*ppunkDst = punkSrc; \
|
|
} \
|
|
}
|
|
|
|
//
|
|
// Helper macro for managing weak pointers to inner interfaces.
|
|
// (It's the weak version of ATOMICRELEASE.)
|
|
//
|
|
// The extra cast to (void **) is to keep C++ from doing strange
|
|
// inheritance games when all I want to do is change the type.
|
|
//
|
|
#ifndef RELEASEINNERINTERFACE
|
|
#define RELEASEINNERINTERFACE(pOuter, p) \
|
|
SHReleaseInnerInterface(pOuter, (IUnknown**)(void **)&(p))
|
|
#endif // RELEASEINNERINTERFACE
|
|
|
|
// For checking window charsets
|
|
#ifdef UNICODE
|
|
#define IsWindowTchar IsWindowUnicode
|
|
#else // !UNICODE
|
|
#define IsWindowTchar !IsWindowUnicode
|
|
#endif // UNICODE
|
|
|
|
#ifdef DEBUG
|
|
// This macro is especially useful for cleaner looking code in
|
|
// declarations or for single lines. For example, instead of:
|
|
//
|
|
// {
|
|
// DWORD dwRet;
|
|
// #ifdef DEBUG
|
|
// DWORD dwDebugOnlyVariable;
|
|
// #endif
|
|
//
|
|
// ....
|
|
// }
|
|
//
|
|
// You can type:
|
|
//
|
|
// {
|
|
// DWORD dwRet;
|
|
// DEBUG_CODE( DWORD dwDebugOnlyVariable; )
|
|
//
|
|
// ....
|
|
// }
|
|
|
|
#define DEBUG_CODE(x) x
|
|
#else
|
|
#define DEBUG_CODE(x)
|
|
|
|
#endif // DEBUG
|
|
|
|
|
|
//
|
|
// SAFECAST(obj, type)
|
|
//
|
|
// This macro is extremely useful for enforcing strong typechecking on other
|
|
// macros. It generates no code.
|
|
//
|
|
// Simply insert this macro at the beginning of an expression list for
|
|
// each parameter that must be typechecked. For example, for the
|
|
// definition of MYMAX(x, y), where x and y absolutely must be integers,
|
|
// use:
|
|
//
|
|
// #define MYMAX(x, y) (SAFECAST(x, int), SAFECAST(y, int), ((x) > (y) ? (x) : (y)))
|
|
//
|
|
//
|
|
#define SAFECAST(_obj, _type) (((_type)(_obj)==(_obj)?0:0), (_type)(_obj))
|
|
|
|
|
|
//
|
|
// Bitfields don't get along too well with bools,
|
|
// so here's an easy way to convert them:
|
|
//
|
|
#define BOOLIFY(expr) (!!(expr))
|
|
|
|
|
|
// (scotth): we should probably make this a 'bool', but be careful
|
|
// because the Alpha compiler might not recognize it yet. Talk to AndyP.
|
|
// This isn't a BOOL because BOOL is signed and the compiler produces
|
|
// sloppy code when testing for a single bit.
|
|
|
|
typedef DWORD BITBOOL;
|
|
|
|
// a three state boolean for bools that need initialization
|
|
typedef enum
|
|
{
|
|
TRIBIT_UNDEFINED = 0,
|
|
TRIBIT_TRUE,
|
|
TRIBIT_FALSE,
|
|
} TRIBIT;
|
|
|
|
//
|
|
// DESTROY_OBJ_WITH_HANDLE(h, fn)
|
|
//
|
|
// Kind of like ATOMICRELEASE for handles. Checks for NULL and assigns
|
|
// NULL when it's done. You supply the destructor function.
|
|
//
|
|
#define DESTROY_OBJ_WITH_HANDLE(h, fn) { if (h) { fn(h); (h) = NULL; } }
|
|
|
|
|
|
// STOCKLIB util functions
|
|
|
|
// staticIsOS(): returns TRUE/FALSE if the platform is the indicated OS.
|
|
// This function exists for those who cannot link to shlwapi.dll
|
|
STDAPI_(BOOL) staticIsOS(DWORD dwOS);
|
|
|
|
#include <pshpack2.h>
|
|
typedef struct tagDLGTEMPLATEEX
|
|
{
|
|
WORD wDlgVer;
|
|
WORD wSignature;
|
|
DWORD dwHelpID;
|
|
DWORD dwExStyle;
|
|
DWORD dwStyle;
|
|
WORD cDlgItems;
|
|
short x;
|
|
short y;
|
|
short cx;
|
|
short cy;
|
|
} DLGTEMPLATEEX, *LPDLGTEMPLATEEX;
|
|
#include <poppack.h>
|
|
|
|
//
|
|
// round macro that rounds a to the next multiple of b.
|
|
//
|
|
#ifndef ROUNDUP
|
|
#define ROUNDUP(a,b) ((((a)+(b)-1)/(b))*(b))
|
|
#endif
|
|
|
|
#define ROUND_TO_CLUSTER ROUNDUP
|
|
|
|
//
|
|
// macro that rounds cbSize fields to the nearest pointer size (for alignment)
|
|
//
|
|
#define ROUND_TO_POINTER(cbSize) ROUNDUP(cbSize, sizeof(void*))
|
|
|
|
//
|
|
// macro that sees if a give char is an number
|
|
//
|
|
#define ISDIGIT(c) ((c) >= TEXT('0') && (c) <= TEXT('9'))
|
|
|
|
//
|
|
// inline that does PathIsDotOrDotDot
|
|
//
|
|
__inline BOOL PathIsDotOrDotDotW(LPCWSTR pszPath)
|
|
{
|
|
return ((pszPath[0] == L'.') &&
|
|
((pszPath[1] == L'\0') || ((pszPath[1] == L'.') && (pszPath[2] == L'\0'))));
|
|
}
|
|
|
|
__inline BOOL PathIsDotOrDotDotA(LPCSTR pszPath)
|
|
{
|
|
return ((pszPath[0] == '.') &&
|
|
((pszPath[1] == '\0') || ((pszPath[1] == '.') && (pszPath[2] == '\0'))));
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
#define PathIsDotOrDotDot PathIsDotOrDotDotW
|
|
#else
|
|
#define PathIsDotOrDotDot PathIsDotOrDotDotA
|
|
#endif
|
|
|
|
//
|
|
// FILETIME helpers
|
|
//
|
|
__inline unsigned __int64 _FILETIMEtoInt64(const FILETIME* pft)
|
|
{
|
|
return ((unsigned __int64)pft->dwHighDateTime << 32) + pft->dwLowDateTime;
|
|
}
|
|
|
|
#define FILETIMEtoInt64(ft) _FILETIMEtoInt64(&(ft))
|
|
|
|
__inline void SetFILETIMEfromInt64(FILETIME *pft, unsigned __int64 i64)
|
|
{
|
|
pft->dwLowDateTime = (DWORD)i64;
|
|
pft->dwHighDateTime = (DWORD)(i64 >> 32);
|
|
}
|
|
|
|
__inline void IncrementFILETIME(FILETIME *pft, unsigned __int64 iAdjust)
|
|
{
|
|
SetFILETIMEfromInt64(pft, _FILETIMEtoInt64(pft) + iAdjust);
|
|
}
|
|
|
|
__inline void DecrementFILETIME(FILETIME *pft, unsigned __int64 iAdjust)
|
|
{
|
|
SetFILETIMEfromInt64(pft, _FILETIMEtoInt64(pft) - iAdjust);
|
|
}
|
|
|
|
//
|
|
// FAT and NTFS use different values for "unknown date".
|
|
//
|
|
// The FAT "unknown date" is January 1 1980 LOCAL TIME.
|
|
// The NTFS "unknown date" is January 1 1601 GMT.
|
|
//
|
|
// This LOCAL/GMT discrepancy is annoying.
|
|
//
|
|
#define FT_FAT_UNKNOWNLOCAL ((unsigned __int64)0x01A8E79FE1D58000)
|
|
#define FT_NTFS_UNKNOWNGMT ((unsigned __int64)0x0000000000000000)
|
|
|
|
//
|
|
// FT_ONEHOUR is the number of FILETIME units in an hour.
|
|
// FT_ONEDAY is the number of FILETIME units in a day.
|
|
//
|
|
// 10,000,000 FILETIME units per second *
|
|
// 3600 seconds per hour *
|
|
// 24 hours per day.
|
|
//
|
|
#define FT_ONESECOND ((unsigned __int64)10000000)
|
|
#define FT_ONEHOUR ((unsigned __int64)10000000 * 3600)
|
|
#define FT_ONEDAY ((unsigned __int64)10000000 * 3600 * 24)
|
|
|
|
|
|
//
|
|
//
|
|
// WindowLong accessor macros and other Win64 niceness
|
|
//
|
|
|
|
__inline void * GetWindowPtr(HWND hWnd, int nIndex) {
|
|
return (void *)GetWindowLongPtr(hWnd, nIndex);
|
|
}
|
|
|
|
__inline void * SetWindowPtr(HWND hWnd, int nIndex, void * p) {
|
|
return (void *)SetWindowLongPtr(hWnd, nIndex, (LONG_PTR)p);
|
|
}
|
|
|
|
//*** GetWindowLong0 -- 'fast' GetWindowLong (and GetWindowLongPtr)
|
|
// DESCRIPTION
|
|
// what's up w/ this? it's all about perf. GetWindowLong has 'A' and 'W'
|
|
// versions. however 99% of the time they do the same thing (the other
|
|
// 0.1% has to do w/ setting the WndProc and having to go thru a thunk).
|
|
// but we still need wrappers for the general case. but most of the time
|
|
// we're just doing a GWL(0), e.g. on entry to a wndproc to get our private
|
|
// data. so by having a special version of that, we save going thru the
|
|
// wrapper (which was costing us 1-3% of our profile).
|
|
// NOTES
|
|
// note that we call the 'A' version since that's guaranteed to exist on
|
|
// all platforms.
|
|
__inline LONG GetWindowLong0(HWND hWnd) {
|
|
return GetWindowLongA(hWnd, 0);
|
|
}
|
|
__inline LONG SetWindowLong0(HWND hWnd, LONG l) {
|
|
return SetWindowLongA(hWnd, 0, l);
|
|
}
|
|
__inline void * GetWindowPtr0(HWND hWnd) {
|
|
return (void *)GetWindowLongPtrA(hWnd, 0);
|
|
}
|
|
__inline void * SetWindowPtr0(HWND hWnd, void * p) {
|
|
return (void *)SetWindowLongPtrA(hWnd, 0, (LONG_PTR)p);
|
|
}
|
|
|
|
|
|
#define IS_WM_CONTEXTMENU_KEYBOARD(lParam) ((DWORD)(lParam) == 0xFFFFFFFF)
|
|
|
|
//
|
|
// CharUpperChar - Convert a single character to uppercase
|
|
//
|
|
__inline WCHAR CharUpperCharW(int c)
|
|
{
|
|
return (WCHAR)(DWORD_PTR)CharUpperW((LPWSTR)(DWORD_PTR)(c));
|
|
}
|
|
|
|
__inline CHAR CharUpperCharA(int c)
|
|
{
|
|
return (CHAR)(DWORD_PTR)CharUpperA((LPSTR)(DWORD_PTR)(c));
|
|
}
|
|
|
|
//
|
|
// CharLowerChar - Convert a single character to lowercase
|
|
//
|
|
__inline WCHAR CharLowerCharW(int c)
|
|
{
|
|
return (WCHAR)(DWORD_PTR)CharLowerW((LPWSTR)(DWORD_PTR)(c));
|
|
}
|
|
|
|
__inline CHAR CharLowerCharA(int c)
|
|
{
|
|
return (CHAR)(DWORD_PTR)CharLowerA((LPSTR)(DWORD_PTR)(c));
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
#define CharUpperChar CharUpperCharW
|
|
#define CharLowerChar CharLowerCharW
|
|
#else
|
|
#define CharUpperChar CharUpperCharA
|
|
#define CharLowerChar CharLowerCharA
|
|
#endif
|
|
|
|
//
|
|
// ShrinkProcessWorkingSet - Use this to stay Sundown-happy.
|
|
//
|
|
#define ShrinkWorkingSet() \
|
|
SetProcessWorkingSetSize(GetCurrentProcess(), (SIZE_T) -1, (SIZE_T) -1)
|
|
|
|
//
|
|
// COM Initialization.
|
|
//
|
|
// Usage:
|
|
//
|
|
// HRESULT hrInit = SHCoInitialize();
|
|
// ... do COM stuff ...
|
|
// SHCoUninitialize(hrInit);
|
|
//
|
|
// Notice: Continue doing COM stuff even if SHCoInitialize fails.
|
|
// It might fail if somebody else already CoInit'd with different
|
|
// flags, but we don't want to barf under those conditions.
|
|
//
|
|
|
|
STDAPI SHCoInitialize(void);
|
|
#define SHCoUninitialize(hr) if (SUCCEEDED(hr)) CoUninitialize()
|
|
|
|
|
|
//
|
|
// OLE Initialization.
|
|
//
|
|
// Usage:
|
|
//
|
|
// HRESULT hrInit = SHOleInitialize(pMalloc);
|
|
// ... do COM stuff ...
|
|
// SHOleUninitialize(hrInit);
|
|
//
|
|
|
|
#define SHOleInitialize(pMalloc) OleInitialize(pMalloc)
|
|
|
|
#define SHOleUninitialize(hr) if (SUCCEEDED(hr)) OleUninitialize()
|
|
|
|
#include <shtypes.h>
|
|
|
|
//
|
|
// Name Parsing generic across the shell
|
|
//
|
|
// Usage:
|
|
//
|
|
// HRESULT SHGetNameAndFlags()
|
|
// wrapper to bind to the folder and do a GetDisplayName()
|
|
//
|
|
STDAPI SHGetNameAndFlagsA(LPCITEMIDLIST pidl, DWORD dwFlags, LPSTR pszName, UINT cchName, DWORD *pdwAttribs);
|
|
STDAPI SHGetNameAndFlagsW(LPCITEMIDLIST pidl, DWORD dwFlags, LPWSTR pszName, UINT cchName, DWORD *pdwAttribs);
|
|
|
|
STDAPI SHBindToObject(struct IShellFolder *psf, REFIID riid, LPCITEMIDLIST pidl, void **ppv);
|
|
STDAPI SHBindToObjectEx(struct IShellFolder *psf, LPCITEMIDLIST pidl, struct IBindCtx *pbc, REFIID riid, void **ppv);
|
|
STDAPI SHGetUIObjectFromFullPIDL(LPCITEMIDLIST pidl, HWND hwnd, REFIID riid, void **ppv);
|
|
STDAPI SHGetTargetFolderIDList(LPCITEMIDLIST pidlFolder, LPITEMIDLIST *ppidl);
|
|
STDAPI SHGetTargetFolderPathW(LPCITEMIDLIST pidlFolder, LPWSTR pszPath, UINT cchBuf);
|
|
STDAPI SHGetTargetFolderPathA(LPCITEMIDLIST pidlFolder, LPSTR pszPath, UINT cchBuf);
|
|
STDAPI_(DWORD) SHGetAttributes(struct IShellFolder *psf, LPCITEMIDLIST pidl, DWORD dwAttributes);
|
|
|
|
#define SHGetAttributesOf(pidl, prgfInOut) SHGetNameAndFlags(pidl, 0, NULL, 0, prgfInOut)
|
|
|
|
#ifdef __IShellFolder2_FWD_DEFINED__
|
|
STDAPI GetDateProperty(IShellFolder2 *psf, LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, FILETIME *pft);
|
|
STDAPI GetLongProperty(IShellFolder2 *psf, LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, ULONGLONG *pdw);
|
|
STDAPI GetStringProperty(IShellFolder2 *psf, LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, LPTSTR pszVal, int cchMax);
|
|
#endif // __IShellFolder2_FWD_DEFINED__
|
|
|
|
STDAPI LoadFromFileW(REFCLSID clsid, LPCWSTR pszFile, REFIID riid, void **ppv);
|
|
STDAPI LoadFromIDList(REFCLSID clsid, LPCITEMIDLIST pidl, REFIID riid, void **ppv);
|
|
|
|
STDAPI_(DWORD) GetUrlSchemeW(LPCWSTR pszUrl);
|
|
STDAPI_(DWORD) GetUrlSchemeA(LPCSTR pszUrl);
|
|
STDAPI_(void) SHRemoveURLTurd(LPTSTR pszUrl);
|
|
STDAPI_(void) SHCleanupUrlForDisplay(LPTSTR pszUrl);
|
|
STDAPI_(BOOL) ShouldNavigateInIE(LPCWSTR pszUrl);
|
|
STDAPI_(BOOL) IsDesktopFrame(IUnknown *punk);
|
|
|
|
#ifdef UNICODE
|
|
#define SHGetNameAndFlags SHGetNameAndFlagsW
|
|
#define GetUrlScheme GetUrlSchemeW
|
|
#define SHGetTargetFolderPath SHGetTargetFolderPathW
|
|
#define LoadFromFile LoadFromFileW
|
|
#else
|
|
#define SHGetNameAndFlags SHGetNameAndFlagsA
|
|
#define GetUrlScheme GetUrlSchemeA
|
|
#define SHGetTargetFolderPath SHGetTargetFolderPathA
|
|
#endif
|
|
|
|
//
|
|
// BindCtx helpers
|
|
//
|
|
STDAPI BindCtx_CreateWithMode(DWORD grfMode, IBindCtx **ppbc);
|
|
STDAPI_(DWORD) BindCtx_GetMode(IBindCtx *pbc, DWORD grfModeDefault);
|
|
STDAPI_(BOOL) BindCtx_ContainsObject(IBindCtx *pbc, LPOLESTR sz);
|
|
STDAPI BindCtx_RegisterObjectParam(IBindCtx *pbcIn, LPCOLESTR pszRegister, IUnknown *punkRegister, IBindCtx **ppbcOut);
|
|
STDAPI BindCtx_CreateWithTimeoutDelta(DWORD dwTicksToAllow, IBindCtx **ppbc);
|
|
STDAPI BindCtx_GetTimeoutDelta(IBindCtx *pbc, DWORD *pdwTicksToAllow);
|
|
STDAPI BindCtx_RegisterUIWindow(IBindCtx *pbcIn, HWND hwnd, IBindCtx **ppbcOut);
|
|
STDAPI_(HWND) BindCtx_GetUIWindow(IBindCtx *pbc);
|
|
|
|
typedef struct _BINDCTX_PARAM
|
|
{
|
|
LPCWSTR pszName;
|
|
IBindCtx *pbcParam;
|
|
} BINDCTX_PARAM;
|
|
STDAPI BindCtx_RegisterObjectParams(IBindCtx *pbcIn, BINDCTX_PARAM *rgParams, UINT cParams, IBindCtx **ppbcOut);
|
|
|
|
// SHBindToIDListParent(LPCITEMIDLIST pidl, REFIID riid, void **ppv, LPCITEMIDLIST *ppidlLast)
|
|
//
|
|
// Given a pidl, you can get an interface pointer (as specified by riid) of the pidl's parent folder (in ppv)
|
|
// If ppidlLast is non-NULL, you can also get the pidl of the last item.
|
|
//
|
|
STDAPI SHBindToIDListParent(LPCITEMIDLIST pidl, REFIID riid, void **ppv, LPCITEMIDLIST *ppidlLast);
|
|
|
|
//
|
|
// SHBindToFolderIDListParent
|
|
//
|
|
// Same as SHBindToIDListParent, except you also specify which root to use.
|
|
//
|
|
STDAPI SHBindToFolderIDListParent(struct IShellFolder *psfRoot, LPCITEMIDLIST pidl, REFIID riid, void **ppv, LPCITEMIDLIST *ppidlLast);
|
|
|
|
|
|
//
|
|
// context menu and dataobject helpers.
|
|
//
|
|
STDAPI_(void) ReleaseStgMediumHGLOBAL(void *pv, STGMEDIUM *pmedium);
|
|
#define FAILED_AND_NOT_CANCELED(hr) (FAILED(hr) && (HRESULT_FROM_WIN32(ERROR_CANCELLED) != hr))
|
|
STDAPI SHInvokeCommandOnPidl(HWND hwnd, IUnknown* punk, LPCITEMIDLIST pidl, UINT uFlags, LPCSTR lpVerb);
|
|
STDAPI SHInvokeCommandOnPidlArray(HWND hwnd, IUnknown* punk, struct IShellFolder* psf, LPCITEMIDLIST *ppidlItem, UINT cItems, UINT uFlags, LPCSTR lpVerb);
|
|
STDAPI SHInvokeCommandOnDataObject(HWND hwnd, IUnknown* punk, IDataObject* pdo, UINT uFlags, LPCSTR lpVerb);
|
|
|
|
|
|
STDAPI DisplayNameOf(struct IShellFolder *psf, LPCITEMIDLIST pidl, DWORD flags, LPTSTR psz, UINT cch);
|
|
STDAPI DisplayNameOfAsOLESTR(struct IShellFolder *psf, LPCITEMIDLIST pidl, DWORD flags, LPWSTR *ppsz);
|
|
|
|
// clones the parent of the pidl
|
|
STDAPI_(LPITEMIDLIST) ILCloneParent(LPCITEMIDLIST pidl);
|
|
|
|
STDAPI SHGetIDListFromUnk(IUnknown *punk, LPITEMIDLIST *ppidl);
|
|
|
|
STDAPI_(BOOL) ILIsRooted(LPCITEMIDLIST pidl);
|
|
STDAPI_(LPCITEMIDLIST) ILRootedFindIDList(LPCITEMIDLIST pidl);
|
|
STDAPI_(BOOL) ILRootedGetClsid(LPCITEMIDLIST pidl, CLSID *clsid);
|
|
STDAPI_(LPITEMIDLIST) ILRootedCreateIDList(CLSID *pclsid, LPCITEMIDLIST pidl);
|
|
STDAPI_(int) ILRootedCompare(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
|
|
#define ILIsEqualRoot(pidl1, pidl2) (0 == ILRootedCompare(pidl1, pidl2))
|
|
STDAPI ILRootedBindToRoot(LPCITEMIDLIST pidl, REFIID riid, void **ppv);
|
|
STDAPI ILRootedBindToObject(LPCITEMIDLIST pidl, REFIID riid, void **ppv);
|
|
STDAPI ILRootedBindToParentFolder(LPCITEMIDLIST pidl, REFIID riid, void **ppv, LPCITEMIDLIST *ppidlChild);
|
|
|
|
typedef HGLOBAL HIDA;
|
|
|
|
STDAPI_(HIDA) HIDA_Create(LPCITEMIDLIST pidlFolder, UINT cidl, LPCITEMIDLIST *apidl);
|
|
STDAPI_(void) HIDA_Free(HIDA hida);
|
|
STDAPI_(HIDA) HIDA_Clone(HIDA hida);
|
|
STDAPI_(UINT) HIDA_GetCount(HIDA hida);
|
|
STDAPI_(UINT) HIDA_GetIDList(HIDA hida, UINT i, LPITEMIDLIST pidlOut, UINT cbMax);
|
|
|
|
STDAPI StgMakeUniqueName(IStorage *pStorageParent, LPCTSTR pszFileSpec, REFIID riid, void **ppv);
|
|
|
|
STDAPI_(BOOL) PathIsImage(LPCTSTR pszFile);
|
|
STDAPI_(BOOL) SHChangeMenuWasSentByMe(LPVOID self, LPCITEMIDLIST pidlNotify);
|
|
STDAPI_(void) SHSendChangeMenuNotify(LPVOID self, DWORD shcnee, DWORD shcnf, LPCITEMIDLIST pidl2);
|
|
|
|
STDAPI_(BOOL) Pidl_Set(LPITEMIDLIST* ppidl, LPCITEMIDLIST pidl);
|
|
|
|
STDAPI GetHTMLDoc2(IUnknown *punk, struct IHTMLDocument2 **ppHtmlDoc);
|
|
STDAPI LocalZoneCheck(IUnknown *punkSite);
|
|
STDAPI LocalZoneCheckPath(LPCWSTR pszUrl, IUnknown *punkSite);
|
|
STDAPI GetZoneFromUrl(LPCWSTR pszUrl, IUnknown * punkSite, DWORD * pdwZoneID);
|
|
STDAPI GetZoneFromSite(IUnknown *punkSite, DWORD * pdwZoneID);
|
|
|
|
STDAPI SHGetDefaultClientOpenCommandW(LPCWSTR pwszClientType,
|
|
LPWSTR pwszClientCommand, DWORD dwCch,
|
|
OPTIONAL LPWSTR pwszClientParams, DWORD dwCchParams);
|
|
STDAPI SHGetDefaultClientNameW(LPCWSTR pwszClientType, LPWSTR pwszBuf, DWORD dwCch);
|
|
|
|
//===========================================================================
|
|
// Helper functions for pidl allocation using the task allocator.
|
|
//
|
|
STDAPI_(LPITEMIDLIST) _ILCreate(UINT cbSize);
|
|
STDAPI SHILClone(LPCITEMIDLIST pidl, LPITEMIDLIST * ppidlOut);
|
|
STDAPI SHILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, LPITEMIDLIST * ppidlOut);
|
|
#define SHILFree(pidl) SHFree(pidl)
|
|
|
|
//
|
|
// DLL version helper macros
|
|
//
|
|
// To add DllGetVersion support to your DLL, do this:
|
|
//
|
|
// 1. foo.c
|
|
//
|
|
// DLLVER_SINGLEBINARY(VER_PRODUCTVERSION_DW, VER_PRODUCTBUILD_QFE);
|
|
//
|
|
// or
|
|
//
|
|
// DLLVER_DUALBINARY(VER_PRODUCTVERSION_DW, VER_PRODUCTBUILD_QFE);
|
|
//
|
|
// depending on whether you are a single-binary or dual-binary component.
|
|
//
|
|
// 2. foo.src:
|
|
//
|
|
// DllGetVersion = CCDllGetVersion ULTRAPRIVATE
|
|
//
|
|
// 3. sources:
|
|
//
|
|
// LINKLIBS = $(LINKLIBS) $(CCSHELL_DIR)\lib\$(O)\stocklib.lib
|
|
//
|
|
|
|
#define PRODUCTVER_GETMAJOR(ver) (((ver) & 0xFF000000) >> 24)
|
|
#define PRODUCTVER_GETMINOR(ver) (((ver) & 0x00FF0000) >> 16)
|
|
#define PRODUCTVER_GETBUILD(ver) (((ver) & 0x0000FFFF) >> 0)
|
|
|
|
#define MAKEDLLVERULL_PRODUCTVERQFE(ver, qfe) \
|
|
MAKEDLLVERULL(PRODUCTVER_GETMAJOR(ver), \
|
|
PRODUCTVER_GETMINOR(ver), \
|
|
PRODUCTVER_GETBUILD(ver), qfe)
|
|
|
|
#define MAKE_DLLVER_STRUCT(ver, plat, qfe) \
|
|
EXTERN_C const DLLVERSIONINFO2 c_dllver = { \
|
|
{ /* DLLVERSIONINFO */ \
|
|
0, /* cbSize */ \
|
|
PRODUCTVER_GETMAJOR(ver), /* dwMajorVersion */ \
|
|
PRODUCTVER_GETMINOR(ver), /* dwMinorVersion */ \
|
|
PRODUCTVER_GETBUILD(ver), /* dwBuildNumber */ \
|
|
plat, /* dwPlatformID */ \
|
|
}, \
|
|
0, /* dwFlags */ \
|
|
MAKEDLLVERULL_PRODUCTVERQFE(ver, qfe), /* ullVersion */ \
|
|
}
|
|
|
|
#define DLLVER_9xBINARY(ver, qfe) \
|
|
MAKE_DLLVER_STRUCT(ver, DLLVER_PLATFORM_WINDOWS, qfe)
|
|
|
|
#define DLLVER_NTBINARY(ver, qfe) \
|
|
MAKE_DLLVER_STRUCT(ver, DLLVER_PLATFORM_NT, qfe)
|
|
|
|
#define DLLVER_SINGLEBINARY DLLVER_9xBINARY
|
|
|
|
#ifdef WINNT
|
|
#define DLLVER_DUALBINARY DLLVER_NTBINARY
|
|
#else
|
|
#define DLLVER_DUALBINARY DLLVER_9xBINARY
|
|
#endif
|
|
|
|
STDAPI CCDllGetVersion(struct _DLLVERSIONINFO * pinfo);
|
|
|
|
//
|
|
// Mirroring-Support APIs (astracted in \shell\lib\stock5\rtlmir.cpp)
|
|
//
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern BOOL g_bMirroredOS;
|
|
|
|
void EditBiDiDLGTemplate(LPDLGTEMPLATE pdt, DWORD dwFlags, PWORD pwIgnoreList, int cIgnore);
|
|
#define EBDT_NOMIRROR 0x00000001
|
|
#define EBDT_FLIP 0x00000002
|
|
|
|
#ifdef USE_MIRRORING
|
|
|
|
BOOL IsBiDiLocalizedSystem( void );
|
|
BOOL IsBiDiLocalizedSystemEx( LANGID *pLangID );
|
|
BOOL Mirror_IsEnabledOS( void );
|
|
LANGID Mirror_GetUserDefaultUILanguage( void );
|
|
BOOL Mirror_IsUILanguageInstalled( LANGID langId );
|
|
BOOL CALLBACK Mirror_EnumUILanguagesProc(LPTSTR lpUILanguageString, LONG_PTR lParam);
|
|
BOOL Mirror_IsWindowMirroredRTL( HWND hWnd );
|
|
DWORD Mirror_IsDCMirroredRTL( HDC hdc );
|
|
DWORD Mirror_MirrorDC( HDC hdc );
|
|
BOOL Mirror_MirrorProcessRTL( void );
|
|
DWORD Mirror_GetLayout( HDC hdc );
|
|
DWORD Mirror_SetLayout( HDC hdc , DWORD dwLayout );
|
|
BOOL Mirror_GetProcessDefaultLayout( DWORD *pdwDefaultLayout );
|
|
BOOL Mirror_IsProcessRTL( void );
|
|
extern const DWORD dwNoMirrorBitmap;
|
|
extern const DWORD dwExStyleRTLMirrorWnd;
|
|
extern const DWORD dwExStyleNoInheritLayout;
|
|
extern const DWORD dwPreserveBitmap;
|
|
//
|
|
// 'g_bMirroredOS' is defined in each component which will use the
|
|
// mirroring APIs. I decided to put it here, in order to make sure
|
|
// each component has validated that the OS supports the mirroring
|
|
// APIs before calling them.
|
|
//
|
|
|
|
#define GET_BIDI_LOCALIZED_SYSTEM_LANGID(pLangID) \
|
|
IsBiDiLocalizedSystemEx(pLangID)
|
|
#define IS_BIDI_LOCALIZED_SYSTEM() IsBiDiLocalizedSystem()
|
|
#define IS_MIRRORING_ENABLED() Mirror_IsEnabledOS()
|
|
#define IS_WINDOW_RTL_MIRRORED(hwnd) (g_bMirroredOS && Mirror_IsWindowMirroredRTL(hwnd))
|
|
#define IS_DC_RTL_MIRRORED(hdc) (g_bMirroredOS && Mirror_IsDCMirroredRTL(hdc))
|
|
#define GET_PROCESS_DEF_LAYOUT(pdwl) (g_bMirroredOS && Mirror_GetProcessDefaultLayout(pdwl))
|
|
#define IS_PROCESS_RTL_MIRRORED() (g_bMirroredOS && Mirror_IsProcessRTL())
|
|
#define SET_DC_RTL_MIRRORED(hdc) Mirror_MirrorDC(hdc)
|
|
#define SET_DC_LAYOUT(hdc,dwl) Mirror_SetLayout(hdc,dwl)
|
|
#define SET_PROCESS_RTL_LAYOUT() Mirror_MirrorProcessRTL()
|
|
#define GET_DC_LAYOUT(hdc) Mirror_GetLayout(hdc)
|
|
#define DONTMIRRORBITMAP dwNoMirrorBitmap
|
|
#define RTL_MIRRORED_WINDOW dwExStyleRTLMirrorWnd
|
|
#define RTL_NOINHERITLAYOUT dwExStyleNoInheritLayout
|
|
#define LAYOUT_PRESERVEBITMAP dwPreserveBitmap
|
|
|
|
#else
|
|
|
|
#define GET_BIDI_LOCALIZED_SYSTEM_LANGID(pLangID) \
|
|
FALSE
|
|
#define IS_BIDI_LOCALIZED_SYSTEM() FALSE
|
|
#define IS_MIRRORING_ENABLED() FALSE
|
|
#define IS_WINDOW_RTL_MIRRORED(hwnd) FALSE
|
|
#define IS_DC_RTL_MIRRORED(hdc) FALSE
|
|
#define GET_PROCESS_DEF_LAYOUT(pdwl) FALSE
|
|
#define IS_PROCESS_RTL_MIRRORED() FALSE
|
|
#define SET_DC_RTL_MIRRORED(hdc)
|
|
#define SET_DC_LAYOUT(hdc,dwl)
|
|
#define SET_PROCESS_DEFAULT_LAYOUT()
|
|
#define GET_DC_LAYOUT(hdc) 0L
|
|
|
|
#define DONTMIRRORBITMAP 0L
|
|
#define RTL_MIRRORED_WINDOW 0L
|
|
#define LAYOUT_PRESERVEBITMAP 0L
|
|
#define RTL_NOINHERITLAYOUT 0L
|
|
|
|
#endif // USE_MIRRROING
|
|
|
|
BOOL IsBiDiLocalizedWin95( BOOL bArabicOnly );
|
|
|
|
//------------------------------------------------------------------------
|
|
// Dynamic class array
|
|
//
|
|
typedef struct _DCA * HDCA; // hdca
|
|
|
|
HDCA DCA_Create();
|
|
void DCA_Destroy(HDCA hdca);
|
|
int DCA_GetItemCount(HDCA hdca);
|
|
BOOL DCA_AddItem(HDCA hdca, REFCLSID rclsid);
|
|
const CLSID * DCA_GetItem(HDCA hdca, int i);
|
|
|
|
void DCA_AddItemsFromKeyA(HDCA hdca, HKEY hkey, LPCSTR pszSubKey);
|
|
void DCA_AddItemsFromKeyW(HDCA hdca, HKEY hkey, LPCWSTR pszSubKey);
|
|
|
|
#ifdef UNICODE
|
|
#define DCA_AddItemsFromKey DCA_AddItemsFromKeyW
|
|
#else
|
|
#define DCA_AddItemsFromKey DCA_AddItemsFromKeyA
|
|
#endif
|
|
|
|
STDAPI DCA_CreateInstance(HDCA hdca, int iItem, REFIID riid, void ** ppv);
|
|
|
|
|
|
#ifdef __cplusplus
|
|
};
|
|
#endif
|
|
|
|
#endif // RC_INVOKED
|
|
|
|
//------------------------------------------------------------------------
|
|
// Random helpful functions
|
|
//------------------------------------------------------------------------
|
|
//
|
|
#define EDGE_LEFT 0x00000001
|
|
#define EDGE_RIGHT 0x00000002
|
|
#define EDGE_TOP 0x00000004
|
|
#define EDGE_BOTTOM 0x00000008
|
|
|
|
STDAPI_(DWORD) SHIsButtonObscured(HWND hwnd, PRECT prc, INT_PTR i);
|
|
STDAPI_(void) _SHPrettyMenu(HMENU hm);
|
|
STDAPI_(BOOL) _SHIsMenuSeparator(HMENU hm, int i);
|
|
STDAPI_(BOOL) _SHIsMenuSeparator2(HMENU hm, int i, BOOL *pbIsNamed);
|
|
STDAPI_(BYTE) SHBtnStateFromRestriction(DWORD dwRest, BYTE fsState);
|
|
STDAPI_(BOOL) SHIsDisplayable(LPCWSTR pwszName, BOOL fRunOnFE, BOOL fRunOnNT5);
|
|
|
|
#define SHProcessMessagesUntilEvent(hwnd, hEvent, dwTimeout) SHProcessMessagesUntilEventEx(hwnd, hEvent, dwTimeout, QS_ALLINPUT)
|
|
#define SHProcessSentMessagesUntilEvent(hwnd, hEvent, dwTimeout) SHProcessMessagesUntilEventEx(hwnd, hEvent, dwTimeout, QS_SENDMESSAGE)
|
|
STDAPI_(DWORD) SHProcessMessagesUntilEventEx(HWND hwnd, HANDLE hEvent, DWORD dwTimeout, DWORD dwWakeMask);
|
|
|
|
STDAPI_(BOOL) SetWindowZorder(HWND hwnd, HWND hwndInsertAfter);
|
|
STDAPI_(BOOL) SHForceWindowZorder(HWND hwnd, HWND hwndInsertAfter);
|
|
|
|
STDAPI_(void) EnableOKButtonFromString(HWND hDlg, LPTSTR pszText);
|
|
STDAPI_(void) EnableOKButtonFromID(HWND hDlg, int id);
|
|
|
|
STDAPI_(void) AlphaStripRenderIcon(HDC hdc, int x, int y, HICON hicon, HDC hdcCompatible);
|
|
|
|
STDAPI_(void) SHAdjustLOGFONTA(IN OUT LOGFONTA *plf);
|
|
STDAPI_(void) SHAdjustLOGFONTW(IN OUT LOGFONTW *plf);
|
|
#ifdef UNICODE
|
|
#define SHAdjustLOGFONT SHAdjustLOGFONTW
|
|
#else
|
|
#define SHAdjustLOGFONT SHAdjustLOGFONTA
|
|
#endif
|
|
|
|
STDAPI SHLoadLegacyRegUIStringA(HKEY hk, LPCSTR pszSubkey, LPSTR pszOutBuf, UINT cchOutBuf);
|
|
STDAPI SHLoadLegacyRegUIStringW(HKEY hk, LPCWSTR pszSubkey, LPWSTR pszOutBuf, UINT cchOutBuf);
|
|
#ifdef UNICODE
|
|
#define SHLoadLegacyRegUIString SHLoadLegacyRegUIStringW
|
|
#else
|
|
#define SHLoadLegacyRegUIString SHLoadLegacyRegUIStringA
|
|
#endif
|
|
|
|
// These 2 functions determine whether a registry subkey exists by
|
|
// trying to open and close the key using the KEY_QUERY_VALUE sam.
|
|
STDAPI_(BOOL) SHRegSubKeyExistsA(HKEY hkey, PCSTR pszSubKey); // DO NOT MAKE PUBLIC IN SHLWAPI: use SHRegGetValue() directly
|
|
STDAPI_(BOOL) SHRegSubKeyExistsW(HKEY hkey, PCWSTR pwszSubKey); // DO NOT MAKE PUBLIC IN SHLWAPI: use SHRegGetValue() directly
|
|
STDAPI SHRegGetDWORDA( HKEY hkey, PCSTR pszSubKey, PCSTR pszValue, DWORD *pdwData); // DO NOT MAKE PUBLIC IN SHLWAPI: use SHRegGetValue() directly
|
|
STDAPI SHRegGetDWORDW( HKEY hkey, PCWSTR pwszSubKey, PCWSTR pwszValue, DWORD *pdwData); // DO NOT MAKE PUBLIC IN SHLWAPI: use SHRegGetValue() directly
|
|
STDAPI SHRegGetStringA( HKEY hkey, PCSTR pszSubKey, PCSTR pszValue, PSTR pszData, DWORD cchData); // DO NOT MAKE PUBLIC IN SHLWAPI: use SHRegGetValue() directly
|
|
STDAPI SHRegGetStringW( HKEY hkey, PCWSTR pwszSubKey, PCWSTR pwszValue, PWSTR pwszData, DWORD cchData); // DO NOT MAKE PUBLIC IN SHLWAPI: use SHRegGetValue() directly
|
|
STDAPI SHRegAllocStringA( HKEY hkey, PCSTR pszSubKey, PCSTR pszValue, PSTR * ppszData); // DO NOT MAKE PUBLIC IN SHLWAPI: use SHRegGetValue() directly
|
|
STDAPI SHRegAllocStringW( HKEY hkey, PCWSTR pwszSubKey, PCWSTR pwszValue, PWSTR *ppwszData); // DO NOT MAKE PUBLIC IN SHLWAPI: use SHRegGetValue() directly
|
|
#ifdef UNICODE
|
|
#define SHRegSubKeyExists SHRegSubKeyExistsW
|
|
#define SHRegGetDWORD SHRegGetDWORDW
|
|
#define SHRegGetString SHRegGetStringW
|
|
#define SHRegAllocString SHRegAllocStringW
|
|
#else
|
|
#define SHRegSubKeyExists SHRegSubKeyExistsA
|
|
#define SHRegGetDWORD SHRegGetDWORDA
|
|
#define SHRegGetString SHRegGetStringA
|
|
#define SHRegAllocString SHRegAllocStringA
|
|
#endif
|
|
|
|
|
|
|
|
STDAPI_(CHAR) SHFindMnemonicA(LPCSTR psz);
|
|
STDAPI_(WCHAR) SHFindMnemonicW(LPCWSTR psz);
|
|
#ifdef UNICODE
|
|
#define SHFindMnemonic SHFindMnemonicW
|
|
#else
|
|
#define SHFindMnemonic SHFindMnemonicA
|
|
#endif
|
|
|
|
typedef struct tagINSTALL_INFO
|
|
{
|
|
LPTSTR szSource;
|
|
LPTSTR szDest;
|
|
DWORD dwDestAttrib;
|
|
} INSTALL_INFO;
|
|
|
|
//
|
|
// Special attributes in INSTALL_INFO.dwDestAttrib. We use attributes
|
|
// that we would never otherwise use.
|
|
//
|
|
#define FILE_ATTRIBUTE_INSTALL_NTONLY FILE_ATTRIBUTE_DEVICE
|
|
#define FILE_ATTRIBUTE_INSTALL_9XONLY FILE_ATTRIBUTE_TEMPORARY
|
|
|
|
// superhidden files are attrib'ed +h +s
|
|
#define FILE_ATTRIBUTE_SUPERHIDDEN (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN)
|
|
#define IS_SYSTEM_HIDDEN(dw) ((dw & FILE_ATTRIBUTE_SUPERHIDDEN) == FILE_ATTRIBUTE_SUPERHIDDEN)
|
|
|
|
STDAPI GetInstallInfoFromResource(HINSTANCE hResourceInst, UINT uID, INSTALL_INFO *piiFile);
|
|
STDAPI InstallInfoFreeMembers(INSTALL_INFO *piiFile);
|
|
STDAPI InstallFileFromResource(HINSTANCE hInstResource, INSTALL_INFO *piiFile, LPCTSTR pszDestDir);
|
|
|
|
#ifndef OBJCOMPATFLAGS
|
|
typedef DWORD OBJCOMPATFLAGS;
|
|
#endif
|
|
|
|
STDAPI_(OBJCOMPATFLAGS) SHGetObjectCompatFlagsFromIDList(LPCITEMIDLIST pidl);
|
|
|
|
#define ROUS_DEFAULTALLOW 0x0000
|
|
#define ROUS_DEFAULTRESTRICT 0x0001
|
|
#define ROUS_KEYALLOWS 0x0000
|
|
#define ROUS_KEYRESTRICTS 0x0002
|
|
|
|
STDAPI_(BOOL) IsRestrictedOrUserSettingA(HKEY hkeyRoot, enum RESTRICTIONS rest, LPCSTR pszSubKey, LPCSTR pszValue, UINT flags);
|
|
STDAPI_(BOOL) IsRestrictedOrUserSettingW(HKEY hkeyRoot, enum RESTRICTIONS rest, LPCWSTR pszSubKey, LPCWSTR pszValue, UINT flags);
|
|
STDAPI_(BOOL) GetExplorerUserSettingA(HKEY hkeyRoot, LPCTSTR pszSubKey, LPCTSTR pszValue);
|
|
STDAPI_(BOOL) GetExplorerUserSettingW(HKEY hkeyRoot, LPCTSTR pszSubKey, LPCTSTR pszValue);
|
|
|
|
#ifdef UNICODE
|
|
#define IsRestrictedOrUserSetting IsRestrictedOrUserSettingW
|
|
#define GetExplorerUserSetting GetExplorerUserSettingW
|
|
#else
|
|
#define IsRestrictedOrUserSetting IsRestrictedOrUserSettingA
|
|
#define GetExplorerUserSetting GetExplorerUserSettingA
|
|
#endif
|
|
|
|
//
|
|
// PropertBag helpers
|
|
|
|
STDAPI_(void) SHPropertyBag_ReadStrDef(IPropertyBag* ppb, LPCWSTR pszPropName, LPWSTR psz, int cch, LPCWSTR pszDef);
|
|
STDAPI_(void) SHPropertyBag_ReadIntDef(IPropertyBag* ppb, LPCWSTR pszPropName, int* piResult, int iDef);
|
|
STDAPI_(void) SHPropertyBag_ReadSHORTDef(IPropertyBag* ppb, LPCWSTR pszPropName, SHORT* psh, SHORT shDef);
|
|
STDAPI_(void) SHPropertyBag_ReadLONGDef(IPropertyBag* ppb, LPCWSTR pszPropName, LONG* pl, LONG lDef);
|
|
STDAPI_(void) SHPropertyBag_ReadDWORDDef(IPropertyBag* ppb, LPCWSTR pszPropName, DWORD* pdw, DWORD dwDef);
|
|
STDAPI_(void) SHPropertyBag_ReadBOOLDef(IPropertyBag* ppb, LPCWSTR pszPropName, BOOL* pf, BOOL fDef);
|
|
STDAPI_(void) SHPropertyBag_ReadGUIDDef(IPropertyBag* ppb, LPCWSTR pszPropName, GUID* pguid, const GUID* pguidDef);
|
|
STDAPI_(void) SHPropertyBag_ReadPOINTLDef(IPropertyBag* ppb, LPCWSTR pszPropName, POINTL* ppt, const POINTL* pptDef);
|
|
STDAPI_(void) SHPropertyBag_ReadPOINTSDef(IPropertyBag* ppb, LPCWSTR pszPropName, POINTS* ppt, const POINTS* pptDef);
|
|
STDAPI_(void) SHPropertyBag_ReadRECTLDef(IPropertyBag* ppb, LPCWSTR pszPropName, RECTL* prc, const RECTL* prcDef);
|
|
STDAPI_(BOOL) SHPropertyBag_ReadBOOLDefRet(IPropertyBag* ppb, LPCWSTR pszPropName, BOOL fDef);
|
|
STDAPI SHPropertyBag_ReadStreamScreenRes(IPropertyBag* ppb, LPCWSTR pszPropName, IStream** ppstm);
|
|
STDAPI SHPropertyBag_WriteStreamScreenRes(IPropertyBag* ppb, LPCWSTR pszPropName, IStream* pstm);
|
|
STDAPI SHPropertyBag_ReadPOINTSScreenRes(IPropertyBag* ppb, LPCWSTR pszPropName, POINTS* ppt);
|
|
STDAPI SHPropertyBag_WritePOINTSScreenRes(IPropertyBag* ppb, LPCWSTR pszPropName, const POINTS* ppt);
|
|
STDAPI_(void) SHPropertyBag_ReadDWORDScreenResDef(IPropertyBag* ppb, LPCWSTR pszPropName, DWORD* pdw, DWORD dwDef);
|
|
STDAPI SHPropertyBag_WriteDWORDScreenRes(IPropertyBag* ppb, LPCWSTR pszPropName, DWORD dw);
|
|
STDAPI SHPropertyBag_ReadPOINTLScreenRes(IPropertyBag* ppb, LPCWSTR pszPropName, POINTL* ppt);
|
|
STDAPI SHPropertyBag_WritePOINTLScreenRes(IPropertyBag* ppb, LPCWSTR pszPropName, const POINTL* ppt);
|
|
STDAPI SHPropertyBag_ReadRECTLScreenRes(IPropertyBag* ppb, LPCWSTR pszPropName, RECTL* prc);
|
|
STDAPI SHPropertyBag_WriteRECTLScreenRes(IPropertyBag* ppb, LPCWSTR pszPropName, const RECTL* prc);
|
|
STDAPI SHPropertyBag_DeleteScreenRes(IPropertyBag* ppb, LPCWSTR pszPropName);
|
|
|
|
|
|
#define VS_BAGSTR_EXPLORER L"Shell"
|
|
#define VS_BAGSTR_DESKTOP L"Desktop"
|
|
#define VS_BAGSTR_COMCLG L"ComDlg"
|
|
|
|
#define VS_PROPSTR_MINPOS L"MinPos"
|
|
#define VS_PROPSTR_MAXPOS L"MaxPos"
|
|
#define VS_PROPSTR_POS L"WinPos"
|
|
#define VS_PROPSTR_MODE L"Mode"
|
|
#define VS_PROPSTR_REV L"Rev"
|
|
#define VS_PROPSTR_WPFLAGS L"WFlags"
|
|
#define VS_PROPSTR_SHOW L"ShowCmd"
|
|
#define VS_PROPSTR_FFLAGS L"FFlags"
|
|
#define VS_PROPSTR_HOTKEY L"HotKey"
|
|
#define VS_PROPSTR_BUTTONS L"Buttons"
|
|
#define VS_PROPSTR_STATUS L"Status"
|
|
#define VS_PROPSTR_LINKS L"Links"
|
|
#define VS_PROPSTR_ADDRESS L"Address"
|
|
#define VS_PROPSTR_VID L"Vid"
|
|
#define VS_PROPSTR_SCROLL L"ScrollPos"
|
|
#define VS_PROPSTR_SORT L"Sort"
|
|
#define VS_PROPSTR_SORTDIR L"SortDir"
|
|
#define VS_PROPSTR_COL L"Col"
|
|
#define VS_PROPSTR_COLINFO L"ColInfo"
|
|
#define VS_PROPSTR_ITEMPOS L"ItemPos"
|
|
|
|
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
|
|
////////////////
|
|
//
|
|
// Critical section stuff
|
|
//
|
|
// Helper macros that give nice debug support
|
|
//
|
|
EXTERN_C CRITICAL_SECTION g_csDll;
|
|
#ifdef DEBUG
|
|
EXTERN_C UINT g_CriticalSectionCount;
|
|
EXTERN_C DWORD g_CriticalSectionOwner;
|
|
EXTERN_C void Dll_EnterCriticalSection(CRITICAL_SECTION*);
|
|
EXTERN_C void Dll_LeaveCriticalSection(CRITICAL_SECTION*);
|
|
#if defined(__cplusplus) && defined(AssertMsg)
|
|
class DEBUGCRITICAL {
|
|
protected:
|
|
BOOL fClosed;
|
|
public:
|
|
DEBUGCRITICAL() {fClosed = FALSE;};
|
|
void Leave() {fClosed = TRUE;};
|
|
~DEBUGCRITICAL()
|
|
{
|
|
AssertMsg(fClosed, TEXT("you left scope while holding the critical section"));
|
|
}
|
|
};
|
|
#define ENTERCRITICAL DEBUGCRITICAL debug_crit; Dll_EnterCriticalSection(&g_csDll)
|
|
#define LEAVECRITICAL debug_crit.Leave(); Dll_LeaveCriticalSection(&g_csDll)
|
|
#define ENTERCRITICALNOASSERT Dll_EnterCriticalSection(&g_csDll)
|
|
#define LEAVECRITICALNOASSERT Dll_LeaveCriticalSection(&g_csDll)
|
|
#else // __cplusplus
|
|
#define ENTERCRITICAL Dll_EnterCriticalSection(&g_csDll)
|
|
#define LEAVECRITICAL Dll_LeaveCriticalSection(&g_csDll)
|
|
#define ENTERCRITICALNOASSERT Dll_EnterCriticalSection(&g_csDll)
|
|
#define LEAVECRITICALNOASSERT Dll_LeaveCriticalSection(&g_csDll)
|
|
#endif // __cplusplus
|
|
#define ASSERTCRITICAL ASSERT(g_CriticalSectionCount > 0 && GetCurrentThreadId() == g_CriticalSectionOwner)
|
|
#define ASSERTNONCRITICAL ASSERT(GetCurrentThreadId() != g_CriticalSectionOwner)
|
|
#else // DEBUG
|
|
#define ENTERCRITICAL EnterCriticalSection(&g_csDll)
|
|
#define LEAVECRITICAL LeaveCriticalSection(&g_csDll)
|
|
#define ENTERCRITICALNOASSERT EnterCriticalSection(&g_csDll)
|
|
#define LEAVECRITICALNOASSERT LeaveCriticalSection(&g_csDll)
|
|
#define ASSERTCRITICAL
|
|
#define ASSERTNONCRITICAL
|
|
#endif // DEBUG
|
|
|
|
////////////////
|
|
//
|
|
// computer display name support
|
|
//
|
|
// Display name: A formatted name that NetFldr uses. It is currently constructed out of the computer name,
|
|
// and, if available, the computer comment (description).
|
|
// DSheldon
|
|
STDAPI SHBuildDisplayMachineName(LPCWSTR pszMachineName, LPCWSTR pszComment, LPWSTR pszDisplayName, DWORD cchDisplayName);
|
|
STDAPI CreateFromRegKey(LPCWSTR pszKey, LPCWSTR pszValue, REFIID riid, void **ppv);
|
|
|
|
STDAPI_(LPCTSTR) SkipServerSlashes(LPCTSTR pszName);
|
|
|
|
//
|
|
// A couple of inline functions that create an HRESULT from
|
|
// a Win32 error code without the double-evaluation side effect of
|
|
// the HRESULT_FROM_WIN32 macro.
|
|
//
|
|
// Use ResultFromWin32 in place of HRESULT_FROM_WIN32 if
|
|
// the side effects of that macro are unwanted.
|
|
// ResultFromLastError was created as a convenience for a
|
|
// common idiom.
|
|
// You could simply call ResultFromWin32(GetLastError()) yourself.
|
|
//
|
|
__inline HRESULT ResultFromWin32(DWORD dwErr)
|
|
{
|
|
return HRESULT_FROM_WIN32(dwErr);
|
|
}
|
|
|
|
__inline HRESULT ResultFromLastError(void)
|
|
{
|
|
return ResultFromWin32(GetLastError());
|
|
}
|
|
|
|
STDAPI_(void) IEPlaySound(LPCTSTR pszSound, BOOL fSysSound);
|
|
|
|
STDAPI IUnknown_DragEnter(IUnknown* punk, IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
|
|
STDAPI IUnknown_DragOver(IUnknown* punk, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
|
|
STDAPI IUnknown_DragLeave(IUnknown* punk);
|
|
STDAPI IUnknown_Drop(IUnknown* punk, IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
|
|
|
|
STDAPI_(BOOL) IsTypeInList(LPCTSTR pszType, const LPCTSTR *arszList, UINT cList);
|
|
|
|
//----------------------------------------------------------------------
|
|
// Msg: WM_MSIME_MODEBIAS
|
|
// Desc: input mode bias
|
|
// Owner: YutakaN
|
|
// Usage: SendMessage( hwndDefUI, WM_MSIME_MODEBIAS, MODEBIAS_xxxx, MODEBIASMODE_xxxx );
|
|
// wParam: operation of bias
|
|
// lParam: bias mode
|
|
// return: If wParam is MODEBIAS_GETVERSION,returns version number of interface.
|
|
// If wParam is MODEBIAS_SETVALUE : return non-zero value if succeeded. Returns 0 if fail.
|
|
// If wParam is MODEBIAS_GETVALUE : returns current bias mode.
|
|
|
|
// Label for RegisterWindowMessage
|
|
#define RWM_MODEBIAS TEXT("MSIMEModeBias")
|
|
|
|
// Current version
|
|
#define VERSION_MODEBIAS 1
|
|
|
|
// Set or Get (wParam)
|
|
#define MODEBIAS_GETVERSION 0
|
|
#define MODEBIAS_SETVALUE 1
|
|
#define MODEBIAS_GETVALUE 2
|
|
|
|
// Bias (lParam)
|
|
#define MODEBIASMODE_DEFAULT 0x00000000 // reset all of bias setting
|
|
#define MODEBIASMODE_FILENAME 0x00000001 // filename
|
|
#define MODEBIASMODE_READING 0x00000002 // reading recommended
|
|
#define MODEBIASMODE_DIGIT 0x00000004 // ANSI-Digit Recommended Mode
|
|
#define MODEBIASMODE_URLHISTORY 0x00010000 // URL history
|
|
|
|
STDAPI_(void) SetModeBias(DWORD dwMode);
|
|
|
|
|
|
|
|
#endif // __CCSTOCK_H__
|