shlwapi_undoc.h File Reference

#include <winreg.h>

Include dependency graph for shlwapi_undoc.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	tagPOLICYDATA

Macros
#define	ASSOCQUERY_LOWORD_MASK   0x0000FFFF
#define	ASSOCQUERY_STRING   0x00010000
#define	ASSOCQUERY_EXISTS   0x00020000
#define	ASSOCQUERY_DIRECT   0x00040000
#define	ASSOCQUERY_DWORD   0x00080000
#define	ASSOCQUERY_INDIRECT   0x00100000
#define	ASSOCQUERY_OBJECT   0x00200000
#define	ASSOCQUERY_GUID   0x00400000
#define	ASSOCQUERY_EXTRA_NON_VERB   0x01000000
#define	ASSOCQUERY_EXTRA_VERB   0x02000000
#define	ASSOCQUERY_SIGNIFICANCE   0x04000000
#define	ASSOCQUERY_FALLBACK   0x80000000
#define	SHELL_NO_POLICY   ((DWORD)-1)
#define	SHELL_GCOUNTER_DEFINE_GUID(name, a, b, c, d, e, f, g, h, i, j, k)   const GUID name = { a, b, c, { d, e, f, g, h, i, j, k } }
#define	SHELL_GCOUNTER_DEFINE_HANDLE(name)   HANDLE name = NULL
#define	SHELL_GCOUNTER_PARAMETERS(handle, id)   handle
#define	SHELL_GlobalCounterCreate(refguid, handle)
#define	SHELL_GlobalCounterIsInitialized(handle)   ( (handle) != NULL )
#define	SHELL_GlobalCounterGet(handle)   SHGlobalCounterGetValue(handle)
#define	SHELL_GlobalCounterIncrement(handle)   SHGlobalCounterIncrement(handle)
#define	SHELL_GCOUNTER_DECLAREPARAMETERS(handle, id)   SHELL_GCOUNTER_PARAMETERS(HANDLE handle, SHGLOBALCOUNTER id)
#define	SHAboutInfo   SHAboutInfoA
#define	SHExpandEnvironmentStrings   SHExpandEnvironmentStringsA
#define	SHCreateWorkerWindow   SHCreateWorkerWindowA
#define	SHGetValueGoodBoot   SHGetValueGoodBootA
#define	SHLoadRegUIString   SHLoadRegUIStringA
#define	WHICH_PIF   (1 << 0)
#define	WHICH_COM   (1 << 1)
#define	WHICH_EXE   (1 << 2)
#define	WHICH_BAT   (1 << 3)
#define	WHICH_LNK   (1 << 4)
#define	WHICH_CMD   (1 << 5)
#define	WHICH_OPTIONAL   (1 << 6)
#define	WHICH_DEFAULT   (WHICH_PIF | WHICH_COM | WHICH_EXE | WHICH_BAT | WHICH_LNK | WHICH_CMD)
#define	PATH_CHAR_CLASS_LETTER   0x00000001
#define	PATH_CHAR_CLASS_ASTERIX   0x00000002
#define	PATH_CHAR_CLASS_DOT   0x00000004
#define	PATH_CHAR_CLASS_BACKSLASH   0x00000008
#define	PATH_CHAR_CLASS_COLON   0x00000010
#define	PATH_CHAR_CLASS_SEMICOLON   0x00000020
#define	PATH_CHAR_CLASS_COMMA   0x00000040
#define	PATH_CHAR_CLASS_SPACE   0x00000080
#define	PATH_CHAR_CLASS_OTHER_VALID   0x00000100
#define	PATH_CHAR_CLASS_DOUBLEQUOTE   0x00000200
#define	PATH_CHAR_CLASS_INVALID   0x00000000
#define	PATH_CHAR_CLASS_ANY   0xffffffff
#define	SHACF_WIN95SHLEXEC   0x00000200 /* Geoff Chappell */
#define	INTERFACE   IAssociationElementOld

Typedefs
typedef DWORD	ASSOCQUERY
typedef struct tagPOLICYDATA	POLICYDATA
typedef struct tagPOLICYDATA *	LPPOLICYDATA

Enumerations
enum	_shellkey_flags {   SHKEY_Root_HKCU = 0x1 , SHKEY_Root_HKLM = 0x2 , SHKEY_Key_Explorer = 0x00 , SHKEY_Key_Shell = 0x10 ,   SHKEY_Key_ShellNoRoam = 0x20 , SHKEY_Key_Classes = 0x30 , SHKEY_Subkey_Default = 0x0000 , SHKEY_Subkey_ResourceName = 0x1000 ,   SHKEY_Subkey_Handlers = 0x2000 , SHKEY_Subkey_Associations = 0x3000 , SHKEY_Subkey_Volatile = 0x4000 , SHKEY_Subkey_MUICache = 0x5000 ,   SHKEY_Subkey_FileExts = 0x6000 , SHKEY_Root_HKCU = 0x1 , SHKEY_Root_HKLM = 0x2 , SHKEY_Key_Explorer = 0x00 ,   SHKEY_Key_Shell = 0x10 , SHKEY_Key_ShellNoRoam = 0x20 , SHKEY_Key_Classes = 0x30 , SHKEY_Subkey_Default = 0x0000 ,   SHKEY_Subkey_ResourceName = 0x1000 , SHKEY_Subkey_Handlers = 0x2000 , SHKEY_Subkey_Associations = 0x3000 , SHKEY_Subkey_Volatile = 0x4000 ,   SHKEY_Subkey_MUICache = 0x5000 , SHKEY_Subkey_FileExts = 0x6000 }

Functions
HANDLE WINAPI	SHGlobalCounterCreate (REFGUID guid)
PVOID WINAPI	SHInterlockedCompareExchange (PVOID *dest, PVOID xchg, PVOID compare)
LONG WINAPI	SHGlobalCounterGetValue (HANDLE hGlobalCounter)
LONG WINAPI	SHGlobalCounterIncrement (HANDLE hGlobalCounter)
DWORD WINAPI	SHRestrictionLookup (_In_ DWORD policy, _In_ LPCWSTR key, _In_ const POLICYDATA *polTable, _Inout_ LPDWORD polArr)
BOOL WINAPI	SHAboutInfoA (LPSTR lpszDest, DWORD dwDestLen)
BOOL WINAPI	SHAboutInfoW (LPWSTR lpszDest, DWORD dwDestLen)
HMODULE WINAPI	SHPinDllOfCLSID (REFIID refiid)
HRESULT WINAPI	IUnknown_QueryStatus (IUnknown *lpUnknown, REFGUID pguidCmdGroup, ULONG cCmds, OLECMD *prgCmds, OLECMDTEXT *pCmdText)
HRESULT WINAPI	IUnknown_Exec (IUnknown *lpUnknown, REFGUID pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
LONG WINAPI	SHSetWindowBits (HWND hwnd, INT offset, UINT wMask, UINT wFlags)
HWND WINAPI	SHSetParentHwnd (HWND hWnd, HWND hWndParent)
HRESULT WINAPI	ConnectToConnectionPoint (IUnknown *lpUnkSink, REFIID riid, BOOL bAdviseOnly, IUnknown *lpUnknown, LPDWORD lpCookie, IConnectionPoint **lppCP)
BOOL WINAPI	SHIsSameObject (IUnknown *lpInt1, IUnknown *lpInt2)
BOOL WINAPI	SHLoadMenuPopup (HINSTANCE hInst, LPCWSTR szName)
void WINAPI	SHPropagateMessage (HWND hWnd, UINT uiMsgId, WPARAM wParam, LPARAM lParam, BOOL bSend)
DWORD WINAPI	SHRemoveAllSubMenus (HMENU hMenu)
UINT WINAPI	SHEnableMenuItem (HMENU hMenu, UINT wItemID, BOOL bEnable)
DWORD WINAPI	SHCheckMenuItem (HMENU hMenu, UINT uID, BOOL bCheck)
DWORD WINAPI	SHRegisterClassA (WNDCLASSA *wndclass)
BOOL WINAPI	SHSimulateDrop (IDropTarget *pDrop, IDataObject *pDataObj, DWORD grfKeyState, PPOINTL lpPt, DWORD *pdwEffect)
DWORD WINAPI	SHGetCurColorRes (void)
HMENU WINAPI	SHGetMenuFromID (HMENU hMenu, UINT uID)
DWORD WINAPI	SHMenuIndexFromID (HMENU hMenu, UINT uID)
DWORD WINAPI	SHWaitForSendMessageThread (HANDLE hand, DWORD dwTimeout)
DWORD WINAPI	SHSendMessageBroadcastW (UINT uMsg, WPARAM wParam, LPARAM lParam)
HRESULT WINAPI	SHIsExpandableFolder (LPSHELLFOLDER lpFolder, LPCITEMIDLIST pidl)
DWORD WINAPI	SHFillRectClr (HDC hDC, LPCRECT pRect, COLORREF cRef)
int WINAPI	SHSearchMapInt (const int *lpKeys, const int *lpValues, int iLen, int iKey)
VOID WINAPI	IUnknown_Set (IUnknown **lppDest, IUnknown *lpUnknown)
HRESULT WINAPI	MayQSForward (IUnknown *lpUnknown, PVOID lpReserved, REFGUID riidCmdGrp, ULONG cCmds, OLECMD *prgCmds, OLECMDTEXT *pCmdText)
HRESULT WINAPI	MayExecForward (IUnknown *lpUnknown, INT iUnk, REFGUID pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
HRESULT WINAPI	IsQSForward (REFGUID pguidCmdGroup, ULONG cCmds, OLECMD *prgCmds)
BOOL WINAPI	SHIsChildOrSelf (HWND hParent, HWND hChild)
HRESULT WINAPI	SHForwardContextMenuMsg (IUnknown *pUnk, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *pResult, BOOL useIContextMenu2)
VOID WINAPI	SHSetDefaultDialogFont (HWND hWnd, INT id)
EXTERN_C BOOL WINAPI	SHBoolSystemParametersInfo (UINT uiAction, PVOID pvParam)
HRESULT WINAPI	SHRegGetCLSIDKeyW (REFGUID guid, LPCWSTR lpszValue, BOOL bUseHKCU, BOOL bCreate, PHKEY phKey)
BOOL WINAPI	SHAddDataBlock (LPDBLIST *lppList, const DATABLOCK_HEADER *lpNewItem)
BOOL WINAPI	SHRemoveDataBlock (LPDBLIST *lppList, DWORD dwSignature)
DATABLOCK_HEADER *WINAPI	SHFindDataBlock (LPDBLIST lpList, DWORD dwSignature)
HRESULT WINAPI	SHWriteDataBlockList (IStream *lpStream, LPDBLIST lpList)
HRESULT WINAPI	SHReadDataBlockList (IStream *lpStream, LPDBLIST *lppList)
VOID WINAPI	SHFreeDataBlockList (LPDBLIST lpList)
LONG WINAPI	RegCreateKeyExWrapW (_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
DWORD WINAPI	SHExpandEnvironmentStringsA (LPCSTR, LPSTR, DWORD)
DWORD WINAPI	SHExpandEnvironmentStringsW (LPCWSTR, LPWSTR, DWORD)
BOOL WINAPI	SHIsEmptyStream (IStream *)
HRESULT WINAPI	IStream_Size (IStream *lpStream, ULARGE_INTEGER *lpulSize)
HRESULT WINAPI	SHInvokeDefaultCommand (HWND, IShellFolder *, LPCITEMIDLIST)
HRESULT WINAPI	SHPropertyBag_ReadType (IPropertyBag *ppb, LPCWSTR pszPropName, VARIANTARG *pvarg, VARTYPE vt)
HRESULT WINAPI	SHPropertyBag_ReadBOOL (IPropertyBag *ppb, LPCWSTR pszPropName, BOOL *pbValue)
BOOL WINAPI	SHPropertyBag_ReadBOOLOld (IPropertyBag *ppb, LPCWSTR pszPropName, BOOL bDefValue)
HRESULT WINAPI	SHPropertyBag_ReadSHORT (IPropertyBag *ppb, LPCWSTR pszPropName, SHORT *psValue)
HRESULT WINAPI	SHPropertyBag_ReadInt (IPropertyBag *ppb, LPCWSTR pszPropName, LPINT pnValue)
HRESULT WINAPI	SHPropertyBag_ReadLONG (IPropertyBag *ppb, LPCWSTR pszPropName, LPLONG pValue)
HRESULT WINAPI	SHPropertyBag_ReadDWORD (IPropertyBag *ppb, LPCWSTR pszPropName, DWORD *pdwValue)
HRESULT WINAPI	SHPropertyBag_ReadBSTR (IPropertyBag *ppb, LPCWSTR pszPropName, BSTR *pbstr)
HRESULT WINAPI	SHPropertyBag_ReadStr (IPropertyBag *ppb, LPCWSTR pszPropName, LPWSTR pszDst, int cchMax)
HRESULT WINAPI	SHPropertyBag_ReadPOINTL (IPropertyBag *ppb, LPCWSTR pszPropName, POINTL *pptl)
HRESULT WINAPI	SHPropertyBag_ReadPOINTS (IPropertyBag *ppb, LPCWSTR pszPropName, POINTS *ppts)
HRESULT WINAPI	SHPropertyBag_ReadRECTL (IPropertyBag *ppb, LPCWSTR pszPropName, RECTL *prcl)
HRESULT WINAPI	SHPropertyBag_ReadGUID (IPropertyBag *ppb, LPCWSTR pszPropName, GUID *pguid)
HRESULT WINAPI	SHPropertyBag_ReadStream (IPropertyBag *ppb, LPCWSTR pszPropName, IStream **ppStream)
INT WINAPI	SHGetPerScreenResName (_Out_writes_(cchBuffer) LPWSTR pszBuffer, _In_ INT cchBuffer, _In_ DWORD dwReserved)
HRESULT WINAPI	SHPropertyBag_Delete (IPropertyBag *ppb, LPCWSTR pszPropName)
HRESULT WINAPI	SHPropertyBag_WriteBOOL (IPropertyBag *ppb, LPCWSTR pszPropName, BOOL bValue)
HRESULT WINAPI	SHPropertyBag_WriteSHORT (IPropertyBag *ppb, LPCWSTR pszPropName, SHORT sValue)
HRESULT WINAPI	SHPropertyBag_WriteInt (IPropertyBag *ppb, LPCWSTR pszPropName, INT nValue)
HRESULT WINAPI	SHPropertyBag_WriteLONG (IPropertyBag *ppb, LPCWSTR pszPropName, LONG lValue)
HRESULT WINAPI	SHPropertyBag_WriteDWORD (IPropertyBag *ppb, LPCWSTR pszPropName, DWORD dwValue)
HRESULT WINAPI	SHPropertyBag_WriteStr (IPropertyBag *ppb, LPCWSTR pszPropName, LPCWSTR pszValue)
HRESULT WINAPI	SHPropertyBag_WriteGUID (IPropertyBag *ppb, LPCWSTR pszPropName, const GUID *pguid)
HRESULT WINAPI	SHPropertyBag_WriteStream (IPropertyBag *ppb, LPCWSTR pszPropName, IStream *pStream)
HRESULT WINAPI	SHPropertyBag_WritePOINTL (IPropertyBag *ppb, LPCWSTR pszPropName, const POINTL *pptl)
HRESULT WINAPI	SHPropertyBag_WritePOINTS (IPropertyBag *ppb, LPCWSTR pszPropName, const POINTS *ppts)
HRESULT WINAPI	SHPropertyBag_WriteRECTL (IPropertyBag *ppb, LPCWSTR pszPropName, const RECTL *prcl)
HRESULT WINAPI	SHCreatePropertyBagOnMemory (_In_ DWORD dwMode, _In_ REFIID riid, _Out_ void **ppvObj)
HRESULT WINAPI	SHCreatePropertyBagOnRegKey (_In_ HKEY hKey, _In_z_ LPCWSTR pszSubKey, _In_ DWORD dwMode, _In_ REFIID riid, _Out_ void **ppvObj)
HRESULT WINAPI	SHCreatePropertyBagOnProfileSection (_In_z_ LPCWSTR lpFileName, _In_opt_z_ LPCWSTR pszSection, _In_ DWORD dwMode, _In_ REFIID riid, _Out_ void **ppvObj)
EXTERN_C HRESULT WINAPI	IUnknown_QueryServicePropertyBag (_In_ IUnknown *punk, _In_ long flags, _In_ REFIID riid, _Outptr_ void **ppvObj)
HWND WINAPI	SHCreateWorkerWindowA (WNDPROC wndProc, HWND hWndParent, DWORD dwExStyle, DWORD dwStyle, HMENU hMenu, LONG_PTR wnd_extra)
HWND WINAPI	SHCreateWorkerWindowW (WNDPROC wndProc, HWND hWndParent, DWORD dwExStyle, DWORD dwStyle, HMENU hMenu, LONG_PTR wnd_extra)
HRESULT WINAPI	IUnknown_SetOwner (IUnknown *iface, IUnknown *pUnk)
HRESULT WINAPI	IUnknown_GetClassID (IUnknown *lpUnknown, CLSID *lpClassId)
HRESULT WINAPI	IUnknown_QueryServiceExec (IUnknown *lpUnknown, REFIID service, const GUID *group, DWORD cmdId, DWORD cmdOpt, VARIANT *pIn, VARIANT *pOut)
HRESULT WINAPI	IUnknown_UIActivateIO (IUnknown *unknown, BOOL activate, LPMSG msg)
HRESULT WINAPI	IUnknown_TranslateAcceleratorOCS (IUnknown *lpUnknown, LPMSG lpMsg, DWORD dwModifiers)
HRESULT WINAPI	IUnknown_OnFocusOCS (IUnknown *lpUnknown, BOOL fGotFocus)
HRESULT WINAPI	IUnknown_HandleIRestrict (LPUNKNOWN lpUnknown, PVOID lpArg1, PVOID lpArg2, PVOID lpArg3, PVOID lpArg4)
HRESULT WINAPI	IUnknown_HasFocusIO (IUnknown *punk)
HRESULT WINAPI	IUnknown_TranslateAcceleratorIO (IUnknown *punk, MSG *pmsg)
HRESULT WINAPI	IUnknown_OnFocusChangeIS (LPUNKNOWN lpUnknown, LPUNKNOWN pFocusObject, BOOL bFocus)
DWORD WINAPI	SHAnsiToUnicode (LPCSTR lpSrcStr, LPWSTR lpDstStr, INT iLen)
INT WINAPI	SHUnicodeToAnsi (LPCWSTR lpSrcStr, LPSTR lpDstStr, INT iLen)
DWORD WINAPI	SHAnsiToUnicodeCP (DWORD dwCp, LPCSTR lpSrcStr, LPWSTR lpDstStr, int iLen)
DWORD WINAPI	SHUnicodeToAnsiCP (UINT CodePage, LPCWSTR lpSrcStr, LPSTR lpDstStr, int dstlen)
PVOID WINAPI	SHLockSharedEx (HANDLE hData, DWORD dwProcessId, BOOL bWriteAccess)
DWORD WINAPI	SHGetValueGoodBootA (HKEY hkey, LPCSTR pSubKey, LPCSTR pValue, LPDWORD pwType, LPVOID pvData, LPDWORD pbData)
DWORD WINAPI	SHGetValueGoodBootW (HKEY hkey, LPCWSTR pSubKey, LPCWSTR pValue, LPDWORD pwType, LPVOID pvData, LPDWORD pbData)
HRESULT WINAPI	SHLoadRegUIStringA (HKEY hkey, LPCSTR value, LPSTR buf, DWORD size)
HRESULT WINAPI	SHLoadRegUIStringW (HKEY hkey, LPCWSTR value, LPWSTR buf, DWORD size)
DWORD WINAPI	SHGetIniStringW (_In_z_ LPCWSTR appName, _In_z_ LPCWSTR keyName, _Out_writes_to_(outLen, return+1) LPWSTR out, _In_ DWORD outLen, _In_z_ LPCWSTR filename)
BOOL WINAPI	SHSetIniStringW (_In_z_ LPCWSTR appName, _In_z_ LPCWSTR keyName, _In_opt_z_ LPCWSTR str, _In_z_ LPCWSTR filename)
DWORD WINAPI	SHGetIniStringUTF7W (_In_opt_z_ LPCWSTR lpAppName, _In_z_ LPCWSTR lpKeyName, _Out_writes_to_(nSize, return+1) _Post_z_ LPWSTR lpReturnedString, _In_ DWORD nSize, _In_z_ LPCWSTR lpFileName)
BOOL WINAPI	SHSetIniStringUTF7W (_In_z_ LPCWSTR lpAppName, _In_z_ LPCWSTR lpKeyName, _In_opt_z_ LPCWSTR lpString, _In_z_ LPCWSTR lpFileName)
HKEY WINAPI	SHGetShellKey (DWORD flags, LPCWSTR sub_key, BOOL create)
int WINAPIV	ShellMessageBoxWrapW (_In_opt_ HINSTANCE hAppInst, _In_opt_ HWND hWnd, _In_ LPCWSTR lpcText, _In_opt_ LPCWSTR lpcTitle, _In_ UINT fuStyle,...)
BOOL WINAPI	PathFileExistsDefExtW (LPWSTR lpszPath, DWORD dwWhich)
BOOL WINAPI	PathFileExistsDefExtAndAttributesW (_Inout_ LPWSTR pszPath, _In_ DWORD dwWhich, _Out_opt_ LPDWORD pdwFileAttributes)
BOOL WINAPI	PathFindOnPathExW (LPWSTR lpszFile, LPCWSTR *lppszOtherDirs, DWORD dwWhich)
VOID WINAPI	FixSlashesAndColonW (LPWSTR)
BOOL WINAPI	PathIsValidCharA (char c, DWORD dwClass)
BOOL WINAPI	PathIsValidCharW (WCHAR c, DWORD dwClass)
BOOL WINAPI	SHGetPathFromIDListWrapW (LPCITEMIDLIST pidl, LPWSTR pszPath)
BOOL WINAPI	IContextMenu_Invoke (_In_ IContextMenu *pContextMenu, _In_ HWND hwnd, _In_ LPCSTR lpVerb, _In_ UINT uFlags)
HRESULT WINAPI	RunRegCommand (_In_opt_ HWND hWnd, _In_ HKEY hKey, _In_opt_ PCWSTR pszSubKey)
HRESULT WINAPI	RunIndirectRegCommand (_In_opt_ HWND hWnd, _In_ HKEY hKey, _In_opt_ PCWSTR pszSubKey, _In_ PCWSTR pszVerb)
HRESULT WINAPI	SHRunIndirectRegClientCommand (_In_ HWND hWnd, _In_ PCWSTR pszClientType)
DWORD WINAPI	SHGetObjectCompatFlags (IUnknown *pUnk, const CLSID *clsid)
DWORD WINAPI	SHGetAppCompatFlags (DWORD dwMask)
	STDMETHOD_ (ULONG, AddRef)(THIS) PURE
	STDMETHOD_ (ULONG, Release)(THIS) PURE
STDMETHOD()	QueryString (THIS_ ASSOCQUERY query, PCWSTR key, PWSTR *ppszValue) PURE
STDMETHOD()	QueryDword (THIS_ ASSOCQUERY query, PCWSTR key, DWORD *pdwValue) PURE
STDMETHOD()	QueryExists (THIS_ ASSOCQUERY query, PCWSTR key) PURE
STDMETHOD()	QueryDirect (THIS_ ASSOCQUERY query, PCWSTR key, FLAGGED_BYTE_BLOB **ppBlob) PURE
STDMETHOD()	QueryObject (THIS_ ASSOCQUERY query, PCWSTR key, REFIID riid, PVOID *ppvObj) PURE

Macro Definition Documentation

ASSOCQUERY_DIRECT

#define ASSOCQUERY_DIRECT   0x00040000

Definition at line 27 of file shlwapi_undoc.h.

ASSOCQUERY_DWORD

#define ASSOCQUERY_DWORD   0x00080000

Definition at line 28 of file shlwapi_undoc.h.

ASSOCQUERY_EXISTS

#define ASSOCQUERY_EXISTS   0x00020000

Definition at line 26 of file shlwapi_undoc.h.

ASSOCQUERY_EXTRA_NON_VERB

#define ASSOCQUERY_EXTRA_NON_VERB   0x01000000

Definition at line 32 of file shlwapi_undoc.h.

ASSOCQUERY_EXTRA_VERB

#define ASSOCQUERY_EXTRA_VERB   0x02000000

Definition at line 33 of file shlwapi_undoc.h.

ASSOCQUERY_FALLBACK

#define ASSOCQUERY_FALLBACK   0x80000000

Definition at line 35 of file shlwapi_undoc.h.

ASSOCQUERY_GUID

#define ASSOCQUERY_GUID   0x00400000

Definition at line 31 of file shlwapi_undoc.h.

ASSOCQUERY_INDIRECT

#define ASSOCQUERY_INDIRECT   0x00100000

Definition at line 29 of file shlwapi_undoc.h.

ASSOCQUERY_LOWORD_MASK

#define ASSOCQUERY_LOWORD_MASK   0x0000FFFF

Definition at line 24 of file shlwapi_undoc.h.

ASSOCQUERY_OBJECT

#define ASSOCQUERY_OBJECT   0x00200000

Definition at line 30 of file shlwapi_undoc.h.

ASSOCQUERY_SIGNIFICANCE

#define ASSOCQUERY_SIGNIFICANCE   0x04000000

Definition at line 34 of file shlwapi_undoc.h.

ASSOCQUERY_STRING

#define ASSOCQUERY_STRING   0x00010000

Definition at line 25 of file shlwapi_undoc.h.

INTERFACE

#define INTERFACE   IAssociationElementOld

Definition at line 390 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_ANY

#define PATH_CHAR_CLASS_ANY   0xffffffff

Definition at line 352 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_ASTERIX

#define PATH_CHAR_CLASS_ASTERIX   0x00000002

Definition at line 342 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_BACKSLASH

#define PATH_CHAR_CLASS_BACKSLASH   0x00000008

Definition at line 344 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_COLON

#define PATH_CHAR_CLASS_COLON   0x00000010

Definition at line 345 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_COMMA

#define PATH_CHAR_CLASS_COMMA   0x00000040

Definition at line 347 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_DOT

#define PATH_CHAR_CLASS_DOT   0x00000004

Definition at line 343 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_DOUBLEQUOTE

#define PATH_CHAR_CLASS_DOUBLEQUOTE   0x00000200

Definition at line 350 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_INVALID

#define PATH_CHAR_CLASS_INVALID   0x00000000

Definition at line 351 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_LETTER

#define PATH_CHAR_CLASS_LETTER   0x00000001

Definition at line 341 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_OTHER_VALID

#define PATH_CHAR_CLASS_OTHER_VALID   0x00000100

Definition at line 349 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_SEMICOLON

#define PATH_CHAR_CLASS_SEMICOLON   0x00000020

Definition at line 346 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_SPACE

#define PATH_CHAR_CLASS_SPACE   0x00000080

Definition at line 348 of file shlwapi_undoc.h.

SHAboutInfo

#define SHAboutInfo   SHAboutInfoA

Definition at line 86 of file shlwapi_undoc.h.

SHACF_WIN95SHLEXEC

#define SHACF_WIN95SHLEXEC   0x00000200 /* Geoff Chappell */

Definition at line 381 of file shlwapi_undoc.h.

SHCreateWorkerWindow

#define SHCreateWorkerWindow   SHCreateWorkerWindowA

Definition at line 233 of file shlwapi_undoc.h.

SHELL_GCOUNTER_DECLAREPARAMETERS

#define SHELL_GCOUNTER_DECLAREPARAMETERS	(		handle,
			id
	)		SHELL_GCOUNTER_PARAMETERS(HANDLE handle, SHGLOBALCOUNTER id)

Definition at line 72 of file shlwapi_undoc.h.

SHELL_GCOUNTER_DEFINE_GUID

#define SHELL_GCOUNTER_DEFINE_GUID	(		name,
			a,
			b,
			c,
			d,
			e,
			f,
			g,
			h,
			i,
			j,
			k
	)		const GUID name = { a, b, c, { d, e, f, g, h, i, j, k } }

Definition at line 60 of file shlwapi_undoc.h.

SHELL_GCOUNTER_DEFINE_HANDLE

#define SHELL_GCOUNTER_DEFINE_HANDLE

(

name

)

HANDLE name = NULL

Definition at line 61 of file shlwapi_undoc.h.

SHELL_GCOUNTER_PARAMETERS

#define SHELL_GCOUNTER_PARAMETERS	(		handle,
			id
	)		handle

Definition at line 62 of file shlwapi_undoc.h.

SHELL_GlobalCounterCreate

#define SHELL_GlobalCounterCreate	(		refguid,
			handle
	)

Value:

  do { \
    EXTERN_C HANDLE SHELL_GetCachedGlobalCounter(HANDLE *phGlobalCounter, REFGUID rguid); \
    SHELL_GetCachedGlobalCounter(&(handle), (refguid)); \
  } while (0)

Definition at line 63 of file shlwapi_undoc.h.

SHELL_GlobalCounterGet

#define SHELL_GlobalCounterGet

(

handle

)

SHGlobalCounterGetValue(handle)

Definition at line 69 of file shlwapi_undoc.h.

SHELL_GlobalCounterIncrement

#define SHELL_GlobalCounterIncrement

(

handle

)

SHGlobalCounterIncrement(handle)

Definition at line 70 of file shlwapi_undoc.h.

SHELL_GlobalCounterIsInitialized

#define SHELL_GlobalCounterIsInitialized

(

handle

)

( (handle) != NULL )

Definition at line 68 of file shlwapi_undoc.h.

SHELL_NO_POLICY

#define SHELL_NO_POLICY   ((DWORD)-1)

Definition at line 37 of file shlwapi_undoc.h.

SHExpandEnvironmentStrings

#define SHExpandEnvironmentStrings   SHExpandEnvironmentStringsA

Definition at line 148 of file shlwapi_undoc.h.

SHGetValueGoodBoot

#define SHGetValueGoodBoot   SHGetValueGoodBootA

Definition at line 265 of file shlwapi_undoc.h.

SHLoadRegUIString

#define SHLoadRegUIString   SHLoadRegUIStringA

Definition at line 266 of file shlwapi_undoc.h.

WHICH_BAT

#define WHICH_BAT   (1 << 3)

Definition at line 333 of file shlwapi_undoc.h.

WHICH_CMD

#define WHICH_CMD   (1 << 5)

Definition at line 335 of file shlwapi_undoc.h.

WHICH_COM

#define WHICH_COM   (1 << 1)

Definition at line 331 of file shlwapi_undoc.h.

WHICH_DEFAULT

#define WHICH_DEFAULT   (WHICH_PIF | WHICH_COM | WHICH_EXE | WHICH_BAT | WHICH_LNK | WHICH_CMD)

Definition at line 338 of file shlwapi_undoc.h.

WHICH_EXE

#define WHICH_EXE   (1 << 2)

Definition at line 332 of file shlwapi_undoc.h.

WHICH_LNK

#define WHICH_LNK   (1 << 4)

Definition at line 334 of file shlwapi_undoc.h.

WHICH_OPTIONAL

#define WHICH_OPTIONAL   (1 << 6)

Definition at line 336 of file shlwapi_undoc.h.

WHICH_PIF

#define WHICH_PIF   (1 << 0)

Definition at line 330 of file shlwapi_undoc.h.

Typedef Documentation

ASSOCQUERY

typedef DWORD ASSOCQUERY

Definition at line 23 of file shlwapi_undoc.h.

LPPOLICYDATA

typedef struct tagPOLICYDATA * LPPOLICYDATA

POLICYDATA

typedef struct tagPOLICYDATA POLICYDATA

Enumeration Type Documentation

_shellkey_flags

enum _shellkey_flags

Enumerator
SHKEY_Root_HKCU
SHKEY_Root_HKLM
SHKEY_Key_Explorer
SHKEY_Key_Shell
SHKEY_Key_ShellNoRoam
SHKEY_Key_Classes
SHKEY_Subkey_Default
SHKEY_Subkey_ResourceName
SHKEY_Subkey_Handlers
SHKEY_Subkey_Associations
SHKEY_Subkey_Volatile
SHKEY_Subkey_MUICache
SHKEY_Subkey_FileExts
SHKEY_Root_HKCU
SHKEY_Root_HKLM
SHKEY_Key_Explorer
SHKEY_Key_Shell
SHKEY_Key_ShellNoRoam
SHKEY_Key_Classes
SHKEY_Subkey_Default
SHKEY_Subkey_ResourceName
SHKEY_Subkey_Handlers
SHKEY_Subkey_Associations
SHKEY_Subkey_Volatile
SHKEY_Subkey_MUICache
SHKEY_Subkey_FileExts

Definition at line 299 of file shlwapi_undoc.h.

{
    SHKEY_Root_HKCU = 0x1,
    SHKEY_Root_HKLM = 0x2,
    SHKEY_Key_Explorer = 0x00,
    SHKEY_Key_Shell = 0x10,
    SHKEY_Key_ShellNoRoam = 0x20,
    SHKEY_Key_Classes = 0x30,
    SHKEY_Subkey_Default = 0x0000,
    SHKEY_Subkey_ResourceName = 0x1000,
    SHKEY_Subkey_Handlers = 0x2000,
    SHKEY_Subkey_Associations = 0x3000,
    SHKEY_Subkey_Volatile = 0x4000,
    SHKEY_Subkey_MUICache = 0x5000,
    SHKEY_Subkey_FileExts = 0x6000
};

Function Documentation

ConnectToConnectionPoint()

HRESULT WINAPI ConnectToConnectionPoint	(	IUnknown *	lpUnkSink,
		REFIID	riid,
		BOOL	bAdviseOnly,
		IUnknown *	lpUnknown,
		LPDWORD	lpCookie,
		IConnectionPoint **	lppCP
	)

Definition at line 1193 of file ordinal.c.

{
  HRESULT hRet;
  IConnectionPointContainer* lpContainer;
  IConnectionPoint *lpCP;
 
  if(!lpUnknown || (fConnect && !lpUnkSink))
    return E_FAIL;
 
  if(lppCP)
    *lppCP = NULL;
 
  hRet = IUnknown_QueryInterface(lpUnknown, &IID_IConnectionPointContainer,
                                 (void**)&lpContainer);
  if (SUCCEEDED(hRet))
  {
    hRet = IConnectionPointContainer_FindConnectionPoint(lpContainer, riid, &lpCP);
 
    if (SUCCEEDED(hRet))
    {
      if(!fConnect)
        hRet = IConnectionPoint_Unadvise(lpCP, *lpCookie);
      else
        hRet = IConnectionPoint_Advise(lpCP, lpUnkSink, lpCookie);
 
      if (FAILED(hRet))
        *lpCookie = 0;
 
      if (lppCP && SUCCEEDED(hRet))
        *lppCP = lpCP; /* Caller keeps the interface */
      else
        IConnectionPoint_Release(lpCP); /* Release it */
    }
 
    IConnectionPointContainer_Release(lpContainer);
  }
  return hRet;
}

Referenced by init_pointers().

FixSlashesAndColonW()

VOID WINAPI FixSlashesAndColonW

(

LPWSTR

lpwstr

)

Definition at line 4551 of file ordinal.c.

{
    while (*lpwstr)
    {
        if (*lpwstr == '/')
            *lpwstr = '\\';
        lpwstr++;
    }
}

Referenced by PathQualifyExW().

IContextMenu_Invoke()

BOOL WINAPI IContextMenu_Invoke	(	_In_ IContextMenu *	pContextMenu,
		_In_ HWND	hwnd,
		_In_ LPCSTR	lpVerb,
		_In_ UINT	uFlags
	)

Definition at line 196 of file utils.cpp.

{
    TRACE("(%p, %p, %s, %u)\n", pContextMenu, hwnd, debugstr_a(lpVerb), uFlags);
    HRESULT hr = SHInvokeCommandOnContextMenuInternal(hwnd, NULL, pContextMenu, 0,
                                                      uFlags, lpVerb, NULL, false);
    return !FAILED_UNEXPECTEDLY(hr);
}

IsQSForward()

HRESULT WINAPI IsQSForward	(	REFGUID	pguidCmdGroup,
		ULONG	cCmds,
		OLECMD *	prgCmds
	)

Definition at line 2235 of file ordinal.c.

{
  FIXME("(%p,%d,%p) - stub!\n", pguidCmdGroup, cCmds, prgCmds);
  return DRAGDROP_E_NOTREGISTERED;
}

IStream_Size()

HRESULT WINAPI IStream_Size	(	IStream *	lpStream,
		ULARGE_INTEGER *	lpulSize
	)

Definition at line 661 of file istream.c.

{
  STATSTG statstg;
  HRESULT hRet;
 
  TRACE("(%p,%p)\n", lpStream, lpulSize);
 
  memset(&statstg, 0, sizeof(statstg));
 
  hRet = IStream_Stat(lpStream, &statstg, 1);
 
  if (SUCCEEDED(hRet) && lpulSize)
    *lpulSize = statstg.cbSize;
  return hRet;
}

Referenced by CDesktopUpgradePropertyBag::_GetOldDesktopViewStream(), CRegPropertyBag::_GetStreamSize(), and CDesktopUpgradePropertyBag::_NewStreamFromOld().

IUnknown_Exec()

HRESULT WINAPI IUnknown_Exec	(	IUnknown *	lpUnknown,
		REFGUID	pguidCmdGroup,
		DWORD	nCmdID,
		DWORD	nCmdexecopt,
		VARIANT *	pvaIn,
		VARIANT *	pvaOut
	)

Definition at line 1087 of file ordinal.c.

{
  HRESULT hRet = E_FAIL;
 
  TRACE("(%p,%p,%d,%d,%p,%p)\n",lpUnknown, pguidCmdGroup, nCmdID,
        nCmdexecopt, pvaIn, pvaOut);
 
  if (lpUnknown)
  {
    IOleCommandTarget* lpOle;
 
    hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleCommandTarget,
                                   (void**)&lpOle);
    if (SUCCEEDED(hRet) && lpOle)
    {
      hRet = IOleCommandTarget_Exec(lpOle, pguidCmdGroup, nCmdID,
                                    nCmdexecopt, pvaIn, pvaOut);
      IOleCommandTarget_Release(lpOle);
    }
  }
  return hRet;
}

Referenced by CTrayBandSite::AddBand(), CISFBand::BandInfoChanged(), CTrayWindow::CheckTrayWndPosition(), CInternetToolbar::CreateMenuBar(), CBaseBar::Exec(), CShellBrowser::Exec(), CMenuSite::Exec(), ExecResetDefViewFolderSettings(), CShellBrowser::Initialize(), CBaseBarSite::OnCommand(), CInternetToolbar::OnFolders(), CInternetToolbar::OnSearch(), CShellBrowser::OnToggleAddressBandVisible(), CShellBrowser::OnToggleLinksBandVisible(), CShellBrowser::OnToggleTextLabels(), CShellBrowser::OnToggleToolbarBandVisible(), CShellBrowser::OnToggleToolbarLock(), CShellBrowser::OnToolbarCustomize(), CInternetToolbar::OnUpLevel(), CShellBrowser::SetAsDefFolderSettings(), CInternetToolbar::SetDirty(), CShellBrowser::ShowBand(), CShellBrowser::ShowControlWindow(), and CTrayBandSite::Update().

IUnknown_GetClassID()

HRESULT WINAPI IUnknown_GetClassID	(	IUnknown *	lpUnknown,
		CLSID *	lpClassId
	)

Definition at line 1457 of file ordinal.c.

{
    IPersist *persist;
    HRESULT hr;
 
    TRACE("(%p, %p)\n", lpUnknown, clsid);
 
    if (!lpUnknown)
    {
        memset(clsid, 0, sizeof(*clsid));
        return E_FAIL;
    }
 
    hr = IUnknown_QueryInterface(lpUnknown, &IID_IPersist, (void**)&persist);
    if (hr != S_OK)
    {
        hr = IUnknown_QueryInterface(lpUnknown, &IID_IPersistFolder, (void**)&persist);
        if (hr != S_OK)
            return hr;
    }
 
    hr = IPersist_GetClassID(persist, clsid);
    IPersist_Release(persist);
    return hr;
}

Referenced by CShellBrowser::BrowseToPIDL(), GetClassOfItem(), CDefView::GetDefaultViewStream(), CSearchBar::GetSearchResultsFolder(), init_pointers(), and SHSkipJunction().

IUnknown_HandleIRestrict()

HRESULT WINAPI IUnknown_HandleIRestrict	(	LPUNKNOWN	lpUnknown,
		PVOID	lpArg1,
		PVOID	lpArg2,
		PVOID	lpArg3,
		PVOID	lpArg4
	)

Definition at line 1953 of file ordinal.c.

{
  /* FIXME: {D12F26B2-D90A-11D0-830D-00AA005B4383} - What object does this represent? */
  static const DWORD service_id[] = { 0xd12f26b2, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
  /* FIXME: {D12F26B1-D90A-11D0-830D-00AA005B4383} - Also Unknown/undocumented */
  static const DWORD function_id[] = { 0xd12f26b1, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
  HRESULT hRet = E_INVALIDARG;
  LPUNKNOWN lpUnkInner = NULL; /* FIXME: Real type is unknown */
 
  TRACE("(%p,%p,%p,%p,%p)\n", lpUnknown, lpArg1, lpArg2, lpArg3, lpArg4);
 
  if (lpUnknown && lpArg4)
  {
     hRet = IUnknown_QueryService(lpUnknown, (REFGUID)service_id,
                                  (REFGUID)function_id, (void**)&lpUnkInner);
 
     if (SUCCEEDED(hRet) && lpUnkInner)
     {
       /* FIXME: The type of service object requested is unknown, however
    * testing shows that its first method is called with 4 parameters.
    * Fake this by using IParseDisplayName_ParseDisplayName since the
    * signature and position in the vtable matches our unknown object type.
    */
       hRet = IParseDisplayName_ParseDisplayName((LPPARSEDISPLAYNAME)lpUnkInner,
                                                 lpArg1, lpArg2, lpArg3, lpArg4);
       IUnknown_Release(lpUnkInner);
     }
  }
  return hRet;
}

IUnknown_HasFocusIO()

HRESULT WINAPI IUnknown_HasFocusIO

(

IUnknown *

punk

)

Definition at line 4332 of file ordinal.c.

{
  IInputObject* lpInput = NULL;
  HRESULT hRet = E_INVALIDARG;
 
  TRACE("(%p)\n", lpUnknown);
  if (lpUnknown)
  {
    hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInputObject,
                                   (void**)&lpInput);
    if (SUCCEEDED(hRet) && lpInput)
    {
      hRet = IInputObject_HasFocusIO(lpInput);
      IInputObject_Release(lpInput);
    }
  }
  return hRet;
}

Referenced by CBaseBarSite::HasFocusIO(), CInternetToolbar::HasFocusIO(), CBaseBar::HasFocusIO(), and CMenuDeskBar::HasFocusIO().

IUnknown_OnFocusChangeIS()

HRESULT WINAPI IUnknown_OnFocusChangeIS	(	LPUNKNOWN	lpUnknown,
		LPUNKNOWN	pFocusObject,
		BOOL	bFocus
	)

Definition at line 4804 of file ordinal.c.

{
    IInputObjectSite *pIOS = NULL;
    HRESULT hRet = E_INVALIDARG;
 
    TRACE("(%p, %p, %s)\n", lpUnknown, pFocusObject, bFocus ? "TRUE" : "FALSE");
 
    if (lpUnknown)
    {
        hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInputObjectSite,
                                       (void **)&pIOS);
        if (SUCCEEDED(hRet) && pIOS)
        {
            hRet = IInputObjectSite_OnFocusChangeIS(pIOS, pFocusObject, bFocus);
            IInputObjectSite_Release(pIOS);
        }
    }
    return hRet;
}

Referenced by CBaseBarSite::OnFocusChangeIS(), CBaseBar::OnFocusChangeIS(), CMenuDeskBar::OnFocusChangeIS(), CSearchBar::OnSetFocus(), and CAddressBand::UIActivateIO().

IUnknown_OnFocusOCS()

HRESULT WINAPI IUnknown_OnFocusOCS	(	IUnknown *	lpUnknown,
		BOOL	fGotFocus
	)

Definition at line 1931 of file ordinal.c.

{
  IOleControlSite* lpCSite = NULL;
  HRESULT hRet = E_FAIL;
 
  TRACE("(%p, %d)\n", lpUnknown, fGotFocus);
  if (lpUnknown)
  {
    hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleControlSite,
                                   (void**)&lpCSite);
    if (SUCCEEDED(hRet) && lpCSite)
    {
      hRet = IOleControlSite_OnFocus(lpCSite, fGotFocus);
      IOleControlSite_Release(lpCSite);
    }
  }
  return hRet;
}

IUnknown_QueryServiceExec()

HRESULT WINAPI IUnknown_QueryServiceExec	(	IUnknown *	lpUnknown,
		REFIID	service,
		const GUID *	group,
		DWORD	cmdId,
		DWORD	cmdOpt,
		VARIANT *	pIn,
		VARIANT *	pOut
	)

Definition at line 1553 of file ordinal.c.

{
    IOleCommandTarget *target;
    HRESULT hr;
 
    TRACE("%p %s %s %d %08x %p %p\n", lpUnknown, debugstr_guid(service),
        debugstr_guid(group), cmdId, cmdOpt, pIn, pOut);
 
    hr = IUnknown_QueryService(lpUnknown, service, &IID_IOleCommandTarget, (void**)&target);
    if (hr == S_OK)
    {
        hr = IOleCommandTarget_Exec(target, group, cmdId, cmdOpt, pIn, pOut);
        IOleCommandTarget_Release(target);
    }
 
    TRACE("<-- hr=0x%08x\n", hr);
 
    return hr;
}

Referenced by CMenuBand::AdjustForTheme(), init_pointers(), CMenuDeskBar::Popup(), and CMenuDeskBar::SetIconSize().

IUnknown_QueryServicePropertyBag()

EXTERN_C HRESULT WINAPI IUnknown_QueryServicePropertyBag	(	_In_ IUnknown *	punk,
		_In_ long	flags,
		_In_ REFIID	riid,
		_Outptr_ void **	ppvObj
	)

Definition at line 1967 of file propbag.cpp.

{
    TRACE("%p 0x%x %p %p\n", punk, flags, &riid, ppvObj);
 
    CComPtr<IShellBrowserService> pService;
    HRESULT hr = IUnknown_QueryService(punk, SID_STopLevelBrowser, IID_IShellBrowserService,
                                       (void **)&pService);
    if (FAILED(hr))
    {
        ERR("0x%X\n", hr);
        return hr;
    }
 
    return pService->GetPropertyBag(flags, riid, ppvObj);
}

Referenced by CDefView::LoadViewState(), and CDefView::SaveViewState().

IUnknown_QueryStatus()

HRESULT WINAPI IUnknown_QueryStatus	(	IUnknown *	lpUnknown,
		REFGUID	pguidCmdGroup,
		ULONG	cCmds,
		OLECMD *	prgCmds,
		OLECMDTEXT *	pCmdText
	)

Definition at line 1048 of file ordinal.c.

{
  HRESULT hRet = E_FAIL;
 
  TRACE("(%p,%p,%d,%p,%p)\n",lpUnknown, pguidCmdGroup, cCmds, prgCmds, pCmdText);
 
  if (lpUnknown)
  {
    IOleCommandTarget* lpOle;
 
    hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleCommandTarget,
                                   (void**)&lpOle);
 
    if (SUCCEEDED(hRet) && lpOle)
    {
      hRet = IOleCommandTarget_QueryStatus(lpOle, pguidCmdGroup, cCmds,
                                           prgCmds, pCmdText);
      IOleCommandTarget_Release(lpOle);
    }
  }
  return hRet;
}

Referenced by CInternetToolbar::CommandStateChanged(), CShellBrowser::IsInternetToolbarBandShown(), CInternetToolbar::OnMenuDropDown(), CAddressBand::QueryStatus(), CMenuSite::QueryStatus(), and CShellBrowser::UpdateViewMenu().

IUnknown_Set()

VOID WINAPI IUnknown_Set	(	IUnknown **	lppDest,
		IUnknown *	lpUnknown
	)

Definition at line 2190 of file ordinal.c.

{
  TRACE("(%p,%p)\n", lppDest, lpUnknown);
 
  IUnknown_AtomicRelease(lppDest);
 
  if (lpUnknown)
  {
    IUnknown_AddRef(lpUnknown);
    *lppDest = lpUnknown;
  }
}

Referenced by Free().

IUnknown_SetOwner()

HRESULT WINAPI IUnknown_SetOwner	(	IUnknown *	iface,
		IUnknown *	pUnk
	)

Definition at line 1385 of file ordinal.c.

{
  IShellService *service;
  HRESULT hr;
 
  TRACE("(%p, %p)\n", iface, pUnk);
 
  if (!iface) return E_FAIL;
 
  hr = IUnknown_QueryInterface(iface, &IID_IShellService, (void**)&service);
  if (hr == S_OK)
  {
    hr = IShellService_SetOwner(service, pUnk);
    IShellService_Release(service);
  }
 
  return hr;
}

Referenced by CTrayBandSite::AddContextMenus().

IUnknown_TranslateAcceleratorIO()

HRESULT WINAPI IUnknown_TranslateAcceleratorIO	(	IUnknown *	punk,
		MSG *	pmsg
	)

IUnknown_TranslateAcceleratorOCS()

HRESULT WINAPI IUnknown_TranslateAcceleratorOCS	(	IUnknown *	lpUnknown,
		LPMSG	lpMsg,
		DWORD	dwModifiers
	)

Definition at line 1898 of file ordinal.c.

{
  IOleControlSite* lpCSite = NULL;
  HRESULT hRet = E_INVALIDARG;
 
  TRACE("(%p,%p,0x%08x)\n", lpUnknown, lpMsg, dwModifiers);
  if (lpUnknown)
  {
    hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleControlSite,
                                   (void**)&lpCSite);
    if (SUCCEEDED(hRet) && lpCSite)
    {
      hRet = IOleControlSite_TranslateAccelerator(lpCSite, lpMsg, dwModifiers);
      IOleControlSite_Release(lpCSite);
    }
  }
  return hRet;
}

IUnknown_UIActivateIO()

HRESULT WINAPI IUnknown_UIActivateIO	(	IUnknown *	unknown,
		BOOL	activate,
		LPMSG	msg
	)

Definition at line 1633 of file ordinal.c.

{
    IInputObject* object = NULL;
    HRESULT ret;
 
    if (!unknown)
        return E_FAIL;
 
    /* Get an IInputObject interface from the object */
    ret = IUnknown_QueryInterface(unknown, &IID_IInputObject, (LPVOID*) &object);
 
    if (ret == S_OK)
    {
        ret = IInputObject_UIActivateIO(object, activate, msg);
        IInputObject_Release(object);
    }
 
    return ret;
}

Referenced by CMenuDeskBar::UIActivateIO(), CBaseBarSite::UIActivateIO(), CBaseBar::UIActivateIO(), and CMenuSite::UIActivateIO().

MayExecForward()

HRESULT WINAPI MayExecForward	(	IUnknown *	lpUnknown,
		INT	iUnk,
		REFGUID	pguidCmdGroup,
		DWORD	nCmdID,
		DWORD	nCmdexecopt,
		VARIANT *	pvaIn,
		VARIANT *	pvaOut
	)

Definition at line 2222 of file ordinal.c.

{
  FIXME("(%p,%d,%p,%d,%d,%p,%p) - stub!\n", lpUnknown, iUnk, pguidCmdGroup,
        nCmdID, nCmdexecopt, pvaIn, pvaOut);
  return DRAGDROP_E_NOTREGISTERED;
}

MayQSForward()

HRESULT WINAPI MayQSForward	(	IUnknown *	lpUnknown,
		PVOID	lpReserved,
		REFGUID	riidCmdGrp,
		ULONG	cCmds,
		OLECMD *	prgCmds,
		OLECMDTEXT *	pCmdText
	)

Definition at line 2207 of file ordinal.c.

{
  FIXME("(%p,%p,%p,%d,%p,%p) - stub\n",
        lpUnknown, lpReserved, riidCmdGrp, cCmds, prgCmds, pCmdText);
 
  /* FIXME: Calls IsQSForward & IUnknown_QueryStatus */
  return DRAGDROP_E_NOTREGISTERED;
}

PathFileExistsDefExtAndAttributesW()

BOOL WINAPI PathFileExistsDefExtAndAttributesW	(	_Inout_ LPWSTR	pszPath,
		_In_ DWORD	dwWhich,
		_Out_opt_ LPDWORD	pdwFileAttributes
	)

Definition at line 300 of file utils.cpp.

{
    TRACE("(%s, 0x%lX, %p)\n", debugstr_w(pszPath), dwWhich, pdwFileAttributes);
 
    if (pdwFileAttributes)
        *pdwFileAttributes = INVALID_FILE_ATTRIBUTES;
 
    if (!pszPath)
        return FALSE;
 
    if (!dwWhich || (*PathFindExtensionW(pszPath) && (dwWhich & WHICH_OPTIONAL)))
        return PathFileExistsAndAttributesW(pszPath, pdwFileAttributes);
 
    if (!PathFileExistsDefExtW(pszPath, dwWhich))
    {
        if (pdwFileAttributes)
            *pdwFileAttributes = INVALID_FILE_ATTRIBUTES;
        return FALSE;
    }
 
    if (pdwFileAttributes)
        *pdwFileAttributes = GetFileAttributesW(pszPath);
 
    return TRUE;
}

Referenced by START_TEST().

PathFileExistsDefExtW()

BOOL WINAPI PathFileExistsDefExtW	(	LPWSTR	lpszPath,
		DWORD	dwWhich
	)

Definition at line 1123 of file path.c.

{
  static const WCHAR pszExts[][5]  = { { '.', 'p', 'i', 'f', 0},
                                       { '.', 'c', 'o', 'm', 0},
                                       { '.', 'e', 'x', 'e', 0},
                                       { '.', 'b', 'a', 't', 0},
                                       { '.', 'l', 'n', 'k', 0},
                                       { '.', 'c', 'm', 'd', 0},
                                       { 0, 0, 0, 0, 0} };
 
  TRACE("(%s,%d)\n", debugstr_w(lpszPath), dwWhich);
 
  if (!lpszPath || PathIsUNCServerW(lpszPath) || PathIsUNCServerShareW(lpszPath))
    return FALSE;
 
  if (dwWhich)
  {
    LPCWSTR szExt = PathFindExtensionW(lpszPath);
#ifndef __REACTOS__
    if (!*szExt || dwWhich & 0x40)
#else
    if (!*szExt || dwWhich & WHICH_OPTIONAL)
#endif
    {
      size_t iChoose = 0;
      int iLen = lstrlenW(lpszPath);
      if (iLen > (MAX_PATH - 5))
        return FALSE;
#ifndef __REACTOS__
      while ( (dwWhich & 0x1) && pszExts[iChoose][0] )
#else
      while (pszExts[iChoose][0])
#endif
      {
#ifdef __REACTOS__
        if (dwWhich & 0x1)
        {
        if (GetFileAttributes(lpszPath) != FILE_ATTRIBUTE_DIRECTORY)
#endif
        lstrcpyW(lpszPath + iLen, pszExts[iChoose]);
        if (PathFileExistsW(lpszPath))
          return TRUE;
#ifdef __REACTOS__
        }
#endif
        iChoose++;
        dwWhich >>= 1;
      }
      *(lpszPath + iLen) = (WCHAR)'\0';
      return FALSE;
    }
  }
  return PathFileExistsW(lpszPath);
}

Referenced by PathFileExistsDefExtA(), PathFileExistsDefExtAndAttributesW(), PathFindOnPathExA(), PathFindOnPathExW(), PathSearchOnExtensionsW(), and SHLWAPI_PathFindInOtherDirs().

PathFindOnPathExW()

BOOL WINAPI PathFindOnPathExW	(	LPWSTR	lpszFile,
		LPCWSTR *	lppszOtherDirs,
		DWORD	dwWhich
	)

Definition at line 1357 of file path.c.

{
  WCHAR buff[MAX_PATH];
 
  TRACE("(%s,%p,%08x)\n", debugstr_w(lpszFile), lppszOtherDirs, dwWhich);
 
  if (!lpszFile || !PathIsFileSpecW(lpszFile))
    return FALSE;
 
  /* Search provided directories first */
  if (lppszOtherDirs && *lppszOtherDirs)
  {
    LPCWSTR *lpszOtherPath = lppszOtherDirs;
    while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
    {
      PathCombineW(buff, *lpszOtherPath, lpszFile);
      if (PathFileExistsDefExtW(buff, dwWhich))
      {
        strcpyW(lpszFile, buff);
        return TRUE;
      }
      lpszOtherPath++;
    }
  }
  /* Not found, try system and path dirs */
  return SHLWAPI_PathFindInOtherDirs(lpszFile, dwWhich);
}

Referenced by PathFindOnPathW(), PathSearchOnExtensionsW(), ShellExecCmdLine(), and WelcomeDlgProc().

PathIsValidCharA()

BOOL WINAPI PathIsValidCharA	(	char	c,
		DWORD	dwClass
	)

Definition at line 4396 of file path.c.

{
    if ((unsigned)c > 0x7e)
        return class & PATH_CHAR_CLASS_OTHER_VALID;
 
    return class & SHELL_charclass[(unsigned)c];
}

PathIsValidCharW()

BOOL WINAPI PathIsValidCharW	(	WCHAR	c,
		DWORD	dwClass
	)

Definition at line 4409 of file path.c.

{
    if (c > 0x7e)
        return class & PATH_CHAR_CLASS_OTHER_VALID;
 
    return class & SHELL_charclass[c];
}

Referenced by PathIsValidElement(), PathQualifyExW(), SHDOCVW_PathDeleteInvalidChars(), and UrlUnescapeAndMakeFileNameValid().

QueryDirect()

STDMETHOD() QueryDirect	(	THIS_ ASSOCQUERY	query,
		PCWSTR	key,
		FLAGGED_BYTE_BLOB **	ppBlob
	)

QueryDword()

STDMETHOD() QueryDword	(	THIS_ ASSOCQUERY	query,
		PCWSTR	key,
		DWORD *	pdwValue
	)

QueryExists()

STDMETHOD() QueryExists	(	THIS_ ASSOCQUERY	query,
		PCWSTR	key
	)

QueryObject()

STDMETHOD() QueryObject	(	THIS_ ASSOCQUERY	query,
		PCWSTR	key,
		REFIID	riid,
		PVOID *	ppvObj
	)

QueryString()

STDMETHOD() QueryString	(	THIS_ ASSOCQUERY	query,
		PCWSTR	key,
		PWSTR *	ppszValue
	)

RegCreateKeyExWrapW()

LONG WINAPI RegCreateKeyExWrapW	(	_In_ HKEY	hKey,
		_In_ LPCWSTR	lpSubKey,
		_In_ DWORD	Reserved,
		_In_opt_ LPWSTR	lpClass,
		_In_ DWORD	dwOptions,
		_In_ REGSAM	samDesired,
		_In_opt_ LPSECURITY_ATTRIBUTES	lpSecurityAttributes,
		_Out_ PHKEY	phkResult,
		_Out_opt_ LPDWORD	lpdwDisposition
	)

Referenced by CMruBase::InitData().

RunIndirectRegCommand()

HRESULT WINAPI RunIndirectRegCommand	(	_In_opt_ HWND	hWnd,
		_In_ HKEY	hKey,
		_In_opt_ PCWSTR	pszSubKey,
		_In_ PCWSTR	pszVerb
	)

Definition at line 250 of file utils.cpp.

{
    WCHAR szKey[MAX_PATH];
    HRESULT hr;
    if (pszSubKey)
        hr = StringCchPrintfW(szKey, _countof(szKey), L"%s\\shell\\%s\\command", pszSubKey, pszVerb);
    else
        hr = StringCchPrintfW(szKey, _countof(szKey), L"shell\\%s\\command", pszVerb);
    return SUCCEEDED(hr) ? RunRegCommand(hWnd, hKey, szKey) : hr;
}

Referenced by SHRunIndirectRegClientCommand().

RunRegCommand()

HRESULT WINAPI RunRegCommand	(	_In_opt_ HWND	hWnd,
		_In_ HKEY	hKey,
		_In_opt_ PCWSTR	pszSubKey
	)

Definition at line 236 of file utils.cpp.

{
    WCHAR szCmd[MAX_PATH * 2];
    DWORD cb = sizeof(szCmd);
    DWORD error = RegGetValueW(hKey, pszSubKey, NULL, RRF_RT_REG_SZ, NULL, szCmd, &cb);
    if (error)
        return HRESULT_FROM_WIN32(error);
    return ShellExecuteCommand(hWnd, szCmd, SEE_MASK_FLAG_LOG_USAGE);
}

Referenced by RunIndirectRegCommand().

SHAboutInfoA()

BOOL WINAPI SHAboutInfoA	(	LPSTR	lpszDest,
		DWORD	dwDestLen
	)

Definition at line 915 of file ordinal.c.

{
  WCHAR buff[2084];
 
  TRACE("(%p,%d)\n", lpszDest, dwDestLen);
 
  if (lpszDest && SHAboutInfoW(buff, dwDestLen))
  {
    WideCharToMultiByte(CP_ACP, 0, buff, -1, lpszDest, dwDestLen, NULL, NULL);
    return TRUE;
  }
  return FALSE;
}

SHAboutInfoW()

BOOL WINAPI SHAboutInfoW	(	LPWSTR	lpszDest,
		DWORD	dwDestLen
	)

Definition at line 934 of file ordinal.c.

{
  static const WCHAR szIEKey[] = { 'S','O','F','T','W','A','R','E','\\',
    'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
    ' ','E','x','p','l','o','r','e','r','\0' };
  static const WCHAR szWinNtKey[] = { 'S','O','F','T','W','A','R','E','\\',
    'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ',
    'N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
  static const WCHAR szWinKey[] = { 'S','O','F','T','W','A','R','E','\\',
    'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
    'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
  static const WCHAR szRegKey[] = { 'S','O','F','T','W','A','R','E','\\',
    'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
    ' ','E','x','p','l','o','r','e','r','\\',
    'R','e','g','i','s','t','r','a','t','i','o','n','\0' };
  static const WCHAR szVersion[] = { 'V','e','r','s','i','o','n','\0' };
  static const WCHAR szCustomized[] = { 'C','u','s','t','o','m','i','z','e','d',
    'V','e','r','s','i','o','n','\0' };
  static const WCHAR szOwner[] = { 'R','e','g','i','s','t','e','r','e','d',
    'O','w','n','e','r','\0' };
  static const WCHAR szOrg[] = { 'R','e','g','i','s','t','e','r','e','d',
    'O','r','g','a','n','i','z','a','t','i','o','n','\0' };
  static const WCHAR szProduct[] = { 'P','r','o','d','u','c','t','I','d','\0' };
  static const WCHAR szUpdate[] = { 'I','E','A','K',
    'U','p','d','a','t','e','U','r','l','\0' };
  static const WCHAR szHelp[] = { 'I','E','A','K',
    'H','e','l','p','S','t','r','i','n','g','\0' };
  WCHAR buff[2084];
  HKEY hReg;
  DWORD dwType, dwLen;
 
  TRACE("(%p,%d)\n", lpszDest, dwDestLen);
 
  if (!lpszDest)
    return FALSE;
 
  *lpszDest = '\0';
 
  /* Try the NT key first, followed by 95/98 key */
  if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szWinNtKey, 0, KEY_READ, &hReg) &&
      RegOpenKeyExW(HKEY_LOCAL_MACHINE, szWinKey, 0, KEY_READ, &hReg))
    return FALSE;
 
  /* OS Version */
  buff[0] = '\0';
  dwLen = 30;
  if (!SHGetValueW(HKEY_LOCAL_MACHINE, szIEKey, szVersion, &dwType, buff, &dwLen))
  {
    DWORD dwStrLen = strlenW(buff);
    dwLen = 30 - dwStrLen;
    SHGetValueW(HKEY_LOCAL_MACHINE, szIEKey,
                szCustomized, &dwType, buff+dwStrLen, &dwLen);
  }
  StrCatBuffW(lpszDest, buff, dwDestLen);
 
  /* ~Registered Owner */
  buff[0] = '~';
  dwLen = 256;
  if (SHGetValueW(hReg, szOwner, 0, &dwType, buff+1, &dwLen))
    buff[1] = '\0';
  StrCatBuffW(lpszDest, buff, dwDestLen);
 
  /* ~Registered Organization */
  dwLen = 256;
  if (SHGetValueW(hReg, szOrg, 0, &dwType, buff+1, &dwLen))
    buff[1] = '\0';
  StrCatBuffW(lpszDest, buff, dwDestLen);
 
  /* FIXME: Not sure where this number comes from  */
  buff[0] = '~';
  buff[1] = '0';
  buff[2] = '\0';
  StrCatBuffW(lpszDest, buff, dwDestLen);
 
  /* ~Product Id */
  dwLen = 256;
  if (SHGetValueW(HKEY_LOCAL_MACHINE, szRegKey, szProduct, &dwType, buff+1, &dwLen))
    buff[1] = '\0';
  StrCatBuffW(lpszDest, buff, dwDestLen);
 
  /* ~IE Update Url */
  dwLen = 2048;
  if(SHGetValueW(HKEY_LOCAL_MACHINE, szWinKey, szUpdate, &dwType, buff+1, &dwLen))
    buff[1] = '\0';
  StrCatBuffW(lpszDest, buff, dwDestLen);
 
  /* ~IE Help String */
  dwLen = 256;
  if(SHGetValueW(hReg, szHelp, 0, &dwType, buff+1, &dwLen))
    buff[1] = '\0';
  StrCatBuffW(lpszDest, buff, dwDestLen);
 
  RegCloseKey(hReg);
  return TRUE;
}

Referenced by SHAboutInfoA().

SHAddDataBlock()

BOOL WINAPI SHAddDataBlock	(	LPDBLIST *	lppList,
		const DATABLOCK_HEADER *	lpNewItem
	)

Definition at line 68 of file clist.c.

{
  LPDATABLOCK_HEADER lpInsertAt = NULL;
  ULONG ulSize;
 
  TRACE("(%p,%p)\n", lppList, lpNewItem);
 
  if(!lppList || !lpNewItem)
    return FALSE;
 
  if (lpNewItem->cbSize < sizeof(DATABLOCK_HEADER) ||
      lpNewItem->dwSignature == CLIST_ID_CONTAINER)
    return FALSE;
 
  ulSize = lpNewItem->cbSize;
 
  if(ulSize & 0x3)
  {
    /* Tune size to a ULONG boundary, add space for container element */
    ulSize = ((ulSize + 0x3) & 0xFFFFFFFC) + sizeof(DATABLOCK_HEADER);
    TRACE("Creating container item, new size = %d\n", ulSize);
  }
 
  if(!*lppList)
  {
    /* An empty list. Allocate space for terminal ulSize also */
    *lppList = LocalAlloc(LMEM_ZEROINIT, ulSize + sizeof(ULONG));
    lpInsertAt = *lppList;
  }
  else
  {
    /* Append to the end of the list */
    ULONG ulTotalSize = 0;
    LPDATABLOCK_HEADER lpIter = *lppList;
 
    /* Iterate to the end of the list, calculating the total size */
    while (lpIter->cbSize)
    {
      ulTotalSize += lpIter->cbSize;
      lpIter = NextItem(lpIter);
    }
 
    /* Increase the size of the list */
    lpIter = LocalReAlloc(*lppList, ulTotalSize + ulSize+sizeof(ULONG),
                                          LMEM_ZEROINIT | LMEM_MOVEABLE);
    if(lpIter)
    {
      *lppList = lpIter;
      lpInsertAt = (LPDATABLOCK_HEADER)((char*)lpIter + ulTotalSize); /* At end */
    }
  }
 
  if(lpInsertAt)
  {
    /* Copy in the new item */
    LPDATABLOCK_HEADER lpDest = lpInsertAt;
 
    if(ulSize != lpNewItem->cbSize)
    {
      lpInsertAt->cbSize = ulSize;
      lpInsertAt->dwSignature = CLIST_ID_CONTAINER;
      lpDest++;
    }
    memcpy(lpDest, lpNewItem, lpNewItem->cbSize);
 
    /* Terminate the list */
    lpInsertAt = NextItem(lpInsertAt);
    lpInsertAt->cbSize = 0;
 
    return TRUE;
  }
  return FALSE;
}

Referenced by CShellLink::AddDataBlock(), and SHReadDataBlockList().

SHAnsiToUnicode()

DWORD WINAPI SHAnsiToUnicode	(	LPCSTR	lpSrcStr,
		LPWSTR	lpDstStr,
		INT	iLen
	)

SHAnsiToUnicodeCP()

DWORD WINAPI SHAnsiToUnicodeCP	(	DWORD	dwCp,
		LPCSTR	lpSrcStr,
		LPWSTR	lpDstStr,
		int	iLen
	)

Definition at line 2648 of file string.c.

{
  DWORD dwRet;
 
  dwRet = MultiByteToWideChar(dwCp, 0, lpSrcStr, -1, lpDstStr, iLen);
  TRACE("%s->%s,ret=%d\n", debugstr_a(lpSrcStr), debugstr_w(lpDstStr), dwRet);
  return dwRet;
}

Referenced by SHAnsiToUnicode().

SHBoolSystemParametersInfo()

EXTERN_C BOOL WINAPI SHBoolSystemParametersInfo	(	UINT	uiAction,
		PVOID	pvParam
	)

Referenced by GetSetState().

SHCheckMenuItem()

DWORD WINAPI SHCheckMenuItem	(	HMENU	hMenu,
		UINT	uID,
		BOOL	bCheck
	)

Definition at line 1800 of file ordinal.c.

{
  TRACE("%p, %u, %d\n", hMenu, uID, bCheck);
  return CheckMenuItem(hMenu, uID, bCheck ? MF_CHECKED : MF_UNCHECKED);
}

Referenced by CInternetToolbar::OnContextMenu(), and CShellBrowser::UpdateViewMenu().

SHCreatePropertyBagOnMemory()

HRESULT WINAPI SHCreatePropertyBagOnMemory	(	_In_ DWORD	dwMode,
		_In_ REFIID	riid,
		_Out_ void **	ppvObj
	)

Definition at line 254 of file propbag.cpp.

{
    TRACE("0x%08X, %s, %p\n", dwMode, debugstr_guid(&riid), ppvObj);
 
    *ppvObj = NULL;
 
    CComPtr<CMemPropertyBag> pMemBag(new CMemPropertyBag(dwMode));
 
    return pMemBag->QueryInterface(riid, ppvObj);
}

Referenced by SHCreatePropertyBag(), and SHPropertyBag_OnMemory().

SHCreatePropertyBagOnProfileSection()

HRESULT WINAPI SHCreatePropertyBagOnProfileSection	(	_In_z_ LPCWSTR	lpFileName,
		_In_opt_z_ LPCWSTR	pszSection,
		_In_ DWORD	dwMode,
		_In_ REFIID	riid,
		_Out_ void **	ppvObj
	)

Definition at line 965 of file propbag.cpp.

{
    HANDLE hFile;
    PWCHAR pchFileTitle;
    WCHAR szBuff[MAX_PATH];
 
    if (dwMode & STGM_CREATE)
    {
        hFile = ::CreateFileW(lpFileName, 0, FILE_SHARE_DELETE, 0, CREATE_NEW,
                              FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM, NULL);
        if (hFile != INVALID_HANDLE_VALUE)
        {
            pchFileTitle = PathFindFileNameW(lpFileName);
            if (lstrcmpiW(pchFileTitle, L"desktop.ini") == 0)
            {
                StrCpyNW(szBuff, lpFileName, _countof(szBuff));
                if (PathRemoveFileSpecW(szBuff))
                    PathMakeSystemFolderW(szBuff);
            }
            ::CloseHandle(hFile);
        }
    }
 
    *ppvObj = NULL;
 
    if (!PathFileExistsW(lpFileName))
        return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 
    CComPtr<CIniPropertyBag> pIniPB(new CIniPropertyBag(dwMode));
 
    HRESULT hr = pIniPB->Init(lpFileName, pszSection);
    if (FAILED(hr))
    {
        ERR("0x%08X\n", hr);
        return hr;
    }
 
    return pIniPB->QueryInterface(riid, ppvObj);
}

Referenced by SHPropertyBag_OnIniFile().

SHCreatePropertyBagOnRegKey()

HRESULT WINAPI SHCreatePropertyBagOnRegKey	(	_In_ HKEY	hKey,
		_In_z_ LPCWSTR	pszSubKey,
		_In_ DWORD	dwMode,
		_In_ REFIID	riid,
		_Out_ void **	ppvObj
	)

Definition at line 575 of file propbag.cpp.

{
    TRACE("%p, %s, 0x%08X, %s, %p\n", hKey, debugstr_w(pszSubKey), dwMode,
          debugstr_guid(&riid), ppvObj);
 
    *ppvObj = NULL;
 
    CComPtr<CRegPropertyBag> pRegBag(new CRegPropertyBag(dwMode));
 
    HRESULT hr = pRegBag->Init(hKey, pszSubKey);
    if (FAILED(hr))
        return hr;
 
    return pRegBag->QueryInterface(riid, ppvObj);
}

Referenced by CViewStatePropertyBag::_CreateBag(), and CViewStatePropertyBag::_FindNearestInheritBag().

SHCreateWorkerWindowA()

HWND WINAPI SHCreateWorkerWindowA	(	WNDPROC	wndProc,
		HWND	hWndParent,
		DWORD	dwExStyle,
		DWORD	dwStyle,
		HMENU	hMenu,
		LONG_PTR	wnd_extra
	)

Definition at line 2679 of file ordinal.c.

{
  static const char szClass[] = "WorkerA";
  WNDCLASSA wc;
  HWND hWnd;
 
  TRACE("(%p, %p, 0x%08x, 0x%08x, %p, 0x%08lx)\n",
         wndProc, hWndParent, dwExStyle, dwStyle, hMenu, wnd_extra);
 
  /* Create Window class */
  wc.style         = 0;
  wc.lpfnWndProc   = DefWindowProcA;
  wc.cbClsExtra    = 0;
  wc.cbWndExtra    = sizeof(LONG_PTR);
  wc.hInstance     = shlwapi_hInstance;
  wc.hIcon         = NULL;
  wc.hCursor       = LoadCursorA(NULL, (LPSTR)IDC_ARROW);
  wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
  wc.lpszMenuName  = NULL;
  wc.lpszClassName = szClass;
 
  SHRegisterClassA(&wc);
 
  hWnd = CreateWindowExA(dwExStyle, szClass, 0, dwStyle, 0, 0, 0, 0,
                         hWndParent, hMenu, shlwapi_hInstance, 0);
  if (hWnd)
  {
    SetWindowLongPtrW(hWnd, 0, wnd_extra);
    if (wndProc) SetWindowLongPtrA(hWnd, GWLP_WNDPROC, (LONG_PTR)wndProc);
  }
 
  return hWnd;
}

Referenced by init_pointers(), and SHCreateWorkerWindowW().

SHCreateWorkerWindowW()

HWND WINAPI SHCreateWorkerWindowW	(	WNDPROC	wndProc,
		HWND	hWndParent,
		DWORD	dwExStyle,
		DWORD	dwStyle,
		HMENU	hMenu,
		LONG_PTR	wnd_extra
	)

Definition at line 3004 of file ordinal.c.

{
  static const WCHAR szClass[] = { 'W', 'o', 'r', 'k', 'e', 'r', 'W', 0 };
  WNDCLASSW wc;
  HWND hWnd;
 
  TRACE("(%p, %p, 0x%08x, 0x%08x, %p, 0x%08lx)\n",
         wndProc, hWndParent, dwExStyle, dwStyle, hMenu, wnd_extra);
 
  /* If our OS is natively ANSI, use the ANSI version */
  if (GetVersion() & 0x80000000)  /* not NT */
  {
    TRACE("fallback to ANSI, ver 0x%08x\n", GetVersion());
    return SHCreateWorkerWindowA(wndProc, hWndParent, dwExStyle, dwStyle, hMenu, wnd_extra);
  }
 
  /* Create Window class */
  wc.style         = 0;
  wc.lpfnWndProc   = DefWindowProcW;
  wc.cbClsExtra    = 0;
  wc.cbWndExtra    = sizeof(LONG_PTR);
  wc.hInstance     = shlwapi_hInstance;
  wc.hIcon         = NULL;
  wc.hCursor       = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
  wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
  wc.lpszMenuName  = NULL;
  wc.lpszClassName = szClass;
 
  SHRegisterClassW(&wc);
 
  hWnd = CreateWindowExW(dwExStyle, szClass, 0, dwStyle, 0, 0, 0, 0,
                         hWndParent, hMenu, shlwapi_hInstance, 0);
  if (hWnd)
  {
    SetWindowLongPtrW(hWnd, 0, wnd_extra);
    if (wndProc) SetWindowLongPtrW(hWnd, GWLP_WNDPROC, (LONG_PTR)wndProc);
  }
 
  return hWnd;
}

Referenced by DoShellContextMenu(), CToolbarProxy::Initialize(), CBrandBand::SetSite(), CInternetToolbar::SetSite(), SHCreateDefaultWorkerWindow(), and CUserNotification::Show().

ShellMessageBoxWrapW()

int WINAPIV ShellMessageBoxWrapW	(	_In_opt_ HINSTANCE	hAppInst,
		_In_opt_ HWND	hWnd,
		_In_ LPCWSTR	lpcText,
		_In_opt_ LPCWSTR	lpcTitle,
		_In_ UINT	fuStyle,
			...
	)

SHEnableMenuItem()

UINT WINAPI SHEnableMenuItem	(	HMENU	hMenu,
		UINT	wItemID,
		BOOL	bEnable
	)

Definition at line 1781 of file ordinal.c.

{
  TRACE("%p, %u, %d\n", hMenu, wItemID, bEnable);
  return EnableMenuItem(hMenu, wItemID, bEnable ? MF_ENABLED : MF_GRAYED);
}

Referenced by CInternetToolbar::OnContextMenu(), CShellBrowser::OnInitMenuPopup(), CShellBrowser::UpdateGotoMenu(), and CShellBrowser::UpdateViewMenu().

SHExpandEnvironmentStringsA()

DWORD WINAPI SHExpandEnvironmentStringsA	(	LPCSTR	,
		LPSTR	,
		DWORD
	)

SHExpandEnvironmentStringsW()

DWORD WINAPI SHExpandEnvironmentStringsW	(	LPCWSTR	,
		LPWSTR	,
		DWORD
	)

Referenced by CShellLink::GetIconLocation(), CAddressEditBox::ParseNow(), CShellLink::SetIconLocation(), and CShellLink::SetPath().

SHFillRectClr()

DWORD WINAPI SHFillRectClr	(	HDC	hDC,
		LPCRECT	pRect,
		COLORREF	cRef
	)

Definition at line 2133 of file ordinal.c.

{
    COLORREF cOldColor = SetBkColor(hDC, cRef);
    ExtTextOutA(hDC, 0, 0, ETO_OPAQUE, pRect, 0, 0, 0);
    SetBkColor(hDC, cOldColor);
    return 0;
}

Referenced by CDefView::OnPrintClient().

SHFindDataBlock()

DATABLOCK_HEADER *WINAPI SHFindDataBlock	(	LPDBLIST	lpList,
		DWORD	dwSignature
	)

Definition at line 424 of file clist.c.

{
  TRACE("(%p,%d)\n", lpList, dwSignature);
 
  if(lpList)
  {
    while(lpList->cbSize)
    {
      if(lpList->dwSignature == dwSignature)
        return lpList; /* Matched */
      else if(lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature)
        return lpList + 1; /* Contained item matches */
 
      lpList = NextItem(lpList);
    }
  }
  return NULL;
}

Referenced by CShellLink::CopyDataBlock(), CShellLink::GetAdvertiseInfo(), CShellLink::GetIconLocation(), CShellLink::GetPath(), CShellLink::Load(), CShellLink::SetIconLocation(), CShellLink::SetPath(), and CShellLink::WriteAdvertiseInfo().

SHForwardContextMenuMsg()

HRESULT WINAPI SHForwardContextMenuMsg	(	IUnknown *	pUnk,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		LRESULT *	pResult,
		BOOL	useIContextMenu2
	)

Definition at line 11 of file rosordinal.c.

{
    HRESULT hr;
    IContextMenu3* pcmenu3;
    IContextMenu2* pcmenu2;
 
    if (!pUnk)
        return E_FAIL;
 
    /* First try to use the IContextMenu3 interface */
    hr = IUnknown_QueryInterface(pUnk, &IID_IContextMenu3, (void**)&pcmenu3);
    if (SUCCEEDED(hr))
    {
        hr = IContextMenu3_HandleMenuMsg2(pcmenu3, uMsg, wParam, lParam, pResult);
        IContextMenu3_Release(pcmenu3);
        return hr;
    }
 
    /* Return failure if we can't use the IContextMenu2 interface */
    if(!useIContextMenu2)
        return hr;
 
    /* Now try to use the IContextMenu2 interface */
    hr = IUnknown_QueryInterface(pUnk, &IID_IContextMenu2, (void**)&pcmenu2);
    if (FAILED(hr))
        return hr;
 
    hr = IContextMenu2_HandleMenuMsg(pcmenu2, uMsg, wParam, lParam);
    IContextMenu2_Release(pcmenu2);
    if (pResult)
        *pResult = 0;
    return hr == S_OK ? S_FALSE : hr;
}

Referenced by BrFolderDlgProc(), DumpMenu(), CDefaultContextMenu::HandleMenuMsg2(), MenuMessageForwarderWndProc(), CDefView::OnMenuMessage(), and ShellContextMenuWindowProc().

SHFreeDataBlockList()

VOID WINAPI SHFreeDataBlockList

(

LPDBLIST

lpList

)

Definition at line 331 of file clist.c.

{
  TRACE("(%p)\n", lpList);
 
  if (lpList)
    LocalFree(lpList);
}

Referenced by DumpCommand(), CShellLink::Reset(), and CShellLink::~CShellLink().

SHGetAppCompatFlags()

DWORD WINAPI SHGetAppCompatFlags

(

DWORD

dwMask

)

Definition at line 4565 of file ordinal.c.

{
  FIXME("(0x%08x) stub\n", dwUnknown);
  return 0;
}

Referenced by ShellExecuteA(), and ShellExecuteW().

SHGetCurColorRes()

DWORD WINAPI SHGetCurColorRes

(

void

)

Definition at line 2023 of file ordinal.c.

{
    HDC hdc;
    DWORD ret;
 
    TRACE("()\n");
 
    hdc = GetDC(0);
    ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
    ReleaseDC(0, hdc);
    return ret;
}

Referenced by CBrandBand::SelectImage(), and SIC_GetIconBPP().

SHGetIniStringUTF7W()

DWORD WINAPI SHGetIniStringUTF7W	(	_In_opt_z_ LPCWSTR	lpAppName,
		_In_z_ LPCWSTR	lpKeyName,
		_Out_writes_to_(nSize, return+1) _Post_z_ LPWSTR	lpReturnedString,
		_In_ DWORD	nSize,
		_In_z_ LPCWSTR	lpFileName
	)

Definition at line 722 of file propbag.cpp.

{
    if (*lpKeyName == L'@') // UTF-7
        return SHGetIniStringW(lpAppName, lpKeyName + 1, lpReturnedString, nSize, lpFileName);
 
    return GetPrivateProfileStringW(lpAppName, lpKeyName, L"", lpReturnedString, nSize, lpFileName);
}

Referenced by CIniPropertyBag::Read().

SHGetIniStringW()

DWORD WINAPI SHGetIniStringW	(	_In_z_ LPCWSTR	appName,
		_In_z_ LPCWSTR	keyName,
		_Out_writes_to_(outLen, return+1) LPWSTR	out,
		_In_ DWORD	outLen,
		_In_z_ LPCWSTR	filename
	)

Definition at line 602 of file propbag.cpp.

{
    TRACE("(%s,%s,%p,%08x,%s)\n", debugstr_w(appName), debugstr_w(keyName),
          out, outLen, debugstr_w(filename));
 
    if (outLen == 0)
        return 0;
 
    // Try ".W"-appended section name. See also SHSetIniStringW
    CStringW szSection(appName);
    szSection += L".W";
    CStringW pszWideBuff;
    const INT cchWideMax = 4 * MAX_PATH; // UTF-7 needs 4 times length buffer.
    GetPrivateProfileStringW(szSection, keyName, NULL,
                             pszWideBuff.GetBuffer(cchWideMax), cchWideMax, filename);
    pszWideBuff.ReleaseBuffer();
 
    if (pszWideBuff.IsEmpty()) // It's empty or not found
    {
        // Try the normal section name
        return GetPrivateProfileStringW(appName, keyName, NULL, out, outLen, filename);
    }
 
    // Okay, now ".W" version is valid. Its value is a UTF-7 string in UTF-16
    CW2A wide2utf7(pszWideBuff);
    MultiByteToWideChar(CP_UTF7, 0, wide2utf7, -1, out, outLen);
    out[outLen - 1] = UNICODE_NULL;
 
    return lstrlenW(out);
}

Referenced by SHGetIniStringUTF7W().

SHGetMenuFromID()

HMENU WINAPI SHGetMenuFromID	(	HMENU	hMenu,
		UINT	uID
	)

Definition at line 1997 of file ordinal.c.

{
  MENUITEMINFOW mi;
 
  TRACE("(%p,%u)\n", hMenu, uID);
 
  mi.cbSize = sizeof(mi);
  mi.fMask = MIIM_SUBMENU;
 
  if (!GetMenuItemInfoW(hMenu, uID, FALSE, &mi))
    return NULL;
 
  return mi.hSubMenu;
}

Referenced by CShellBrowser::BuildExplorerBandMenu(), CShellBrowser::OnInitMenuPopup(), and CShellBrowser::UpdateViewMenu().

SHGetObjectCompatFlags()

DWORD WINAPI SHGetObjectCompatFlags	(	IUnknown *	pUnk,
		const CLSID *	clsid
	)

Definition at line 6315 of file ordinal.c.

{
    static const WCHAR compatpathW[] =
        {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
         'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
         'S','h','e','l','l','C','o','m','p','a','t','i','b','i','l','i','t','y','\\',
         'O','b','j','e','c','t','s','\\','%','s',0};
    WCHAR strW[sizeof(compatpathW)/sizeof(WCHAR) + 38 /* { CLSID } */];
    DWORD ret, length = sizeof(strW)/sizeof(WCHAR);
    OLECHAR *clsid_str;
    HKEY key;
    INT i;
 
    TRACE("%p %s\n", pUnk, debugstr_guid(clsid));
 
    if (!pUnk && !clsid) return 0;
 
    if (pUnk && !clsid)
    {
        FIXME("iface not handled\n");
        return 0;
    }
 
    StringFromCLSID(clsid, &clsid_str);
    sprintfW(strW, compatpathW, clsid_str);
    CoTaskMemFree(clsid_str);
 
    ret = RegOpenKeyW(HKEY_LOCAL_MACHINE, strW, &key);
    if (ret != ERROR_SUCCESS) return 0;
 
    /* now collect flag values */
    ret = 0;
    for (i = 0; RegEnumValueW(key, i, strW, &length, NULL, NULL, NULL, NULL) == ERROR_SUCCESS; i++)
    {
        INT left, right, res, x;
 
        /* search in table */
        left  = 0;
        right = sizeof(objcompat_table) / sizeof(struct objcompat_entry) - 1;
 
        while (right >= left) {
            x = (left + right) / 2;
            res = strcmpW(strW, objcompat_table[x].name);
            if (res == 0)
            {
                ret |= objcompat_table[x].value;
                break;
            }
            else if (res < 0)
                right = x - 1;
            else
                left = x + 1;
        }
 
        length = sizeof(strW)/sizeof(WCHAR);
    }
 
    return ret;
}

Referenced by init_pointers(), and SHGetAttributes().

SHGetPathFromIDListWrapW()

BOOL WINAPI SHGetPathFromIDListWrapW	(	LPCITEMIDLIST	pidl,
		LPWSTR	pszPath
	)

Definition at line 3472 of file ordinal.c.

{
    return SHGetPathFromIDListW(pidl, pszPath);
}

Referenced by _ILIsNetworkPlace().

SHGetPerScreenResName()

INT WINAPI SHGetPerScreenResName	(	_Out_writes_(cchBuffer) LPWSTR	pszBuffer,
		_In_ INT	cchBuffer,
		_In_ DWORD	dwReserved
	)

Definition at line 1938 of file propbag.cpp.

{
    if (dwReserved)
        return 0;
 
    HDC hDC = ::GetDC(NULL);
    INT cxWidth = ::GetDeviceCaps(hDC, HORZRES);
    INT cyHeight = ::GetDeviceCaps(hDC, VERTRES);
    INT cMonitors = ::GetSystemMetrics(SM_CMONITORS);
    ::ReleaseDC(NULL, hDC);
 
    StringCchPrintfW(pszBuffer, cchBuffer, L"%dx%d(%d)", cxWidth, cyHeight, cMonitors);
    return lstrlenW(pszBuffer);
}

Referenced by CDefView::SaveViewState(), and SHPropertyBag_PerScreenRes().

SHGetShellKey()

HKEY WINAPI SHGetShellKey	(	DWORD	flags,
		LPCWSTR	sub_key,
		BOOL	create
	)

Definition at line 4622 of file ordinal.c.

{
#ifndef __REACTOS__
    enum _shellkey_flags {
        SHKEY_Root_HKCU = 0x1,
        SHKEY_Root_HKLM = 0x2,
        SHKEY_Key_Explorer  = 0x00,
        SHKEY_Key_Shell = 0x10,
        SHKEY_Key_ShellNoRoam = 0x20,
        SHKEY_Key_Classes = 0x30,
        SHKEY_Subkey_Default = 0x0000,
        SHKEY_Subkey_ResourceName = 0x1000,
        SHKEY_Subkey_Handlers = 0x2000,
        SHKEY_Subkey_Associations = 0x3000,
        SHKEY_Subkey_Volatile = 0x4000,
        SHKEY_Subkey_MUICache = 0x5000,
        SHKEY_Subkey_FileExts = 0x6000
    };
#endif
 
    static const WCHAR explorerW[] = {'S','o','f','t','w','a','r','e','\\',
        'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
        'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
        'E','x','p','l','o','r','e','r','\\'};
    static const WCHAR shellW[] = {'S','o','f','t','w','a','r','e','\\',
        'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
        'S','h','e','l','l','\\'};
    static const WCHAR shell_no_roamW[] = {'S','o','f','t','w','a','r','e','\\',
        'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
        'S','h','e','l','l','N','o','R','o','a','m','\\'};
    static const WCHAR classesW[] = {'S','o','f','t','w','a','r','e','\\',
        'C','l','a','s','s','e','s','\\'};
 
    static const WCHAR localized_resource_nameW[] = {'L','o','c','a','l','i','z','e','d',
        'R','e','s','o','u','r','c','e','N','a','m','e','\\'};
    static const WCHAR handlersW[] = {'H','a','n','d','l','e','r','s','\\'};
    static const WCHAR associationsW[] = {'A','s','s','o','c','i','a','t','i','o','n','s','\\'};
    static const WCHAR volatileW[] = {'V','o','l','a','t','i','l','e','\\'};
    static const WCHAR mui_cacheW[] = {'M','U','I','C','a','c','h','e','\\'};
    static const WCHAR file_extsW[] = {'F','i','l','e','E','x','t','s','\\'};
 
    WCHAR *path;
    const WCHAR *key, *subkey;
    int size_key, size_subkey, size_user;
    HKEY hkey = NULL;
 
    TRACE("(0x%08x, %s, %d)\n", flags, debugstr_w(sub_key), create);
 
    /* For compatibility with Vista+ */
    if(flags == 0x1ffff)
        flags = 0x21;
 
    switch(flags&0xff0) {
    case SHKEY_Key_Explorer:
        key = explorerW;
        size_key = sizeof(explorerW);
        break;
    case SHKEY_Key_Shell:
        key = shellW;
        size_key = sizeof(shellW);
        break;
    case SHKEY_Key_ShellNoRoam:
        key = shell_no_roamW;
        size_key = sizeof(shell_no_roamW);
        break;
    case SHKEY_Key_Classes:
        key = classesW;
        size_key = sizeof(classesW);
        break;
    default:
        FIXME("unsupported flags (0x%08x)\n", flags);
        return NULL;
    }
 
    switch(flags&0xff000) {
    case SHKEY_Subkey_Default:
        subkey = NULL;
        size_subkey = 0;
        break;
    case SHKEY_Subkey_ResourceName:
        subkey = localized_resource_nameW;
        size_subkey = sizeof(localized_resource_nameW);
        break;
    case SHKEY_Subkey_Handlers:
        subkey = handlersW;
        size_subkey = sizeof(handlersW);
        break;
    case SHKEY_Subkey_Associations:
        subkey = associationsW;
        size_subkey = sizeof(associationsW);
        break;
    case SHKEY_Subkey_Volatile:
        subkey = volatileW;
        size_subkey = sizeof(volatileW);
        break;
    case SHKEY_Subkey_MUICache:
        subkey = mui_cacheW;
        size_subkey = sizeof(mui_cacheW);
        break;
    case SHKEY_Subkey_FileExts:
        subkey = file_extsW;
        size_subkey = sizeof(file_extsW);
        break;
    default:
        FIXME("unsupported flags (0x%08x)\n", flags);
        return NULL;
    }
 
    if(sub_key)
        size_user = lstrlenW(sub_key)*sizeof(WCHAR);
    else
        size_user = 0;
 
    path = HeapAlloc(GetProcessHeap(), 0, size_key+size_subkey+size_user+sizeof(WCHAR));
    if(!path) {
        ERR("Out of memory\n");
        return NULL;
    }
 
    memcpy(path, key, size_key);
    if(subkey)
        memcpy(path+size_key/sizeof(WCHAR), subkey, size_subkey);
    if(sub_key)
        memcpy(path+(size_key+size_subkey)/sizeof(WCHAR), sub_key, size_user);
    path[(size_key+size_subkey+size_user)/sizeof(WCHAR)] = '\0';
 
    if(create)
        RegCreateKeyExW((flags&0xf)==SHKEY_Root_HKLM?HKEY_LOCAL_MACHINE:HKEY_CURRENT_USER,
                path, 0, NULL, 0, MAXIMUM_ALLOWED, NULL, &hkey, NULL);
    else
        RegOpenKeyExW((flags&0xf)==SHKEY_Root_HKLM?HKEY_LOCAL_MACHINE:HKEY_CURRENT_USER,
                path, 0, MAXIMUM_ALLOWED, &hkey);
 
    HeapFree(GetProcessHeap(), 0, path);
    return hkey;
}

Referenced by CViewStatePropertyBag::_GetHKey(), CDesktopUpgradePropertyBag::_GetOldDesktopViewStream(), init_pointers(), CGlobalFolderSettings::Load(), read_advanced_key(), CGlobalFolderSettings::Save(), SHGetSetSettings(), SKAllocValueW(), SKDeleteValueW(), SKGetValueW(), and SKSetValueW().

SHGetValueGoodBootA()

DWORD WINAPI SHGetValueGoodBootA	(	HKEY	hkey,
		LPCSTR	pSubKey,
		LPCSTR	pValue,
		LPDWORD	pwType,
		LPVOID	pvData,
		LPDWORD	pbData
	)

Definition at line 1877 of file reg.c.

{
  if (GetSystemMetrics(SM_CLEANBOOT))
    return ERROR_INVALID_FUNCTION;
  return SHGetValueA(hkey, pSubKey, pValue, pwType, pvData, pbData);
}

SHGetValueGoodBootW()

DWORD WINAPI SHGetValueGoodBootW	(	HKEY	hkey,
		LPCWSTR	pSubKey,
		LPCWSTR	pValue,
		LPDWORD	pwType,
		LPVOID	pvData,
		LPDWORD	pbData
	)

Definition at line 1890 of file reg.c.

{
  if (GetSystemMetrics(SM_CLEANBOOT))
    return ERROR_INVALID_FUNCTION;
  return SHGetValueW(hkey, pSubKey, pValue, pwType, pvData, pbData);
}

SHGlobalCounterCreate()

HANDLE WINAPI SHGlobalCounterCreate

(

REFGUID

guid

)

Definition at line 551 of file thread.c.

{
  char szName[40];
 
  TRACE("(%s)\n", debugstr_guid(guid));
 
  /* Create a named semaphore using the GUID string */
  SHStringFromGUIDA(guid, szName, sizeof(szName) - 1);
  return SHGlobalCounterCreateNamedA(szName, 0);
}

Referenced by SHELL_GetCachedGlobalCounter().

SHGlobalCounterGetValue()

LONG WINAPI SHGlobalCounterGetValue

(

HANDLE

hGlobalCounter

)

Definition at line 432 of file thread.c.

{
  LONG dwOldCount = 0;
 
  TRACE("(%p)\n", hSem);
  ReleaseSemaphore(hSem, 1, &dwOldCount); /* +1 */
  WaitForSingleObject(hSem, 0);           /* -1 */
  return dwOldCount;
}

Referenced by SHELL_QueryRestrictionsChanged(), and SHGlobalCounterDecrement().

SHGlobalCounterIncrement()

LONG WINAPI SHGlobalCounterIncrement

(

HANDLE

hGlobalCounter

)

Definition at line 453 of file thread.c.

{
  LONG dwOldCount = 0;
 
  TRACE("(%p)\n", hSem);
  ReleaseSemaphore(hSem, 1, &dwOldCount);
  return dwOldCount + 1;
}

Referenced by SHSettingsChanged().

SHInterlockedCompareExchange()

PVOID WINAPI SHInterlockedCompareExchange	(	PVOID *	dest,
		PVOID	xchg,
		PVOID	compare
	)

Definition at line 3501 of file ordinal.c.

{
    return InterlockedCompareExchangePointer( dest, xchg, compare );
}

SHInvokeDefaultCommand()

HRESULT WINAPI SHInvokeDefaultCommand	(	HWND	hWnd,
		IShellFolder *	lpFolder,
		LPCITEMIDLIST	lpApidl
	)

Definition at line 3060 of file ordinal.c.

{
    TRACE("%p %p %p\n", hWnd, lpFolder, lpApidl);
#ifdef __REACTOS__
    return SHInvokeCommand(hWnd, lpFolder, lpApidl, NULL);
#else
    return SHInvokeCommand(hWnd, lpFolder, lpApidl, 0);
#endif
}

Referenced by CMenuCallback::CallbackSM(), CStartMenuSite::Execute(), CAddressEditBox::Execute(), CShellBrowser::OnOrganizeFavorites(), and CISFBand::OnWinEvent().

SHIsChildOrSelf()

BOOL WINAPI SHIsChildOrSelf	(	HWND	hParent,
		HWND	hChild
	)

Definition at line 2254 of file ordinal.c.

{
  TRACE("(%p,%p)\n", hParent, hChild);
 
  if (!hParent || !hChild)
    return TRUE;
  else if(hParent == hChild)
    return FALSE;
  return !IsChild(hParent, hChild);
}

SHIsEmptyStream()

BOOL WINAPI SHIsEmptyStream

(

IStream *

lpStream

)

Definition at line 567 of file istream.c.

{
  STATSTG statstg;
  BOOL bRet = TRUE;
 
  TRACE("(%p)\n", lpStream);
 
  memset(&statstg, 0, sizeof(statstg));
 
  if(SUCCEEDED(IStream_Stat(lpStream, &statstg, 1)))
  {
    if(statstg.cbSize.QuadPart)
      bRet = FALSE; /* Non-Zero */
  }
  else
  {
    DWORD dwDummy;
 
    /* Try to read from the stream */
    if(SUCCEEDED(SHIStream_Read(lpStream, &dwDummy, sizeof(dwDummy))))
    {
      LARGE_INTEGER zero;
      zero.QuadPart = 0;
 
      IStream_Seek(lpStream, zero, 0, NULL);
      bRet = FALSE; /* Non-Zero */
    }
  }
  return bRet;
}

SHIsExpandableFolder()

HRESULT WINAPI SHIsExpandableFolder	(	LPSHELLFOLDER	lpFolder,
		LPCITEMIDLIST	pidl
	)

Definition at line 2088 of file ordinal.c.

{
  HRESULT hRet = E_INVALIDARG;
  IQueryInfo *lpInfo;
 
  if (lpFolder && pidl)
  {
    hRet = IShellFolder_GetUIObjectOf(lpFolder, NULL, 1, &pidl, &IID_IQueryInfo,
                                      NULL, (void**)&lpInfo);
    if (FAILED(hRet))
      hRet = S_FALSE; /* Doesn't expose IQueryInfo */
    else
    {
      DWORD dwFlags = 0;
 
      /* MSDN states of IQueryInfo_GetInfoFlags() that "This method is not
       * currently used". Really? You wouldn't be holding out on me would you?
       */
      hRet = IQueryInfo_GetInfoFlags(lpInfo, &dwFlags);
 
      if (SUCCEEDED(hRet))
      {
        /* 0x2 is an undocumented flag apparently indicating expandability */
        hRet = dwFlags & 0x2 ? S_OK : S_FALSE;
      }
 
      IQueryInfo_Release(lpInfo);
    }
  }
  return hRet;
}

SHIsSameObject()

BOOL WINAPI SHIsSameObject	(	IUnknown *	lpInt1,
		IUnknown *	lpInt2
	)

Definition at line 1289 of file ordinal.c.

{
  IUnknown *lpUnknown1, *lpUnknown2;
  BOOL ret;
 
  TRACE("(%p %p)\n", lpInt1, lpInt2);
 
  if (!lpInt1 || !lpInt2)
    return FALSE;
 
  if (lpInt1 == lpInt2)
    return TRUE;
 
  if (IUnknown_QueryInterface(lpInt1, &IID_IUnknown, (void**)&lpUnknown1) != S_OK)
    return FALSE;
 
  if (IUnknown_QueryInterface(lpInt2, &IID_IUnknown, (void**)&lpUnknown2) != S_OK)
  {
    IUnknown_Release(lpUnknown1);
    return FALSE;
  }
 
  ret = lpUnknown1 == lpUnknown2;
 
  IUnknown_Release(lpUnknown1);
  IUnknown_Release(lpUnknown2);
 
  return ret;
}

SHLoadMenuPopup()

BOOL WINAPI SHLoadMenuPopup	(	HINSTANCE	hInst,
		LPCWSTR	szName
	)

Definition at line 1666 of file ordinal.c.

{
  HMENU hMenu;
 
  TRACE("%p %s\n", hInst, debugstr_w(szName));
 
  if ((hMenu = LoadMenuW(hInst, szName)))
  {
    if (GetSubMenu(hMenu, 0))
      RemoveMenu(hMenu, 0, MF_BYPOSITION);
 
    DestroyMenu(hMenu);
    return TRUE;
  }
  return FALSE;
}

SHLoadRegUIStringA()

HRESULT WINAPI SHLoadRegUIStringA	(	HKEY	hkey,
		LPCSTR	value,
		LPSTR	buf,
		DWORD	size
	)

SHLoadRegUIStringW()

HRESULT WINAPI SHLoadRegUIStringW	(	HKEY	hkey,
		LPCWSTR	value,
		LPWSTR	buf,
		DWORD	size
	)

Definition at line 4277 of file ordinal.c.

{
    DWORD type, sz = size * sizeof(WCHAR);
 
    if(RegQueryValueExW(hkey, value, NULL, &type, (LPBYTE)buf, &sz) != ERROR_SUCCESS)
        return E_FAIL;
 
    return SHLoadIndirectString(buf, buf, size, NULL);
}

Referenced by CBandSiteMenu::_CreateMenuPart(), CRegTreeOptions::AddItemsFromRegistry(), and GetKbdLayoutNameFromReg().

SHLockSharedEx()

PVOID WINAPI SHLockSharedEx	(	HANDLE	hData,
		DWORD	dwProcessId,
		BOOL	bWriteAccess
	)

Referenced by CreateNotificationParam(), CreateRegistrationParam(), CChangeNotifyServer::DeliverNotification(), DoGetHandbagFromTicket(), CChangeNotifyServer::OnRegister(), SHChangeNotifyRegister(), and SHLockShared().

SHMenuIndexFromID()

DWORD WINAPI SHMenuIndexFromID	(	HMENU	hMenu,
		UINT	uID
	)

Definition at line 4541 of file ordinal.c.

{
    TRACE("%p %u\n", hMenu, uID);
    return GetMenuPosFromID(hMenu, uID);
}

Referenced by CDefView::FillViewMenu().

SHPinDllOfCLSID()

HMODULE WINAPI SHPinDllOfCLSID

(

REFIID

refiid

)

Definition at line 2537 of file ordinal.c.

{
    HKEY newkey;
    DWORD type, count;
    CHAR value[MAX_PATH], string[MAX_PATH];
 
    strcpy(string, "CLSID\\");
    SHStringFromGUIDA(refiid, string + 6, sizeof(string)/sizeof(char) - 6);
    strcat(string, "\\InProcServer32");
 
    count = MAX_PATH;
    RegOpenKeyExA(HKEY_CLASSES_ROOT, string, 0, 1, &newkey);
    RegQueryValueExA(newkey, 0, 0, &type, (PBYTE)value, &count);
    RegCloseKey(newkey);
    return LoadLibraryExA(value, 0, 0);
}

Referenced by SHAutoComplete().

SHPropagateMessage()

void WINAPI SHPropagateMessage	(	HWND	hWnd,
		UINT	uiMsgId,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	bSend
	)

Definition at line 1719 of file ordinal.c.

{
  enumWndData data;
 
  TRACE("(%p,%u,%ld,%ld,%d)\n", hWnd, uiMsgId, wParam, lParam, bSend);
 
  if(hWnd)
  {
    data.uiMsgId = uiMsgId;
    data.wParam  = wParam;
    data.lParam  = lParam;
 
    if (bSend)
      data.pfnPost = IsWindowUnicode(hWnd) ? (void*)SendMessageW : (void*)SendMessageA;
    else
      data.pfnPost = IsWindowUnicode(hWnd) ? (void*)PostMessageW : (void*)PostMessageA;
 
    EnumChildWindows(hWnd, SHLWAPI_EnumChildProc, (LPARAM)&data);
  }
}

Referenced by CShellBrowser::OnSettingChange(), and CShellBrowser::OnSysColorChange().

SHPropertyBag_Delete()

HRESULT WINAPI SHPropertyBag_Delete	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName
	)

Referenced by CDefView::SaveViewState(), and SHPropertyBag_WriteTest().

SHPropertyBag_ReadBOOL()

HRESULT WINAPI SHPropertyBag_ReadBOOL	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		BOOL *	pbValue
	)

Referenced by SHPropertyBag_ReadTest().

SHPropertyBag_ReadBOOLOld()

BOOL WINAPI SHPropertyBag_ReadBOOLOld	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		BOOL	bDefValue
	)

SHPropertyBag_ReadBSTR()

HRESULT WINAPI SHPropertyBag_ReadBSTR	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		BSTR *	pbstr
	)

Referenced by SHPropertyBag_ReadTest().

SHPropertyBag_ReadDWORD()

HRESULT WINAPI SHPropertyBag_ReadDWORD	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		DWORD *	pdwValue
	)

Referenced by CDefView::LoadViewState(), ReadDWORD(), and SHPropertyBag_ReadTest().

SHPropertyBag_ReadGUID()

HRESULT WINAPI SHPropertyBag_ReadGUID	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		GUID *	pguid
	)

Referenced by SHPropertyBag_ReadTest().

SHPropertyBag_ReadInt()

HRESULT WINAPI SHPropertyBag_ReadInt	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		LPINT	pnValue
	)

SHPropertyBag_ReadLONG()

HRESULT WINAPI SHPropertyBag_ReadLONG	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		LPLONG	pValue
	)

Definition at line 5622 of file ordinal.c.

{
#ifdef __REACTOS__
    HRESULT hr;
    VARIANTARG varg;
 
    TRACE("%p %s %p\n", ppb, debugstr_w(pszPropName), pValue);
 
    if (!ppb || !pszPropName || !pValue)
    {
        ERR("%p %s %p\n", ppb, debugstr_w(pszPropName), pValue);
        return E_INVALIDARG;
    }
 
    hr = SHPropertyBag_ReadType(ppb, pszPropName, &varg, VT_I4);
    if (SUCCEEDED(hr))
        *pValue = V_I4(&varg);
#else
    VARIANT var;
    HRESULT hr;
    TRACE("%p %s %p\n", ppb,debugstr_w(pszPropName),pValue);
    if (!pszPropName || !ppb || !pValue)
        return E_INVALIDARG;
    V_VT(&var) = VT_I4;
    hr = IPropertyBag_Read(ppb, pszPropName, &var, NULL);
    if (SUCCEEDED(hr))
    {
        if (V_VT(&var) == VT_I4)
            *pValue = V_I4(&var);
        else
            hr = DISP_E_BADVARTYPE;
    }
#endif
    return hr;
}

Referenced by init_pointers(), and SHPropertyBag_ReadTest().

SHPropertyBag_ReadPOINTL()

HRESULT WINAPI SHPropertyBag_ReadPOINTL	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		POINTL *	pptl
	)

Referenced by SHPropertyBag_ReadTest().

SHPropertyBag_ReadPOINTS()

HRESULT WINAPI SHPropertyBag_ReadPOINTS	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		POINTS *	ppts
	)

Referenced by SHPropertyBag_ReadTest().

SHPropertyBag_ReadRECTL()

HRESULT WINAPI SHPropertyBag_ReadRECTL	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		RECTL *	prcl
	)

Referenced by SHPropertyBag_ReadTest().

SHPropertyBag_ReadSHORT()

HRESULT WINAPI SHPropertyBag_ReadSHORT	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		SHORT *	psValue
	)

Referenced by SHPropertyBag_ReadTest().

SHPropertyBag_ReadStr()

HRESULT WINAPI SHPropertyBag_ReadStr	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		LPWSTR	pszDst,
		int	cchMax
	)

SHPropertyBag_ReadStream()

HRESULT WINAPI SHPropertyBag_ReadStream	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		IStream **	ppStream
	)

Referenced by CDefView::LoadViewState().

SHPropertyBag_ReadType()

HRESULT WINAPI SHPropertyBag_ReadType	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		VARIANTARG *	pvarg,
		VARTYPE	vt
	)

Referenced by SHPropertyBag_ReadLONG().

SHPropertyBag_WriteBOOL()

HRESULT WINAPI SHPropertyBag_WriteBOOL	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		BOOL	bValue
	)

Referenced by SHPropertyBag_WriteTest().

SHPropertyBag_WriteDWORD()

HRESULT WINAPI SHPropertyBag_WriteDWORD	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		DWORD	dwValue
	)

Referenced by CDefView::SaveViewState(), and SHPropertyBag_WriteTest().

SHPropertyBag_WriteGUID()

HRESULT WINAPI SHPropertyBag_WriteGUID	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		const GUID *	pguid
	)

Referenced by SHPropertyBag_WriteTest().

SHPropertyBag_WriteInt()

HRESULT WINAPI SHPropertyBag_WriteInt	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		INT	nValue
	)

SHPropertyBag_WriteLONG()

HRESULT WINAPI SHPropertyBag_WriteLONG	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		LONG	lValue
	)

Referenced by SHPropertyBag_WriteTest().

SHPropertyBag_WritePOINTL()

HRESULT WINAPI SHPropertyBag_WritePOINTL	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		const POINTL *	pptl
	)

Referenced by SHPropertyBag_WriteTest().

SHPropertyBag_WritePOINTS()

HRESULT WINAPI SHPropertyBag_WritePOINTS	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		const POINTS *	ppts
	)

Referenced by SHPropertyBag_WriteTest().

SHPropertyBag_WriteRECTL()

HRESULT WINAPI SHPropertyBag_WriteRECTL	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		const RECTL *	prcl
	)

Referenced by SHPropertyBag_WriteTest().

SHPropertyBag_WriteSHORT()

HRESULT WINAPI SHPropertyBag_WriteSHORT	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		SHORT	sValue
	)

Referenced by SHPropertyBag_WriteTest().

SHPropertyBag_WriteStr()

HRESULT WINAPI SHPropertyBag_WriteStr	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		LPCWSTR	pszValue
	)

Referenced by SHPropertyBag_WriteTest().

SHPropertyBag_WriteStream()

HRESULT WINAPI SHPropertyBag_WriteStream	(	IPropertyBag *	ppb,
		LPCWSTR	pszPropName,
		IStream *	pStream
	)

Referenced by CDefView::SaveViewState().

SHReadDataBlockList()

HRESULT WINAPI SHReadDataBlockList	(	IStream *	lpStream,
		LPDBLIST *	lppList
	)

Definition at line 235 of file clist.c.

{
  DATABLOCK_HEADER bBuff[128]; /* Temporary storage for new list item */
  ULONG ulBuffSize = sizeof(bBuff);
  LPDATABLOCK_HEADER pItem = bBuff;
  ULONG ulRead, ulSize;
  HRESULT hRet = S_OK;
 
  TRACE("(%p,%p)\n", lpStream, lppList);
 
  if(*lppList)
  {
    /* Free any existing list */
    LocalFree(*lppList);
    *lppList = NULL;
  }
 
  do
  {
    /* Read the size of the next item */
    hRet = IStream_Read(lpStream, &ulSize,sizeof(ulSize),&ulRead);
 
    if(FAILED(hRet) || ulRead != sizeof(ulSize) || !ulSize)
      break; /* Read failed or read zero size (the end of the list) */
 
    if(ulSize > 0xFFFF)
    {
      LARGE_INTEGER liZero;
      ULARGE_INTEGER ulPos;
 
      liZero.QuadPart = 0;
 
      /* Back the stream up; this object is too big for the list */
      if(SUCCEEDED(IStream_Seek(lpStream, liZero, STREAM_SEEK_CUR, &ulPos)))
      {
        liZero.QuadPart = ulPos.QuadPart - sizeof(ULONG);
        IStream_Seek(lpStream, liZero, STREAM_SEEK_SET, NULL);
      }
      break;
    }
    else if (ulSize >= sizeof(DATABLOCK_HEADER))
    {
      /* Add this new item to the list */
      if(ulSize > ulBuffSize)
      {
        /* We need more buffer space, allocate it */
        LPDATABLOCK_HEADER lpTemp;
 
        if (pItem == bBuff)
          lpTemp = LocalAlloc(LMEM_ZEROINIT, ulSize);
        else
          lpTemp = LocalReAlloc(pItem, ulSize, LMEM_ZEROINIT|LMEM_MOVEABLE);
 
        if(!lpTemp)
        {
          hRet = E_OUTOFMEMORY;
          break;
        }
        ulBuffSize = ulSize;
        pItem = lpTemp;
      }
 
      pItem->cbSize = ulSize;
      ulSize -= sizeof(pItem->cbSize); /* already read this member */
 
      /* Read the item Id and data */
      hRet = IStream_Read(lpStream, &pItem->dwSignature, ulSize, &ulRead);
 
      if(FAILED(hRet) || ulRead != ulSize)
        break;
 
      SHAddDataBlock(lppList, pItem); /* Insert Item */
    }
  } while(1);
 
  /* If we allocated space, free it */
  if(pItem != bBuff)
    LocalFree(pItem);
 
  return hRet;
}

Referenced by DumpCommand(), and CShellLink::Load().

SHRegGetCLSIDKeyW()

HRESULT WINAPI SHRegGetCLSIDKeyW	(	REFGUID	guid,
		LPCWSTR	lpszValue,
		BOOL	bUseHKCU,
		BOOL	bCreate,
		PHKEY	phKey
	)

Definition at line 2422 of file reg.c.

{
#ifndef __REACTOS__
  static const WCHAR szClassIdKey[] = { 'S','o','f','t','w','a','r','e','\\',
    'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
    'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
    'E','x','p','l','o','r','e','r','\\','C','L','S','I','D','\\' };
#endif
#define szClassIdKeyLen (sizeof(szClassIdKey)/sizeof(WCHAR))
  WCHAR szKey[MAX_PATH];
  DWORD dwRet;
  HKEY hkey;
 
  /* Create the key string */
#ifdef __REACTOS__
  // https://www.geoffchappell.com/studies/windows/shell/shlwapi/api/reg/reggetclsidkey.htm
  WCHAR* ptr;
 
  wcscpy(szKey, bUseHKCU ? L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CLSID\\" : L"CLSID\\");
  ptr = szKey + wcslen(szKey);
  SHStringFromGUIDW(guid, ptr, 39); /* Append guid */
  if (lpszValue)
  {
      ptr = szKey + wcslen(szKey);
      wcscat(ptr, L"\\");
      wcscat(++ptr, lpszValue);
  }
#else
  memcpy(szKey, szClassIdKey, sizeof(szClassIdKey));
  SHStringFromGUIDW(guid, szKey + szClassIdKeyLen, 39); /* Append guid */
 
  if(lpszValue)
  {
    szKey[szClassIdKeyLen + 39] = '\\';
    strcpyW(szKey + szClassIdKeyLen + 40, lpszValue); /* Append value name */
  }
#endif
 
  hkey = bUseHKCU ? HKEY_CURRENT_USER : HKEY_CLASSES_ROOT;
 
  if(bCreate)
    dwRet = RegCreateKeyW(hkey, szKey, phKey);
  else
    dwRet = RegOpenKeyExW(hkey, szKey, 0, KEY_READ, phKey);
 
  return dwRet ? HRESULT_FROM_WIN32(dwRet) : S_OK;
}

Referenced by CFileSysEnum::_AddFindResult(), SHELL32_GetFSItemAttributes(), and SHRegGetCLSIDKeyA().

SHRegisterClassA()

DWORD WINAPI SHRegisterClassA

(

WNDCLASSA *

wndclass

)

Definition at line 1817 of file ordinal.c.

{
  WNDCLASSA wca;
  if (GetClassInfoA(wndclass->hInstance, wndclass->lpszClassName, &wca))
    return TRUE;
  return (DWORD)RegisterClassA(wndclass);
}

Referenced by SHCreateWorkerWindowA().

SHRemoveAllSubMenus()

DWORD WINAPI SHRemoveAllSubMenus

(

HMENU

hMenu

)

Definition at line 1752 of file ordinal.c.

{
  int iItemCount = GetMenuItemCount(hMenu) - 1;
 
  TRACE("%p\n", hMenu);
 
  while (iItemCount >= 0)
  {
    HMENU hSubMenu = GetSubMenu(hMenu, iItemCount);
    if (hSubMenu)
      RemoveMenu(hMenu, iItemCount, MF_BYPOSITION);
    iItemCount--;
  }
  return iItemCount;
}

SHRemoveDataBlock()

BOOL WINAPI SHRemoveDataBlock	(	LPDBLIST *	lppList,
		DWORD	dwSignature
	)

Definition at line 355 of file clist.c.

{
  LPDATABLOCK_HEADER lpList = NULL;
  LPDATABLOCK_HEADER lpItem = NULL;
  LPDATABLOCK_HEADER lpNext;
  ULONG ulNewSize;
 
  TRACE("(%p,%d)\n", lppList, dwSignature);
 
  if(lppList && (lpList = *lppList))
  {
    /* Search for item in list */
    while (lpList->cbSize)
    {
      if(lpList->dwSignature == dwSignature ||
        (lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature))
      {
        lpItem = lpList; /* Found */
        break;
      }
      lpList = NextItem(lpList);
    }
  }
 
  if(!lpItem)
    return FALSE;
 
  lpList = lpNext = NextItem(lpItem);
 
  /* Locate the end of the list */
  while (lpList->cbSize)
    lpList = NextItem(lpList);
 
  /* Resize the list */
  ulNewSize = LocalSize(*lppList) - lpItem->cbSize;
 
  /* Copy following elements over lpItem */
  memmove(lpItem, lpNext, (char *)lpList - (char *)lpNext + sizeof(ULONG));
 
  if(ulNewSize <= sizeof(ULONG))
  {
    LocalFree(*lppList);
    *lppList = NULL; /* Removed the last element */
  }
  else
  {
    lpList = LocalReAlloc(*lppList, ulNewSize, LMEM_ZEROINIT|LMEM_MOVEABLE);
    if(lpList)
      *lppList = lpList;
  }
  return TRUE;
}

Referenced by CShellLink::RemoveDataBlock().

SHRestrictionLookup()

DWORD WINAPI SHRestrictionLookup	(	_In_ DWORD	policy,
		_In_ LPCWSTR	key,
		_In_ const POLICYDATA *	polTable,
		_Inout_ LPDWORD	polArr
	)

SHRunIndirectRegClientCommand()

HRESULT WINAPI SHRunIndirectRegClientCommand	(	_In_ HWND	hWnd,
		_In_ PCWSTR	pszClientType
	)

SHSearchMapInt()

int WINAPI SHSearchMapInt	(	const int *	lpKeys,
		const int *	lpValues,
		int	iLen,
		int	iKey
	)

Definition at line 2161 of file ordinal.c.

{
  if (lpKeys && lpValues)
  {
    int i = 0;
 
    while (i < iLen)
    {
      if (lpKeys[i] == iKey)
        return lpValues[i]; /* Found */
      i++;
    }
  }
  return -1; /* Not found */
}

Referenced by init_pointers().

SHSendMessageBroadcastW()

DWORD WINAPI SHSendMessageBroadcastW	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 4072 of file ordinal.c.

{
    return SendMessageTimeoutW(HWND_BROADCAST, uMsg, wParam, lParam,
                               SMTO_ABORTIFHUNG, 2000, NULL);
}

Referenced by IntSetUnderlineState(), SHGetSetSettings(), and ViewDlg_Apply().

SHSetDefaultDialogFont()

VOID WINAPI SHSetDefaultDialogFont	(	HWND	hWnd,
		INT	id
	)

Definition at line 2457 of file ordinal.c.

{
#ifdef __REACTOS__
    HFONT hOldFont, hNewFont;
    LOGFONTW lfOldFont, lfNewFont;
    HWND hwndItem;
 
    TRACE("(%p, %d)\n", hWnd, id);
 
    hOldFont = (HFONT)SendMessageW(hWnd, WM_GETFONT, 0, 0);
    GetObjectW(hOldFont, sizeof(lfOldFont), &lfOldFont);
    SystemParametersInfoW(SPI_GETICONTITLELOGFONT, sizeof(lfNewFont), &lfNewFont, 0);
 
    if (lfOldFont.lfCharSet == lfNewFont.lfCharSet)
        return;
 
    hNewFont = GetPropW(hWnd, L"PropDlgFont");
    if (!hNewFont)
    {
        /* Create the icon-title font of the same height */
        lfNewFont.lfHeight = lfOldFont.lfHeight;
        hNewFont = CreateFontIndirectW(&lfNewFont);
 
        /* If creating the font is failed, then keep the old font */
        if (!hNewFont)
            hNewFont = hOldFont;
 
        /* Set "PropDlgFont" property if the font is changed */
        if (hOldFont != hNewFont)
            SetPropW(hWnd, L"PropDlgFont", hNewFont);
    }
 
    hwndItem = GetDlgItem(hWnd, id);
    SendMessageW(hwndItem, WM_SETFONT, (WPARAM)hNewFont, 0);
#else
    FIXME("(%p, %d) stub\n", hWnd, id);
    return S_OK;
#endif
}

SHSetIniStringUTF7W()

BOOL WINAPI SHSetIniStringUTF7W	(	_In_z_ LPCWSTR	lpAppName,
		_In_z_ LPCWSTR	lpKeyName,
		_In_opt_z_ LPCWSTR	lpString,
		_In_z_ LPCWSTR	lpFileName
	)

Definition at line 748 of file propbag.cpp.

{
    if (*lpKeyName == L'@') // UTF-7
        return SHSetIniStringW(lpAppName, lpKeyName + 1, lpString, lpFileName);
 
    return WritePrivateProfileStringW(lpAppName, lpKeyName, lpString, lpFileName);
}

Referenced by CIniPropertyBag::Write().

SHSetIniStringW()

BOOL WINAPI SHSetIniStringW	(	_In_z_ LPCWSTR	appName,
		_In_z_ LPCWSTR	keyName,
		_In_opt_z_ LPCWSTR	str,
		_In_z_ LPCWSTR	filename
	)

Definition at line 658 of file propbag.cpp.

{
    TRACE("(%s, %p, %s, %s)\n", debugstr_w(appName), keyName, debugstr_w(str),
          debugstr_w(filename));
 
    // Write a normal profile string. If str was NULL, then key will be deleted
    if (!WritePrivateProfileStringW(appName, keyName, str, filename))
        return FALSE;
 
    if (Is7BitClean(str))
    {
        // Delete ".A" version
        CStringW szSection(appName);
        szSection += L".A";
        WritePrivateProfileStringW(szSection, keyName, NULL, filename);
 
        // Delete ".W" version
        szSection = appName;
        szSection += L".W";
        WritePrivateProfileStringW(szSection, keyName, NULL, filename);
 
        return TRUE;
    }
 
    // Now str is not 7-bit clean. It needs UTF-7 encoding in UTF-16.
    // We write ".A" and ".W"-appended sections
    CW2A wide2utf7(str, CP_UTF7);
    CA2W utf72wide(wide2utf7, CP_ACP);
 
    BOOL ret = TRUE;
 
    // Write ".A" version
    CStringW szSection(appName);
    szSection += L".A";
    if (!WritePrivateProfileStringW(szSection, keyName, str, filename))
        ret = FALSE;
 
    // Write ".W" version
    szSection = appName;
    szSection += L".W";
    if (!WritePrivateProfileStringW(szSection, keyName, utf72wide, filename))
        ret = FALSE;
 
    return ret;
}

Referenced by SHSetIniStringUTF7W().

SHSetParentHwnd()

HWND WINAPI SHSetParentHwnd	(	HWND	hWnd,
		HWND	hWndParent
	)

Definition at line 1158 of file ordinal.c.

{
  TRACE("%p, %p\n", hWnd, hWndParent);
 
  if(GetParent(hWnd) == hWndParent)
    return NULL;
 
  if(hWndParent)
    SHSetWindowBits(hWnd, GWL_STYLE, WS_CHILD | WS_POPUP, WS_CHILD);
  else
    SHSetWindowBits(hWnd, GWL_STYLE, WS_CHILD | WS_POPUP, WS_POPUP);
 
  return hWndParent ? SetParent(hWnd, hWndParent) : NULL;
}

Referenced by init_pointers().

SHSetWindowBits()

LONG WINAPI SHSetWindowBits	(	HWND	hwnd,
		INT	offset,
		UINT	wMask,
		UINT	wFlags
	)

Definition at line 1130 of file ordinal.c.

{
  LONG ret = GetWindowLongW(hwnd, offset);
  LONG new_flags = (flags & mask) | (ret & ~mask);
 
  TRACE("%p %d %x %x\n", hwnd, offset, mask, flags);
 
  if (new_flags != ret)
    ret = SetWindowLongW(hwnd, offset, new_flags);
  return ret;
}

Referenced by CMenuDeskBar::_AdjustForTheme(), init_pointers(), CShellBrowser::OnToggleFullscreen(), SetWindowExStyle(), SetWindowStyle(), and SHSetParentHwnd().

SHSimulateDrop()

BOOL WINAPI SHSimulateDrop	(	IDropTarget *	pDrop,
		IDataObject *	pDataObj,
		DWORD	grfKeyState,
		PPOINTL	lpPt,
		DWORD *	pdwEffect
	)

Definition at line 1828 of file ordinal.c.

{
  DWORD dwEffect = DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY;
  POINTL pt = { 0, 0 };
 
  TRACE("%p %p 0x%08x %p %p\n", pDrop, pDataObj, grfKeyState, lpPt, pdwEffect);
 
  if (!lpPt)
    lpPt = &pt;
 
  if (!pdwEffect)
    pdwEffect = &dwEffect;
 
  IDropTarget_DragEnter(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);
 
  if (*pdwEffect != DROPEFFECT_NONE)
    return IDropTarget_Drop(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);
 
  IDropTarget_DragLeave(pDrop);
  return TRUE;
}

Referenced by CDefaultContextMenu::DoCreateLink(), CDefaultContextMenu::DoDelete(), CDefaultContextMenu::DoPaste(), CCPLItemMenu::InvokeCommand(), and CDefaultContextMenu::InvokeRegVerb().

SHUnicodeToAnsi()

INT WINAPI SHUnicodeToAnsi	(	LPCWSTR	lpSrcStr,
		LPSTR	lpDstStr,
		INT	iLen
	)

Definition at line 2797 of file string.c.

{
    return SHUnicodeToAnsiCP(CP_ACP, lpSrcStr, lpDstStr, iLen);
}

Referenced by CheckEscapesA(), DoesStringRoundTripW(), CDefaultContextMenu::GetCommandString(), GetCommandStringA(), CStartMenuBtnCtxMenu::InvokeCommand(), CDefView::InvokeContextMenuCommand(), MakeShellURLFromPathA(), CAutoComplete::OnNotify(), PathQualifyA(), PathResolveA(), SHBrowseForFolderA(), SHELL_IsVerb(), SHELL_MapContextMenuVerbToCmdId(), SHInvokeCommandOnContextMenuInternal(), and ViewDlg_OnInitDialog().

SHUnicodeToAnsiCP()

DWORD WINAPI SHUnicodeToAnsiCP	(	UINT	CodePage,
		LPCWSTR	lpSrcStr,
		LPSTR	lpDstStr,
		int	dstlen
	)

Definition at line 2698 of file string.c.

{
  static const WCHAR emptyW[] = { '\0' };
  int len , reqLen;
  LPSTR mem;
 
  if (!lpDstStr || !dstlen)
    return 0;
 
  if (!lpSrcStr)
    lpSrcStr = emptyW;
 
  *lpDstStr = '\0';
 
  len = strlenW(lpSrcStr) + 1;
 
  switch (CodePage)
  {
  case CP_WINUNICODE:
    CodePage = CP_UTF8; /* Fall through... */
  case 0x0000C350: /* FIXME: CP_ #define */
  case CP_UTF7:
  case CP_UTF8:
    {
      DWORD dwMode = 0;
      INT lenW = len - 1;
      INT needed = dstlen - 1;
      HRESULT hr;
 
      /* try the user supplied buffer first */
      hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &lenW, lpDstStr, &needed);
      if (hr == S_OK)
      {
        lpDstStr[needed] = '\0';
        return needed + 1;
      }
 
      /* user buffer too small. exclude termination and copy as much as possible */
      lenW = len;
      hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &lenW, NULL, &needed);
      needed++;
      mem = HeapAlloc(GetProcessHeap(), 0, needed);
      if (!mem)
        return 0;
 
      hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &len, mem, &needed);
      if (hr == S_OK)
      {
          reqLen = SHTruncateString(mem, dstlen);
          if (reqLen > 0) memcpy(lpDstStr, mem, reqLen-1);
      }
      HeapFree(GetProcessHeap(), 0, mem);
      return 0;
    }
  default:
    break;
  }
 
  /* try the user supplied buffer first */
  reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, lpDstStr, dstlen, NULL, NULL);
 
  if (!reqLen && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
  {
    reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, NULL, 0, NULL, NULL);
    if (reqLen)
    {
      mem = HeapAlloc(GetProcessHeap(), 0, reqLen);
      if (mem)
      {
        WideCharToMultiByte(CodePage, 0, lpSrcStr, len, mem, reqLen, NULL, NULL);
 
        reqLen = SHTruncateString(mem, dstlen -1);
        reqLen++;
 
        lstrcpynA(lpDstStr, mem, reqLen);
        HeapFree(GetProcessHeap(), 0, mem);
        lpDstStr[reqLen-1] = '\0';
      }
    }
  }
  return reqLen;
}

Referenced by SHUnicodeToAnsi().

SHWaitForSendMessageThread()

DWORD WINAPI SHWaitForSendMessageThread	(	HANDLE	hand,
		DWORD	dwTimeout
	)

Definition at line 2050 of file ordinal.c.

{
  DWORD dwEndTicks = GetTickCount() + dwTimeout;
  DWORD dwRet;
 
  while ((dwRet = MsgWaitForMultipleObjectsEx(1, &hand, dwTimeout, QS_SENDMESSAGE, 0)) == 1)
  {
    MSG msg;
 
    PeekMessageW(&msg, NULL, 0, 0, PM_NOREMOVE);
 
    if (dwTimeout != INFINITE)
    {
        if ((int)(dwTimeout = dwEndTicks - GetTickCount()) <= 0)
            return WAIT_TIMEOUT;
    }
  }
 
  return dwRet;
}

SHWriteDataBlockList()

HRESULT WINAPI SHWriteDataBlockList	(	IStream *	lpStream,
		LPDBLIST	lpList
	)

Definition at line 179 of file clist.c.

{
  ULONG ulSize;
  HRESULT hRet = S_OK;
 
  TRACE("(%p,%p)\n", lpStream, lpList);
 
  if(lpList)
  {
    while (lpList->cbSize)
    {
      LPDATABLOCK_HEADER lpItem = lpList;
 
      if(lpList->dwSignature == CLIST_ID_CONTAINER)
        lpItem++;
 
      hRet = IStream_Write(lpStream,lpItem,lpItem->cbSize,&ulSize);
      if (FAILED(hRet))
        return hRet;
 
      if(lpItem->cbSize != ulSize)
        return STG_E_MEDIUMFULL;
 
      lpList = NextItem(lpList);
    }
  }
 
  if(SUCCEEDED(hRet))
  {
    ULONG ulDummy;
    ulSize = 0;
 
    /* Write a terminating list entry with zero size */
    hRet = IStream_Write(lpStream, &ulSize,sizeof(ulSize),&ulDummy);
  }
 
  return hRet;
}

Referenced by CShellLink::Save().

STDMETHOD_() [1/2]

STDMETHOD_	(	ULONG	,
		AddRef
	)

STDMETHOD_() [2/2]

STDMETHOD_	(	ULONG	,
		Release
	)