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	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	PathIsValidChar   PathIsValidCharA
#define	StrCpyNX   StrCpyNXA
#define	FixSlashesAndColon   FixSlashesAndColonA
#define	SHACF_CONTEXTMENU   0x00000001
#define	SHACF_FLUSHNOWAITALWAYS   SHACF_CONTEXTMENU
#define	SHACF_DOCOBJECT   0x00000002
#define	SHACF_CORELINTERNETENUM   0x00000004
#define	SHACF_OLDCREATEVIEWWND   SHACF_CORELINTERNETENUM
#define	SHACF_WIN95DEFVIEW   SHACF_CORELINTERNETENUM
#define	SHACF_MYCOMPUTERFIRST   0x00000008
#define	SHACF_OLDREGITEMGDN   0x00000010
#define	SHACF_LOADCOLUMNHANDLER   0x00000040
#define	SHACF_ANSI   0x00000080
#define	SHACF_UNKNOWN1   0x00000100
#define	SHACF_WIN95SHLEXEC   0x00000200
#define	SHACF_STAROFFICE5PRINTER   0x00000400
#define	SHACF_NOVALIDATEFSIDS   0x00000800
#define	SHACF_FILEOPENNEEDSEXT   0x00001000
#define	SHACF_WIN95BINDTOOBJECT   0x00002000
#define	SHACF_IGNOREENUMRESET   0x00004000
#define	SHACF_ANSIDISPLAYNAMES   0x00010000
#define	SHACF_FILEOPENBOGUSCTRLID   0x00020000
#define	SHACF_FORCELFNIDLIST   0x00040000
#define	SHACF_UNKNOWN2   0x01000000
#define	SHACF_UNKNOWN3   0x80000000
#define	E_DATATYPE_MISMATCH   HRESULT_FROM_WIN32(ERROR_DATATYPE_MISMATCH)
#define	ZoneCheckUrlExCache   ZoneCheckUrlExCacheA
#define	ZoneCheckPath   ZoneCheckPathA
#define	ZoneCheckUrl   ZoneCheckUrlA
#define	ZoneCheckUrlEx   ZoneCheckUrlExA

Typedefs
typedef struct tagPOLICYDATA	POLICYDATA
typedef struct tagPOLICYDATA *	LPPOLICYDATA
typedef INT_PTR(CALLBACK *	SHDIALOGPROC) (PVOID pThis, HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

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)
HRESULT WINAPI	CLSIDFromStringWrap (_In_ LPCWSTR idstr, _Out_ CLSID *id)
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)
HRESULT WINAPI	SHInvokeCommandsOnContextMenu (_In_opt_ HWND hwnd, _In_opt_ IUnknown *punkSite, _In_ IContextMenu *pCM, _In_ DWORD fMask, _In_reads_opt_(cVerbs) PCSTR *pVerbs, _In_ UINT cVerbs)
HRESULT WINAPI	MayQSForward (_In_ IUnknown *lpUnknown, _In_ INT nUnknown, _In_opt_ REFGUID riidCmdGrp, _In_ ULONG cCmds, _Inout_ OLECMD *prgCmds, _Inout_ OLECMDTEXT *pCmdText)
HRESULT WINAPI	MayExecForward (_In_ IUnknown *lpUnknown, _In_ INT nUnknown, _In_opt_ REFGUID pguidCmdGroup, _In_ DWORD nCmdID, _In_ DWORD nCmdexecopt, _In_ VARIANT *pvaIn, _Inout_ VARIANT *pvaOut)
HRESULT WINAPI	IsQSForward (_In_opt_ REFGUID pguidCmdGroup, _In_ ULONG cCmds, _In_ 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)
HRESULT WINAPI	QuerySourceCreateFromKey (_In_ HKEY hKey, _In_opt_ PCWSTR lpSubKey, _In_ BOOL bCreate, _In_ REFIID riid, _Outptr_ PVOID *ppv)
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)
HRESULT WINAPI	IStream_ReadPidl (_In_ IStream *pstm, _Out_ LPITEMIDLIST *ppidlOut)
HRESULT WINAPI	IStream_WritePidl (_In_ IStream *pstm, _In_ LPCITEMIDLIST pidlWrite)
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	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	PathUnExpandEnvStringsForUserA (_In_ HANDLE hUserToken, _In_ PCSTR pszPath, _Out_writes_(cchBuff) PSTR pszBuff, _In_ INT cchBuff)
BOOL WINAPI	PathUnExpandEnvStringsForUserW (_In_ HANDLE hUserToken, _In_ PCWSTR pwszPath, _Out_writes_(cchBuff) PWSTR pszBuff, _In_ INT cchBuff)
BOOL WINAPI	PathFindOnPathExW (LPWSTR lpszFile, LPCWSTR *lppszOtherDirs, DWORD dwWhich)
VOID WINAPI	FixSlashesAndColonA (_Inout_ LPSTR lpstr)
VOID WINAPI	FixSlashesAndColonW (_Inout_ LPWSTR lpwstr)
BOOL WINAPI	PathIsValidCharA (char c, DWORD dwClass)
BOOL WINAPI	PathIsValidCharW (WCHAR c, DWORD dwClass)
BOOL WINAPI	SHGetPathFromIDListWrapW (LPCITEMIDLIST pidl, LPWSTR pszPath)
DECLSPEC_IMPORT BOOL WINAPI	PathFileExistsAndAttributesA (LPCSTR lpszPath, DWORD *dwAttr)
DECLSPEC_IMPORT BOOL WINAPI	PathFileExistsAndAttributesW (LPCWSTR lpszPath, DWORD *dwAttr)
LPSTR WINAPI	StrCpyNXA (LPSTR lpszDest, LPCSTR lpszSrc, int iLen)
LPWSTR WINAPI	StrCpyNXW (LPWSTR lpszDest, LPCWSTR lpszSrc, int iLen)
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 (_In_ DWORD dwMask)
HRESULT WINAPI	IUnknown_QueryServiceForWebBrowserApp (_In_ IUnknown *lpUnknown, _In_ REFGUID riid, _Out_ LPVOID *lppOut)
INT_PTR WINAPI	SHDialogBox (_In_opt_ HINSTANCE hInstance, _In_ PCSTR lpTemplateName, _In_opt_ HWND hWndParent, _In_opt_ SHDIALOGPROC fn, _In_opt_ PVOID pThis)
PSTR WINAPI	CharLowerNoDBCSA (_Inout_ PSTR lpString)
PWSTR WINAPI	CharLowerNoDBCSW (_Inout_ PWSTR lpString)
PSTR WINAPI	CharUpperNoDBCSA (_Inout_ PSTR lpString)
PWSTR WINAPI	CharUpperNoDBCSW (_Inout_ PWSTR lpString)
HRESULT WINAPI	SHWindowsPolicyGetValue (_In_ REFGUID rpolid, _Out_opt_ PVOID pvValue, _Out_opt_ PDWORD pcbValue)
HRESULT WINAPI	ZoneCheckUrlExCacheA (_In_ PCSTR pszUrl, _Out_writes_bytes_opt_(cbPolicy) PBYTE pbPolicy, _In_ DWORD cbPolicy, _In_reads_bytes_opt_(cbContext) PBYTE pbContext, _In_ DWORD cbContext, _In_ DWORD dwAction, _In_ DWORD dwFlags, _In_opt_ IInternetSecurityMgrSite *pSecuritySite, _In_opt_ IInternetSecurityManager *pISM)
HRESULT WINAPI	ZoneCheckUrlExCacheW (_In_ PCWSTR pszUrl, _Out_writes_bytes_opt_(cbPolicy) PBYTE pbPolicy, _In_ DWORD cbPolicy, _In_reads_bytes_opt_(cbContext) PBYTE pbContext, _In_ DWORD cbContext, _In_ DWORD dwAction, _In_ DWORD dwFlags, _In_opt_ IInternetSecurityMgrSite *pSecuritySite, _In_opt_ IInternetSecurityManager *pISM)
HRESULT WINAPI	ZoneCheckPathA (_In_ PCSTR pszPath, _In_ DWORD dwAction, _In_ DWORD dwFlags, _In_opt_ IInternetSecurityMgrSite *pSecuritySite)
HRESULT WINAPI	ZoneCheckPathW (_In_ PCWSTR pszPath, _In_ DWORD dwAction, _In_ DWORD dwFlags, _In_opt_ IInternetSecurityMgrSite *pSecuritySite)
HRESULT WINAPI	ZoneCheckUrlA (_In_ PCSTR pszUrl, _In_ DWORD dwAction, _In_ DWORD dwFlags, _In_opt_ IInternetSecurityMgrSite *pSecuritySite)
HRESULT WINAPI	ZoneCheckUrlW (_In_ PCWSTR pszUrl, _In_ DWORD dwAction, _In_ DWORD dwFlags, _In_opt_ IInternetSecurityMgrSite *pSecuritySite)
HRESULT WINAPI	ZoneCheckUrlExA (_In_ PCSTR pszUrl, _Out_writes_bytes_opt_(cbPolicy) PBYTE pbPolicy, _In_ DWORD cbPolicy, _In_reads_bytes_opt_(cbContext) PBYTE pbContext, _In_ DWORD cbContext, _In_ DWORD dwAction, _In_ DWORD dwFlags, _In_opt_ IInternetSecurityMgrSite *pSecuritySite)
HRESULT WINAPI	ZoneCheckUrlExW (_In_ PCWSTR pszUrl, _Out_writes_bytes_opt_(cbPolicy) PBYTE pbPolicy, _In_ DWORD cbPolicy, _In_reads_bytes_opt_(cbContext) PBYTE pbContext, _In_ DWORD cbContext, _In_ DWORD dwAction, _In_ DWORD dwFlags, _In_opt_ IInternetSecurityMgrSite *pSecuritySite)
HRESULT WINAPI	ZoneCheckHost (_In_ IInternetSecurityManager *pISM, _In_ PCWSTR pszUrl, _In_ DWORD dwAction)
HRESULT WINAPI	ZoneCheckHostEx (_In_ IInternetSecurityManager *pISM, _Out_writes_bytes_opt_(cbPolicy) PBYTE pbPolicy, _In_ DWORD cbPolicy, _In_reads_bytes_opt_(cbContext) PBYTE pbContext, _In_ DWORD cbContext, _In_ PCWSTR pszUrl, _In_ DWORD dwAction)

Macro Definition Documentation

E_DATATYPE_MISMATCH

#define E_DATATYPE_MISMATCH   HRESULT_FROM_WIN32(ERROR_DATATYPE_MISMATCH)

Definition at line 494 of file shlwapi_undoc.h.

FixSlashesAndColon

#define FixSlashesAndColon   FixSlashesAndColonA

Definition at line 417 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_ANY

#define PATH_CHAR_CLASS_ANY   0xffffffff

Definition at line 369 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_ASTERIX

#define PATH_CHAR_CLASS_ASTERIX   0x00000002

Definition at line 359 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_BACKSLASH

#define PATH_CHAR_CLASS_BACKSLASH   0x00000008

Definition at line 361 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_COLON

#define PATH_CHAR_CLASS_COLON   0x00000010

Definition at line 362 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_COMMA

#define PATH_CHAR_CLASS_COMMA   0x00000040

Definition at line 364 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_DOT

#define PATH_CHAR_CLASS_DOT   0x00000004

Definition at line 360 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_DOUBLEQUOTE

#define PATH_CHAR_CLASS_DOUBLEQUOTE   0x00000200

Definition at line 367 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_INVALID

#define PATH_CHAR_CLASS_INVALID   0x00000000

Definition at line 368 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_LETTER

#define PATH_CHAR_CLASS_LETTER   0x00000001

Definition at line 358 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_OTHER_VALID

#define PATH_CHAR_CLASS_OTHER_VALID   0x00000100

Definition at line 366 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_SEMICOLON

#define PATH_CHAR_CLASS_SEMICOLON   0x00000020

Definition at line 363 of file shlwapi_undoc.h.

PATH_CHAR_CLASS_SPACE

#define PATH_CHAR_CLASS_SPACE   0x00000080

Definition at line 365 of file shlwapi_undoc.h.

PathIsValidChar

#define PathIsValidChar   PathIsValidCharA

Definition at line 415 of file shlwapi_undoc.h.

SHAboutInfo

#define SHAboutInfo   SHAboutInfoA

Definition at line 66 of file shlwapi_undoc.h.

SHACF_ANSI

#define SHACF_ANSI   0x00000080

Definition at line 444 of file shlwapi_undoc.h.

SHACF_ANSIDISPLAYNAMES

#define SHACF_ANSIDISPLAYNAMES   0x00010000

Definition at line 453 of file shlwapi_undoc.h.

SHACF_CONTEXTMENU

#define SHACF_CONTEXTMENU   0x00000001

Definition at line 434 of file shlwapi_undoc.h.

SHACF_CORELINTERNETENUM

#define SHACF_CORELINTERNETENUM   0x00000004

Definition at line 437 of file shlwapi_undoc.h.

SHACF_DOCOBJECT

#define SHACF_DOCOBJECT   0x00000002

Definition at line 436 of file shlwapi_undoc.h.

SHACF_FILEOPENBOGUSCTRLID

#define SHACF_FILEOPENBOGUSCTRLID   0x00020000

Definition at line 454 of file shlwapi_undoc.h.

SHACF_FILEOPENNEEDSEXT

#define SHACF_FILEOPENNEEDSEXT   0x00001000

Definition at line 449 of file shlwapi_undoc.h.

SHACF_FLUSHNOWAITALWAYS

#define SHACF_FLUSHNOWAITALWAYS   SHACF_CONTEXTMENU

Definition at line 435 of file shlwapi_undoc.h.

SHACF_FORCELFNIDLIST

#define SHACF_FORCELFNIDLIST   0x00040000

Definition at line 455 of file shlwapi_undoc.h.

SHACF_IGNOREENUMRESET

#define SHACF_IGNOREENUMRESET   0x00004000

Definition at line 451 of file shlwapi_undoc.h.

SHACF_LOADCOLUMNHANDLER

#define SHACF_LOADCOLUMNHANDLER   0x00000040

Definition at line 443 of file shlwapi_undoc.h.

SHACF_MYCOMPUTERFIRST

#define SHACF_MYCOMPUTERFIRST   0x00000008

Definition at line 440 of file shlwapi_undoc.h.

SHACF_NOVALIDATEFSIDS

#define SHACF_NOVALIDATEFSIDS   0x00000800

Definition at line 448 of file shlwapi_undoc.h.

SHACF_OLDCREATEVIEWWND

#define SHACF_OLDCREATEVIEWWND   SHACF_CORELINTERNETENUM

Definition at line 438 of file shlwapi_undoc.h.

SHACF_OLDREGITEMGDN

#define SHACF_OLDREGITEMGDN   0x00000010

Definition at line 441 of file shlwapi_undoc.h.

SHACF_STAROFFICE5PRINTER

#define SHACF_STAROFFICE5PRINTER   0x00000400

Definition at line 447 of file shlwapi_undoc.h.

SHACF_UNKNOWN1

#define SHACF_UNKNOWN1   0x00000100

Definition at line 445 of file shlwapi_undoc.h.

SHACF_UNKNOWN2

#define SHACF_UNKNOWN2   0x01000000

Definition at line 457 of file shlwapi_undoc.h.

SHACF_UNKNOWN3

#define SHACF_UNKNOWN3   0x80000000

Definition at line 458 of file shlwapi_undoc.h.

SHACF_WIN95BINDTOOBJECT

#define SHACF_WIN95BINDTOOBJECT   0x00002000

Definition at line 450 of file shlwapi_undoc.h.

SHACF_WIN95DEFVIEW

#define SHACF_WIN95DEFVIEW   SHACF_CORELINTERNETENUM

Definition at line 439 of file shlwapi_undoc.h.

SHACF_WIN95SHLEXEC

#define SHACF_WIN95SHLEXEC   0x00000200

Definition at line 446 of file shlwapi_undoc.h.

SHCreateWorkerWindow

#define SHCreateWorkerWindow   SHCreateWorkerWindowA

Definition at line 250 of file shlwapi_undoc.h.

SHELL_GCOUNTER_DECLAREPARAMETERS

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

Definition at line 52 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 40 of file shlwapi_undoc.h.

SHELL_GCOUNTER_DEFINE_HANDLE

#define SHELL_GCOUNTER_DEFINE_HANDLE

(

name

)

HANDLE name = NULL

Definition at line 41 of file shlwapi_undoc.h.

SHELL_GCOUNTER_PARAMETERS

#define SHELL_GCOUNTER_PARAMETERS	(		handle,
			id
	)		handle

Definition at line 42 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 43 of file shlwapi_undoc.h.

SHELL_GlobalCounterGet

#define SHELL_GlobalCounterGet

(

handle

)

SHGlobalCounterGetValue(handle)

Definition at line 49 of file shlwapi_undoc.h.

SHELL_GlobalCounterIncrement

#define SHELL_GlobalCounterIncrement

(

handle

)

SHGlobalCounterIncrement(handle)

Definition at line 50 of file shlwapi_undoc.h.

SHELL_GlobalCounterIsInitialized

#define SHELL_GlobalCounterIsInitialized

(

handle

)

( (handle) != NULL )

Definition at line 48 of file shlwapi_undoc.h.

SHELL_NO_POLICY

#define SHELL_NO_POLICY   ((DWORD)-1)

Definition at line 17 of file shlwapi_undoc.h.

SHExpandEnvironmentStrings

#define SHExpandEnvironmentStrings   SHExpandEnvironmentStringsA

Definition at line 166 of file shlwapi_undoc.h.

SHGetValueGoodBoot

#define SHGetValueGoodBoot   SHGetValueGoodBootA

Definition at line 282 of file shlwapi_undoc.h.

SHLoadRegUIString

#define SHLoadRegUIString   SHLoadRegUIStringA

Definition at line 283 of file shlwapi_undoc.h.

StrCpyNX

#define StrCpyNX   StrCpyNXA

Definition at line 416 of file shlwapi_undoc.h.

WHICH_BAT

#define WHICH_BAT   (1 << 3)

Definition at line 350 of file shlwapi_undoc.h.

WHICH_CMD

#define WHICH_CMD   (1 << 5)

Definition at line 352 of file shlwapi_undoc.h.

WHICH_COM

#define WHICH_COM   (1 << 1)

Definition at line 348 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 355 of file shlwapi_undoc.h.

WHICH_EXE

#define WHICH_EXE   (1 << 2)

Definition at line 349 of file shlwapi_undoc.h.

WHICH_LNK

#define WHICH_LNK   (1 << 4)

Definition at line 351 of file shlwapi_undoc.h.

WHICH_OPTIONAL

#define WHICH_OPTIONAL   (1 << 6)

Definition at line 353 of file shlwapi_undoc.h.

WHICH_PIF

#define WHICH_PIF   (1 << 0)

Definition at line 347 of file shlwapi_undoc.h.

ZoneCheckPath

#define ZoneCheckPath   ZoneCheckPathA

Definition at line 597 of file shlwapi_undoc.h.

ZoneCheckUrl

#define ZoneCheckUrl   ZoneCheckUrlA

Definition at line 598 of file shlwapi_undoc.h.

ZoneCheckUrlEx

#define ZoneCheckUrlEx   ZoneCheckUrlExA

Definition at line 599 of file shlwapi_undoc.h.

ZoneCheckUrlExCache

#define ZoneCheckUrlExCache   ZoneCheckUrlExCacheA

Definition at line 596 of file shlwapi_undoc.h.

Typedef Documentation

LPPOLICYDATA

typedef struct tagPOLICYDATA * LPPOLICYDATA

POLICYDATA

typedef struct tagPOLICYDATA POLICYDATA

SHDIALOGPROC

typedef INT_PTR(CALLBACK * SHDIALOGPROC) (PVOID pThis, HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

Definition at line 468 of file shlwapi_undoc.h.

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 316 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

CharLowerNoDBCSA()

PSTR WINAPI CharLowerNoDBCSA

(

_Inout_ PSTR

lpString

)

Definition at line 250 of file utils.cpp.

{
    return CharLowerNoDBCSAWorker(lpString, 0, FALSE) ? lpString : NULL;
}

CharLowerNoDBCSW()

PWSTR WINAPI CharLowerNoDBCSW

(

_Inout_ PWSTR

lpString

)

Definition at line 258 of file utils.cpp.

{
    return CharLowerNoDBCSWWorker(lpString, 0, FALSE) ? lpString : NULL;
}

CharUpperNoDBCSA()

PSTR WINAPI CharUpperNoDBCSA

(

_Inout_ PSTR

lpString

)

Definition at line 266 of file utils.cpp.

{
    return CharLowerNoDBCSAWorker(lpString, 0, TRUE) ? lpString : NULL;
}

CharUpperNoDBCSW()

PWSTR WINAPI CharUpperNoDBCSW

(

_Inout_ PWSTR

lpString

)

Definition at line 274 of file utils.cpp.

{
    return CharLowerNoDBCSWWorker(lpString, 0, TRUE) ? lpString : NULL;
}

CLSIDFromStringWrap()

HRESULT WINAPI CLSIDFromStringWrap	(	_In_ LPCWSTR	idstr,
		_Out_ CLSID *	id
	)

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().

FixSlashesAndColonA()

VOID WINAPI FixSlashesAndColonA

(

_Inout_ LPSTR

lpstr

)

FixSlashesAndColonW()

VOID WINAPI FixSlashesAndColonW

(

_Inout_ LPWSTR

lpwstr

)

IContextMenu_Invoke()

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

Definition at line 532 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	(	_In_opt_ REFGUID	pguidCmdGroup,
		_In_ ULONG	cCmds,
		_In_ OLECMD *	prgCmds
	)

IStream_ReadPidl()

HRESULT WINAPI IStream_ReadPidl	(	_In_ IStream *	pstm,
		_Out_ LPITEMIDLIST *	ppidlOut
	)

IStream_WritePidl()

HRESULT WINAPI IStream_WritePidl	(	_In_ IStream *	pstm,
		_In_ LPCITEMIDLIST	pidlWrite
	)

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(), MayExecForwardMockup(), 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 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 4468 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 5003 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_QueryServiceForWebBrowserApp()

HRESULT WINAPI IUnknown_QueryServiceForWebBrowserApp	(	_In_ IUnknown *	lpUnknown,
		_In_ REFGUID	riid,
		_Out_ LPVOID *	lppOut
	)

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(), MayQSForwardMockup(), CInternetToolbar::OnMenuDropDown(), CAddressBand::QueryStatus(), CMenuSite::QueryStatus(), and CShellBrowser::UpdateViewMenu().

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 CTrayWindow::OnActivate(), CTrayWindow::OnSetFocus(), CMenuDeskBar::UIActivateIO(), CBaseBarSite::UIActivateIO(), CBaseBar::UIActivateIO(), and CMenuSite::UIActivateIO().

MayExecForward()

HRESULT WINAPI MayExecForward	(	_In_ IUnknown *	lpUnknown,
		_In_ INT	nUnknown,
		_In_opt_ REFGUID	pguidCmdGroup,
		_In_ DWORD	nCmdID,
		_In_ DWORD	nCmdexecopt,
		_In_ VARIANT *	pvaIn,
		_Inout_ VARIANT *	pvaOut
	)

MayQSForward()

HRESULT WINAPI MayQSForward	(	_In_ IUnknown *	lpUnknown,
		_In_ INT	nUnknown,
		_In_opt_ REFGUID	riidCmdGrp,
		_In_ ULONG	cCmds,
		_Inout_ OLECMD *	prgCmds,
		_Inout_ OLECMDTEXT *	pCmdText
	)

PathFileExistsAndAttributesA()

DECLSPEC_IMPORT BOOL WINAPI PathFileExistsAndAttributesA	(	LPCSTR	lpszPath,
		DWORD *	dwAttr
	)

Definition at line 1853 of file path.c.

{
  UINT iPrevErrMode;
  DWORD dwVal = 0;
 
  TRACE("(%s %p)\n", debugstr_a(lpszPath), dwAttr);
 
  if (dwAttr)
    *dwAttr = INVALID_FILE_ATTRIBUTES;
 
  if (!lpszPath)
    return FALSE;
 
  iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
  dwVal = GetFileAttributesA(lpszPath);
  SetErrorMode(iPrevErrMode);
  if (dwAttr)
    *dwAttr = dwVal;
  return (dwVal != INVALID_FILE_ATTRIBUTES);
}

PathFileExistsAndAttributesW()

DECLSPEC_IMPORT BOOL WINAPI PathFileExistsAndAttributesW	(	LPCWSTR	lpszPath,
		DWORD *	dwAttr
	)

Definition at line 1879 of file path.c.

{
  UINT iPrevErrMode;
  DWORD dwVal;
 
  TRACE("(%s %p)\n", debugstr_w(lpszPath), dwAttr);
 
  if (!lpszPath)
    return FALSE;
 
  iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
  dwVal = GetFileAttributesW(lpszPath);
  SetErrorMode(iPrevErrMode);
  if (dwAttr)
    *dwAttr = dwVal;
  return (dwVal != INVALID_FILE_ATTRIBUTES);
}

PathFileExistsDefExtAndAttributesW()

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

Definition at line 636 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 1126 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 1360 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 2213 of file path.c.

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

PathIsValidCharW()

BOOL WINAPI PathIsValidCharW	(	WCHAR	c,
		DWORD	dwClass
	)

Definition at line 2221 of file path.c.

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

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

PathUnExpandEnvStringsForUserA()

BOOL WINAPI PathUnExpandEnvStringsForUserA	(	_In_ HANDLE	hUserToken,
		_In_ PCSTR	pszPath,
		_Out_writes_(cchBuff) PSTR	pszBuff,
		_In_ INT	cchBuff
	)

Definition at line 136 of file utils.cpp.

{
    static const PCSTR c_varsA[] =
    {
        "%APPDATA%",
        "%USERPROFILE%",
        "%ALLUSERSPROFILE%",
        "%ProgramFiles%",
        "%SystemRoot%",
        "%SystemDrive%",
    };
 
    if (!pszPath)
    {
        if (pszBuff && cchBuff)
            *pszBuff = ANSI_NULL;
 
        return FALSE;
    }
 
    if (!pszBuff)
        return FALSE;
 
    for (size_t iVar = 0; iVar < _countof(c_varsA); ++iVar)
    {
        if (UnExpandEnvironmentStringForUserA(hUserToken, pszPath, c_varsA[iVar],
                                              pszBuff, cchBuff))
        {
            return TRUE;
        }
    }
 
    return FALSE;
}

PathUnExpandEnvStringsForUserW()

BOOL WINAPI PathUnExpandEnvStringsForUserW	(	_In_ HANDLE	hUserToken,
		_In_ PCWSTR	pwszPath,
		_Out_writes_(cchBuff) PWSTR	pszBuff,
		_In_ INT	cchBuff
	)

Definition at line 182 of file utils.cpp.

{
    static const PCWSTR c_varsW[] =
    {
        L"%APPDATA%",
        L"%USERPROFILE%",
        L"%ALLUSERSPROFILE%",
        L"%ProgramFiles%",
        L"%SystemRoot%",
        L"%SystemDrive%",
    };
 
    if (!pwszPath)
    {
        if (pszBuff && cchBuff)
            *pszBuff = UNICODE_NULL;
 
        return FALSE;
    }
 
    if (!pszBuff)
        return FALSE;
 
    for (size_t iVar = 0; iVar < _countof(c_varsW); ++iVar)
    {
        if (UnExpandEnvironmentStringForUserW(hUserToken, pwszPath, c_varsW[iVar],
                                              pszBuff, cchBuff))
        {
            return TRUE;
        }
    }
 
    return FALSE;
}

QuerySourceCreateFromKey()

HRESULT WINAPI QuerySourceCreateFromKey	(	_In_ HKEY	hKey,
		_In_opt_ PCWSTR	lpSubKey,
		_In_ BOOL	bCreate,
		_In_ REFIID	riid,
		_Outptr_ PVOID *	ppv
	)

Definition at line 494 of file querysrc.cpp.

{
    *ppv = NULL;
 
    CRegistrySource* pRS = new CRegistrySource();
 
    HRESULT hr = pRS->Init(hKey, lpSubKey, bCreate);
    if (SUCCEEDED(hr))
        hr = pRS->QueryInterface(riid, ppv);
 
    pRS->Release();
    return hr;
}

Referenced by CRegistrySource::OpenSource().

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 586 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 572 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 2778 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 CRegTreeOptions::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 2798 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 3127 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().

SHDialogBox()

INT_PTR WINAPI SHDialogBox	(	_In_opt_ HINSTANCE	hInstance,
		_In_ PCSTR	lpTemplateName,
		_In_opt_ HWND	hWndParent,
		_In_opt_ SHDIALOGPROC	fn,
		_In_opt_ PVOID	pThis
	)

Definition at line 871 of file utils.cpp.

{
    SHDIALOG data = { fn, pThis };
    return DialogBoxParamA(hInstance, lpTemplateName, hWndParent, SHDialogProc, (LPARAM)&data);
}

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

(

_In_ DWORD

dwMask

)

Definition at line 433 of file appcompat.c.

{
    TRACE("(0x%lX)\n", dwMask);
 
    // Initialize and retrieve flags if necessary
    if (dwMask & SHACF_TO_INIT)
    {
        if (!g_fAppCompatInitialized)
        {
            DWORD dwAppCompatFlags = SHLWAPI_InitAppCompat();
            InterlockedExchange((PLONG)&g_dwAppCompatFlags, dwAppCompatFlags);
 
            g_fAppCompatInitialized = TRUE; // Mark as initialized
        }
    }
 
    // Retrieve additional flags if necessary
    DWORD dwAppCompatFlags = g_dwAppCompatFlags;
    if (dwAppCompatFlags && (dwMask & (SHACF_UNKNOWN1 | SHACF_UNKNOWN2)))
    {
        // Find the target window and its flags using g_wndCompatInfo
        APPCOMPATENUM data =
        {
            g_wndCompatInfo, _countof(g_wndCompatInfo), GetCurrentProcessId(), -1
        };
        EnumWindows(SHLWAPI_WndCompatEnumProc, (LPARAM)&data);
 
        // Add the target flags if a match is found
        if (data.iFound >= 0)
            dwAppCompatFlags |= g_wndCompatInfo[data.iFound].dwCompatFlags;
 
        dwAppCompatFlags |= SHACF_UNKNOWN3;
 
        InterlockedExchange((PLONG)&g_dwAppCompatFlags, dwAppCompatFlags);
    }
 
    return dwAppCompatFlags;
}

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 _SHMergePopupMenus(), CShellBrowser::BuildExplorerBandMenu(), CShellBrowser::OnInitMenuPopup(), and CShellBrowser::UpdateViewMenu().

SHGetObjectCompatFlags()

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

Definition at line 6530 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 3595 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 4821 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(), InitializeServerAdminUI(), IsOS(), 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 1919 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 1932 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 CPolicyCache::Initialize(), and 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 CPolicyCache::_ValidateCachedResults(), 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 3624 of file ordinal.c.

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

SHInvokeCommandsOnContextMenu()

HRESULT WINAPI SHInvokeCommandsOnContextMenu	(	_In_opt_ HWND	hwnd,
		_In_opt_ IUnknown *	punkSite,
		_In_ IContextMenu *	pCM,
		_In_ DWORD	fMask,
		_In_reads_opt_(cVerbs) PCSTR *	pVerbs,
		_In_ UINT	cVerbs
	)

Definition at line 411 of file utils.cpp.

{
    HRESULT hr;
    CMINVOKECOMMANDINFOEX ici;
    WCHAR szVerbW[MAX_PATH];
    HMENU hMenu = NULL;
    UINT iVerb, idDefault = (UINT)-1;
    PCSTR pszVerbA = NULL;
 
    if (!pCM)
        return E_INVALIDARG;
 
    hMenu = CreatePopupMenu();
    if (!hMenu)
        return E_OUTOFMEMORY;
 
    if (punkSite)
        IUnknown_SetSite(pCM, punkSite);
 
    hr = pCM->QueryContextMenu(hMenu, 0, 1, MAXSHORT, (cVerbs ? 0 : CMF_DEFAULTONLY));
    if (FAILED(hr))
        goto Cleanup;
 
    if (!cVerbs)
    {
        idDefault = GetMenuDefaultItem(hMenu, FALSE, 0);
        if (idDefault != (UINT)-1)
            pszVerbA = MAKEINTRESOURCEA(idDefault - 1);
    }
 
    ZeroMemory(&ici, sizeof(ici));
    ici.cbSize = sizeof(ici);
    ici.hwnd   = hwnd;
    ici.nShow  = SW_SHOWNORMAL;
 
    iVerb = 0;
    do
    {
        if (cVerbs)
            pszVerbA = pVerbs[iVerb];
 
        if (!pszVerbA && idDefault == (UINT)-1)
        {
            hr = E_FAIL;
            break;
        }
 
        ici.fMask   = fMask;
        ici.lpVerb  = pszVerbA;
        ici.lpVerbW = NULL;
 
        if (idDefault == (UINT)-1 && !IS_INTRESOURCE(pszVerbA) && IsTextAsciiOnly(pszVerbA))
        {
            size_t ich;
            for (ich = 0; pszVerbA[ich] && ich + 1 < _countof(szVerbW); ++ich)
            {
                szVerbW[ich] = (BYTE)pszVerbA[ich];
            }
            szVerbW[ich] = UNICODE_NULL;
 
            ici.lpVerbW = szVerbW;
            ici.fMask |= CMIC_MASK_UNICODE;
        }
 
        hr = pCM->InvokeCommand((LPCMINVOKECOMMANDINFO)&ici);
 
        if (SUCCEEDED(hr) || hr == HRESULT_FROM_WIN32(ERROR_CANCELLED))
            break;
 
        ++iVerb;
    } while (iVerb < cVerbs);
 
Cleanup:
    if (punkSite)
        IUnknown_SetSite(pCM, NULL);
    DestroyMenu(hMenu);
    return hr;
}

SHInvokeDefaultCommand()

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

Definition at line 3183 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 2373 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 570 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 4413 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 4725 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 2656 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(), and SHLWAPI_GetCachedZonesManagerInner().

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 5837 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 2464 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 4195 of file ordinal.c.

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

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

SHSetDefaultDialogFont()

VOID WINAPI SHSetDefaultDialogFont	(	HWND	hWnd,
		INT	id
	)

Definition at line 2576 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(), CFontBackgroundMenu::InvokeCommand(), CCPLItemMenu::InvokeCommand(), CDefaultContextMenu::InvokeRegVerb(), and SH32_SimulateDropWithSite().

SHUnicodeToAnsi()

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

Definition at line 2927 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 2828 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;
}

SHWindowsPolicyGetValue()

HRESULT WINAPI SHWindowsPolicyGetValue	(	_In_ REFGUID	rpolid,
		_Out_opt_ PVOID	pvValue,
		_Out_opt_ PDWORD	pcbValue
	)

Definition at line 299 of file policy.cpp.

{
    HRESULT hr = E_FAIL;
 
    EnterCriticalSection(&g_csPolicyLock);
    if (SHPolicyCache_Create())
        hr = g_pPolicyCache->GetValue(rpolid, pvValue, pcbValue);
    LeaveCriticalSection(&g_csPolicyLock);
    return hr;
}

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().

StrCpyNXA()

LPSTR WINAPI StrCpyNXA	(	LPSTR	lpszDest,
		LPCSTR	lpszSrc,
		int	iLen
	)

Definition at line 2393 of file string.c.

{
  TRACE("(%p,%s,%i)\n", lpszDest, debugstr_a(lpszSrc), iLen);
 
  if (lpszDest && lpszSrc && iLen > 0)
  {
    while ((iLen-- > 1) && *lpszSrc)
      *lpszDest++ = *lpszSrc++;
    if (iLen >= 0)
     *lpszDest = '\0';
  }
  return lpszDest;
}

StrCpyNXW()

LPWSTR WINAPI StrCpyNXW	(	LPWSTR	lpszDest,
		LPCWSTR	lpszSrc,
		int	iLen
	)

Definition at line 2412 of file string.c.

{
  TRACE("(%p,%s,%i)\n", lpszDest, debugstr_w(lpszSrc), iLen);
 
  if (lpszDest && lpszSrc && iLen > 0)
  {
    while ((iLen-- > 1) && *lpszSrc)
      *lpszDest++ = *lpszSrc++;
    if (iLen >= 0)
     *lpszDest = '\0';
  }
  return lpszDest;
}

ZoneCheckHost()

HRESULT WINAPI ZoneCheckHost	(	_In_ IInternetSecurityManager *	pISM,
		_In_ PCWSTR	pszUrl,
		_In_ DWORD	dwAction
	)

Definition at line 305 of file zonechk.c.

{
    return ZoneCheckHostEx(pISM, NULL, 0, NULL, 0, pszUrl, dwAction);
}

ZoneCheckHostEx()

HRESULT WINAPI ZoneCheckHostEx	(	_In_ IInternetSecurityManager *	pISM,
		_Out_writes_bytes_opt_(cbPolicy) PBYTE	pbPolicy,
		_In_ DWORD	cbPolicy,
		_In_reads_bytes_opt_(cbContext) PBYTE	pbContext,
		_In_ DWORD	cbContext,
		_In_ PCWSTR	pszUrl,
		_In_ DWORD	dwAction
	)

Definition at line 317 of file zonechk.c.

{
    DWORD dwPolicyBuf, dwContextBuf;
 
    if (!pISM || !pszUrl)
        return E_INVALIDARG;
 
    if (!pbPolicy)
    {
        dwPolicyBuf = 0;
        pbPolicy = (PBYTE)&dwPolicyBuf;
        cbPolicy = sizeof(dwPolicyBuf);
    }
 
    if (!pbContext)
    {
        dwContextBuf = 0;
        pbContext = (PBYTE)&dwContextBuf;
        cbContext = sizeof(dwContextBuf);
    }
 
    return pISM->lpVtbl->ProcessUrlAction(pISM, pszUrl, dwAction, pbPolicy, cbPolicy,
                                          pbContext, cbContext, 0, 0);
}

Referenced by ZoneCheckHost().

ZoneCheckPathA()

HRESULT WINAPI ZoneCheckPathA	(	_In_ PCSTR	pszPath,
		_In_ DWORD	dwAction,
		_In_ DWORD	dwFlags,
		_In_opt_ IInternetSecurityMgrSite *	pSecuritySite
	)

Definition at line 196 of file zonechk.c.

{
    WCHAR szPath[2048];
    if (!pszPath)
    {
        ERR("pszPath was NULL\n");
        return E_INVALIDARG;
    }
    SHAnsiToUnicode(pszPath, szPath, _countof(szPath));
    return ZoneCheckPathW(szPath, dwAction, dwFlags, pSecuritySite);
}

ZoneCheckPathW()

HRESULT WINAPI ZoneCheckPathW	(	_In_ PCWSTR	pszPath,
		_In_ DWORD	dwAction,
		_In_ DWORD	dwFlags,
		_In_opt_ IInternetSecurityMgrSite *	pSecuritySite
	)

Definition at line 216 of file zonechk.c.

{
    return ZoneCheckUrlW(pszPath, dwAction, dwFlags | PUAF_ISFILE, pSecuritySite);
}

Referenced by ZoneCheckPathA().

ZoneCheckUrlA()

HRESULT WINAPI ZoneCheckUrlA	(	_In_ PCSTR	pszUrl,
		_In_ DWORD	dwAction,
		_In_ DWORD	dwFlags,
		_In_opt_ IInternetSecurityMgrSite *	pSecuritySite
	)

Definition at line 229 of file zonechk.c.

{
    WCHAR szUrl[2048];
    if (!pszUrl)
    {
        ERR("pszUrl was NULL\n");
        return E_INVALIDARG;
    }
    SHAnsiToUnicode(pszUrl, szUrl, _countof(szUrl));
    return ZoneCheckUrlW(szUrl, dwAction, dwFlags, pSecuritySite);
}

ZoneCheckUrlExA()

HRESULT WINAPI ZoneCheckUrlExA	(	_In_ PCSTR	pszUrl,
		_Out_writes_bytes_opt_(cbPolicy) PBYTE	pbPolicy,
		_In_ DWORD	cbPolicy,
		_In_reads_bytes_opt_(cbContext) PBYTE	pbContext,
		_In_ DWORD	cbContext,
		_In_ DWORD	dwAction,
		_In_ DWORD	dwFlags,
		_In_opt_ IInternetSecurityMgrSite *	pSecuritySite
	)

Definition at line 262 of file zonechk.c.

{
    WCHAR szUrl[2048];
    if (!pszUrl)
    {
        ERR("pszUrl was NULL\n");
        return E_INVALIDARG;
    }
    SHAnsiToUnicode(pszUrl, szUrl, _countof(szUrl));
    return ZoneCheckUrlExW(szUrl, pbPolicy, cbPolicy, pbContext, cbContext,
                           dwAction, dwFlags, pSecuritySite);
}

ZoneCheckUrlExCacheA()

HRESULT WINAPI ZoneCheckUrlExCacheA	(	_In_ PCSTR	pszUrl,
		_Out_writes_bytes_opt_(cbPolicy) PBYTE	pbPolicy,
		_In_ DWORD	cbPolicy,
		_In_reads_bytes_opt_(cbContext) PBYTE	pbContext,
		_In_ DWORD	cbContext,
		_In_ DWORD	dwAction,
		_In_ DWORD	dwFlags,
		_In_opt_ IInternetSecurityMgrSite *	pSecuritySite,
		_In_opt_ IInternetSecurityManager *	pISM
	)

Definition at line 107 of file zonechk.c.

{
    WCHAR szUrl[2048];
    if (!pszUrl)
    {
        ERR("pszUrl was NULL\n");
        return E_INVALIDARG;
    }
    SHAnsiToUnicode(pszUrl, szUrl, _countof(szUrl));
    return ZoneCheckUrlExCacheW(szUrl, pbPolicy, cbPolicy, pbContext, cbContext,
                                dwAction, dwFlags, pSecuritySite, pISM);
}

ZoneCheckUrlExCacheW()

HRESULT WINAPI ZoneCheckUrlExCacheW	(	_In_ PCWSTR	pszUrl,
		_Out_writes_bytes_opt_(cbPolicy) PBYTE	pbPolicy,
		_In_ DWORD	cbPolicy,
		_In_reads_bytes_opt_(cbContext) PBYTE	pbContext,
		_In_ DWORD	cbContext,
		_In_ DWORD	dwAction,
		_In_ DWORD	dwFlags,
		_In_opt_ IInternetSecurityMgrSite *	pSecuritySite,
		_In_opt_ IInternetSecurityManager *	pISM
	)

Definition at line 133 of file zonechk.c.

{
    HRESULT hr;
    IInternetSecurityManager *pWorkISM;
    DWORD dwPolicyBuf, dwContextBuf;
 
    if (!pszUrl)
    {
        ERR("pszUrl was NULL\n");
        return E_INVALIDARG;
    }
 
    if (pISM && pISM->lpVtbl)
        hr = pISM->lpVtbl->QueryInterface(pISM, &IID_IInternetSecurityManager, (PVOID *)&pWorkISM);
    else
        hr = SHLWAPI_GetCachedZonesManager(&IID_IInternetSecurityManager, (PVOID *)&pWorkISM);
 
    if (FAILED(hr))
    {
        ERR("hr: 0x%lX\n", hr);
        return hr;
    }
 
    if (pSecuritySite)
        pWorkISM->lpVtbl->SetSecuritySite(pWorkISM, pSecuritySite);
 
    if (!pbContext)
    {
        dwContextBuf = 0;
        pbContext = (PBYTE)&dwContextBuf;
        cbContext = sizeof(dwContextBuf);
    }
 
    if (!pbPolicy)
    {
        dwPolicyBuf = 0;
        pbPolicy = (PBYTE)&dwPolicyBuf;
        cbPolicy = sizeof(dwPolicyBuf);
    }
 
    hr = pWorkISM->lpVtbl->ProcessUrlAction(pWorkISM, pszUrl, dwAction, pbPolicy, cbPolicy,
                                            pbContext, cbContext, dwFlags, 0);
 
    if (pSecuritySite)
        pWorkISM->lpVtbl->SetSecuritySite(pWorkISM, NULL);
 
    pWorkISM->lpVtbl->Release(pWorkISM);
    return hr;
}

Referenced by ZoneCheckUrlExCacheA(), and ZoneCheckUrlExW().

ZoneCheckUrlExW()

HRESULT WINAPI ZoneCheckUrlExW	(	_In_ PCWSTR	pszUrl,
		_Out_writes_bytes_opt_(cbPolicy) PBYTE	pbPolicy,
		_In_ DWORD	cbPolicy,
		_In_reads_bytes_opt_(cbContext) PBYTE	pbContext,
		_In_ DWORD	cbContext,
		_In_ DWORD	dwAction,
		_In_ DWORD	dwFlags,
		_In_opt_ IInternetSecurityMgrSite *	pSecuritySite
	)

Definition at line 287 of file zonechk.c.

{
    return ZoneCheckUrlExCacheW(pszUrl, pbPolicy, cbPolicy, pbContext, cbContext,
                                dwAction, dwFlags, pSecuritySite, NULL);
}

Referenced by ZoneCheckUrlExA(), and ZoneCheckUrlW().

ZoneCheckUrlW()

HRESULT WINAPI ZoneCheckUrlW	(	_In_ PCWSTR	pszUrl,
		_In_ DWORD	dwAction,
		_In_ DWORD	dwFlags,
		_In_opt_ IInternetSecurityMgrSite *	pSecuritySite
	)

Definition at line 249 of file zonechk.c.

{
    return ZoneCheckUrlExW(pszUrl, NULL, 0, NULL, 0, dwAction, dwFlags, pSecuritySite);
}

Referenced by ZoneCheckPathW(), and ZoneCheckUrlA().