ordinal.c File Reference

#include "config.h"
#include "wine/port.h"
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winreg.h"
#include "wingdi.h"
#include "winuser.h"
#include "winver.h"
#include "winnetwk.h"
#include "mmsystem.h"
#include "objbase.h"
#include "exdisp.h"
#include "shdeprecated.h"
#include "shlobj.h"
#include "shlwapi.h"
#include "shellapi.h"
#include "commdlg.h"
#include "mlang.h"
#include "mshtmhst.h"
#include "wine/unicode.h"
#include "wine/debug.h"

Include dependency graph for ordinal.c:

Go to the source code of this file.

Classes
struct	_enumWndData
struct	FDSA_info
struct	tagPOLICYDATA
struct	SHELL_USER_SID
struct	SHELL_USER_PERMISSION
struct	objcompat_entry

Macros
#define	COBJMACROS
#define	FDSA_FLAG_INTERNAL_ALLOC   0x01 /* When set we have allocated mem internally */
#define	SHELL_NO_POLICY   0xffffffff
#define	IsIface(type)   SUCCEEDED((hRet = IUnknown_QueryInterface(lpUnknown, &IID_##type, (void**)&lpObj)))
#define	IShellBrowser_EnableModeless   IShellBrowser_EnableModelessSB
#define	EnableModeless(type)   type##_EnableModeless((type*)lpObj, bModeless)
#define	GET_RGB(h)   (ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240
#define	ISOS_RETURN(x)
#define	SHFORMATDT_UNSUPPORTED_FLAGS   (FDTF_RELATIVE | FDTF_LTRDATE | FDTF_RTLDATE | FDTF_NOAUTOREADINGORDER)
#define	OBJCOMPAT_OTNEEDSSFCACHE   0x00000001
#define	OBJCOMPAT_NO_WEBVIEW   0x00000002
#define	OBJCOMPAT_UNBINDABLE   0x00000004
#define	OBJCOMPAT_PINDLL   0x00000008
#define	OBJCOMPAT_NEEDSFILESYSANCESTOR   0x00000010
#define	OBJCOMPAT_NOTAFILESYSTEM   0x00000020
#define	OBJCOMPAT_CTXMENU_NOVERBS   0x00000040
#define	OBJCOMPAT_CTXMENU_LIMITEDQI   0x00000080
#define	OBJCOMPAT_COCREATESHELLFOLDERONLY   0x00000100
#define	OBJCOMPAT_NEEDSSTORAGEANCESTOR   0x00000200
#define	OBJCOMPAT_NOLEGACYWEBVIEW   0x00000400
#define	OBJCOMPAT_CTXMENU_XPQCMFLAGS   0x00001000
#define	OBJCOMPAT_NOIPROPERTYSTORE   0x00002000

Typedefs
typedef struct _enumWndData	enumWndData
typedef struct tagPOLICYDATA	POLICYDATA
typedef struct tagPOLICYDATA *	LPPOLICYDATA
typedef HRESULT(WINAPI *	DllGetVersion_func) (DLLVERSIONINFO *)
typedef struct SHELL_USER_SID	SHELL_USER_SID
typedef struct SHELL_USER_SID *	PSHELL_USER_SID
typedef struct SHELL_USER_PERMISSION	SHELL_USER_PERMISSION
typedef struct SHELL_USER_PERMISSION *	PSHELL_USER_PERMISSION

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
HRESULT WINAPI	IUnknown_QueryService (IUnknown *, REFGUID, REFIID, LPVOID *)
HRESULT WINAPI	SHInvokeCommand (HWND, IShellFolder *, LPCITEMIDLIST, DWORD)
BOOL WINAPI	SHAboutInfoW (LPWSTR, DWORD)
HANDLE WINAPI	SHMapHandle (HANDLE hShared, DWORD dwSrcProcId, DWORD dwDstProcId, DWORD dwAccess, DWORD dwOptions)
HANDLE WINAPI	SHAllocShared (LPCVOID lpvData, DWORD dwSize, DWORD dwProcId)
PVOID WINAPI	SHLockShared (HANDLE hShared, DWORD dwProcId)
BOOL WINAPI	SHUnlockShared (LPVOID lpView)
BOOL WINAPI	SHFreeShared (HANDLE hShared, DWORD dwProcId)
HRESULT WINAPI	RegisterDefaultAcceptHeaders (LPBC lpBC, IUnknown *lpUnknown)
HRESULT WINAPI	GetAcceptLanguagesW (LPWSTR langbuf, LPDWORD buflen)
HRESULT WINAPI	GetAcceptLanguagesA (LPSTR langbuf, LPDWORD buflen)
INT WINAPI	SHStringFromGUIDA (REFGUID guid, LPSTR lpszDest, INT cchMax)
INT WINAPI	SHStringFromGUIDW (REFGUID guid, LPWSTR lpszDest, INT cchMax)
BOOL WINAPI	IsCharBlankW (WCHAR wc)
BOOL WINAPI	IsCharPunctW (WCHAR wc)
BOOL WINAPI	IsCharCntrlW (WCHAR wc)
BOOL WINAPI	IsCharDigitW (WCHAR wc)
BOOL WINAPI	IsCharXDigitW (WCHAR wc)
BOOL WINAPI	GetStringType3ExW (LPWSTR src, INT count, LPWORD type)
DWORD WINAPI	StrCmpNCA (LPCSTR lpszSrc, LPCSTR lpszCmp, INT len)
DWORD WINAPI	StrCmpNCW (LPCWSTR lpszSrc, LPCWSTR lpszCmp, INT len)
DWORD WINAPI	StrCmpNICA (LPCSTR lpszSrc, LPCSTR lpszCmp, DWORD len)
DWORD WINAPI	StrCmpNICW (LPCWSTR lpszSrc, LPCWSTR lpszCmp, DWORD len)
DWORD WINAPI	StrCmpCA (LPCSTR lpszSrc, LPCSTR lpszCmp)
DWORD WINAPI	StrCmpCW (LPCWSTR lpszSrc, LPCWSTR lpszCmp)
DWORD WINAPI	StrCmpICA (LPCSTR lpszSrc, LPCSTR lpszCmp)
DWORD WINAPI	StrCmpICW (LPCWSTR lpszSrc, LPCWSTR lpszCmp)
BOOL WINAPI	SHAboutInfoA (LPSTR lpszDest, DWORD dwDestLen)
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 mask, UINT flags)
HWND WINAPI	SHSetParentHwnd (HWND hWnd, HWND hWndParent)
HRESULT WINAPI	ConnectToConnectionPoint (IUnknown *lpUnkSink, REFIID riid, BOOL fConnect, IUnknown *lpUnknown, LPDWORD lpCookie, IConnectionPoint **lppCP)
void WINAPI	IUnknown_AtomicRelease (IUnknown **lpUnknown)
LPCSTR WINAPI	PathSkipLeadingSlashesA (LPCSTR lpszSrc)
BOOL WINAPI	SHIsSameObject (IUnknown *lpInt1, IUnknown *lpInt2)
HRESULT WINAPI	IUnknown_GetWindow (IUnknown *lpUnknown, HWND *lphWnd)
HRESULT WINAPI	IUnknown_SetOwner (IUnknown *iface, IUnknown *pUnk)
HRESULT WINAPI	IUnknown_SetSite (IUnknown *obj, IUnknown *site)
HRESULT WINAPI	IUnknown_GetClassID (IUnknown *lpUnknown, CLSID *clsid)
HRESULT WINAPI	IUnknown_QueryServiceExec (IUnknown *lpUnknown, REFIID service, const GUID *group, DWORD cmdId, DWORD cmdOpt, VARIANT *pIn, VARIANT *pOut)
HRESULT WINAPI	IUnknown_ProfferService (IUnknown *lpUnknown, REFGUID service, IServiceProvider *pService, DWORD *pCookie)
HRESULT WINAPI	IUnknown_UIActivateIO (IUnknown *unknown, BOOL activate, LPMSG msg)
BOOL WINAPI	SHLoadMenuPopup (HINSTANCE hInst, LPCWSTR szName)
static BOOL CALLBACK	SHLWAPI_EnumChildProc (HWND hWnd, LPARAM lParam)
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	SHLoadFromPropertyBag (IUnknown *lpUnknown, IPropertyBag *lpPropBag)
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)
HMENU WINAPI	SHGetMenuFromID (HMENU hMenu, UINT uID)
DWORD WINAPI	SHGetCurColorRes (void)
DWORD WINAPI	SHWaitForSendMessageThread (HANDLE hand, DWORD dwTimeout)
HRESULT WINAPI	SHIsExpandableFolder (LPSHELLFOLDER lpFolder, LPCITEMIDLIST pidl)
DWORD WINAPI	SHFillRectClr (HDC hDC, LPCRECT pRect, COLORREF cRef)
int WINAPI	SHSearchMapInt (const int *lpKeys, const int *lpValues, int iLen, int iKey)
VOID WINAPI	IUnknown_Set (IUnknown **lppDest, IUnknown *lpUnknown)
HRESULT WINAPI	MayQSForward (IUnknown *lpUnknown, PVOID lpReserved, REFGUID riidCmdGrp, ULONG cCmds, OLECMD *prgCmds, OLECMDTEXT *pCmdText)
HRESULT WINAPI	MayExecForward (IUnknown *lpUnknown, INT iUnk, REFGUID pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
HRESULT WINAPI	IsQSForward (REFGUID pguidCmdGroup, ULONG cCmds, OLECMD *prgCmds)
BOOL WINAPI	SHIsChildOrSelf (HWND hParent, HWND hChild)
BOOL WINAPI	FDSA_Initialize (DWORD block_size, DWORD inc, FDSA_info *info, void *mem, DWORD init_blocks)
BOOL WINAPI	FDSA_Destroy (FDSA_info *info)
DWORD WINAPI	FDSA_InsertItem (FDSA_info *info, DWORD where, const void *block)
BOOL WINAPI	FDSA_DeleteItem (FDSA_info *info, DWORD where)
HRESULT WINAPI	QISearch (void *base, const QITAB *table, REFIID riid, void **ppv)
HRESULT WINAPI	SHSetDefaultDialogFont (HWND hWnd, INT id)
HANDLE WINAPI	SHRemoveDefaultDialogFont (HWND hWnd)
HMODULE WINAPI	SHPinDllOfCLSID (REFIID refiid)
DWORD WINAPI	SHRegisterClassW (WNDCLASSW *lpWndClass)
void WINAPI	SHUnregisterClassesA (HINSTANCE hInst, LPCSTR *lppClasses, INT iCount)
void WINAPI	SHUnregisterClassesW (HINSTANCE hInst, LPCWSTR *lppClasses, INT iCount)
LRESULT CALLBACK	SHDefWindowProc (HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
HRESULT WINAPI	IUnknown_GetSite (LPUNKNOWN lpUnknown, REFIID iid, PVOID *lppSite)
HWND WINAPI	SHCreateWorkerWindowA (WNDPROC wndProc, HWND hWndParent, DWORD dwExStyle, DWORD dwStyle, HMENU hMenu, LONG_PTR wnd_extra)
DWORD WINAPI	SHGetRestriction (LPCWSTR lpSubKey, LPCWSTR lpSubName, LPCWSTR lpValue)
DWORD WINAPI	SHRestrictionLookup (DWORD policy, LPCWSTR initial, LPPOLICYDATA polTable, LPDWORD polArr)
HRESULT WINAPI	SHWeakQueryInterface (IUnknown *pUnk, IUnknown *pInner, IID *riid, LPVOID *ppv)
VOID WINAPI	SHWeakReleaseInterface (IUnknown *lpDest, IUnknown **lppUnknown)
BOOL WINAPI	GUIDFromStringA (LPCSTR idstr, CLSID *id)
BOOL WINAPI	GUIDFromStringW (LPCWSTR idstr, CLSID *id)
DWORD WINAPI	WhichPlatform (void)
HWND WINAPI	SHCreateWorkerWindowW (WNDPROC wndProc, HWND hWndParent, DWORD dwExStyle, DWORD dwStyle, HMENU hMenu, LONG_PTR wnd_extra)
HRESULT WINAPI	SHInvokeDefaultCommand (HWND hWnd, IShellFolder *lpFolder, LPCITEMIDLIST lpApidl)
HRESULT WINAPI	SHPackDispParamsV (DISPPARAMS *params, VARIANTARG *args, UINT cnt, __ms_va_list valist)
HRESULT WINAPIV	SHPackDispParams (DISPPARAMS *params, VARIANTARG *args, UINT cnt,...)
static HRESULT	SHLWAPI_InvokeByIID (IConnectionPoint *iCP, REFIID iid, DISPID dispId, DISPPARAMS *dispParams)
HRESULT WINAPI	IConnectionPoint_InvokeWithCancel (IConnectionPoint *iCP, DISPID dispId, DISPPARAMS *dispParams, DWORD unknown1, DWORD unknown2)
HRESULT WINAPI	IConnectionPoint_SimpleInvoke (IConnectionPoint *iCP, DISPID dispId, DISPPARAMS *dispParams)
HRESULT WINAPI	IConnectionPoint_OnChanged (IConnectionPoint *lpCP, DISPID dispID)
HRESULT WINAPIV	IUnknown_CPContainerInvokeParam (IUnknown *container, REFIID riid, DISPID dispId, VARIANTARG *buffer, DWORD cParams,...)
HRESULT WINAPI	IUnknown_CPContainerOnChanged (IUnknown *lpUnknown, DISPID dispID)
BOOL WINAPI	PlaySoundWrapW (LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound)
DWORD WINAPI	SHGetIniStringW (LPCWSTR appName, LPCWSTR keyName, LPWSTR out, DWORD outLen, LPCWSTR filename)
BOOL WINAPI	SHSetIniStringW (LPCWSTR appName, LPCWSTR keyName, LPCWSTR str, LPCWSTR filename)
DWORD WINAPI	SHGetFileInfoWrapW (LPCWSTR path, DWORD dwFileAttributes, SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags)
UINT WINAPI	DragQueryFileWrapW (HDROP hDrop, UINT lFile, LPWSTR lpszFile, UINT lLength)
LPITEMIDLIST WINAPI	SHBrowseForFolderWrapW (LPBROWSEINFOW lpBi)
BOOL WINAPI	SHGetPathFromIDListWrapW (LPCITEMIDLIST pidl, LPWSTR pszPath)
BOOL WINAPI	ShellExecuteExWrapW (LPSHELLEXECUTEINFOW lpExecInfo)
INT WINAPI	SHFileOperationWrapW (LPSHFILEOPSTRUCTW lpFileOp)
PVOID WINAPI	SHInterlockedCompareExchange (PVOID *dest, PVOID xchg, PVOID compare)
DWORD WINAPI	GetFileVersionInfoSizeWrapW (LPCWSTR filename, LPDWORD handle)
BOOL WINAPI	GetFileVersionInfoWrapW (LPCWSTR filename, DWORD handle, DWORD datasize, LPVOID data)
WORD WINAPI	VerQueryValueWrapW (LPVOID pBlock, LPCWSTR lpSubBlock, LPVOID *lplpBuffer, UINT *puLen)
HRESULT WINAPI	IUnknown_EnableModeless (IUnknown *lpUnknown, BOOL bModeless)
BOOL WINAPI	SHGetNewLinkInfoWrapW (LPCWSTR pszLinkTo, LPCWSTR pszDir, LPWSTR pszName, BOOL *pfMustCopy, UINT uFlags)
UINT WINAPI	SHDefExtractIconWrapW (LPCWSTR pszIconFile, int iIndex, UINT uFlags, HICON *phiconLarge, HICON *phiconSmall, UINT nIconSize)
HICON WINAPI	ExtractIconWrapW (HINSTANCE hInstance, LPCWSTR lpszExeFileName, UINT nIconIndex)
HMODULE WINAPI	MLLoadLibraryA (LPCSTR new_mod, HMODULE inst_hwnd, DWORD dwCrossCodePage)
HMODULE WINAPI	MLLoadLibraryW (LPCWSTR new_mod, HMODULE inst_hwnd, DWORD dwCrossCodePage)
COLORREF WINAPI	ColorAdjustLuma (COLORREF cRGB, int dwLuma, BOOL bUnknown)
BOOL WINAPI	GetSaveFileNameWrapW (LPOPENFILENAMEW ofn)
DWORD WINAPI	WNetRestoreConnectionWrapW (HWND hwndOwner, LPWSTR lpszDevice)
DWORD WINAPI	WNetGetLastErrorWrapW (LPDWORD lpError, LPWSTR lpErrorBuf, DWORD nErrorBufSize, LPWSTR lpNameBuf, DWORD nNameBufSize)
BOOL WINAPI	PageSetupDlgWrapW (LPPAGESETUPDLGW pagedlg)
BOOL WINAPI	PrintDlgWrapW (LPPRINTDLGW printdlg)
BOOL WINAPI	GetOpenFileNameWrapW (LPOPENFILENAMEW ofn)
HRESULT WINAPI	SHIShellFolder_EnumObjects (LPSHELLFOLDER lpFolder, HWND hwnd, SHCONTF flags, IEnumIDList **ppenum)
static WORD	ConvertHue (int wHue, WORD wMid1, WORD wMid2)
COLORREF WINAPI	ColorHLSToRGB (WORD wHue, WORD wLuminosity, WORD wSaturation)
DWORD WINAPI	SHGetMachineInfo (DWORD dwFlags)
DWORD WINAPI	SHWinHelpOnDemandW (HWND hwnd, LPCWSTR helpfile, DWORD flags1, VOID *ptr1, DWORD flags2)
DWORD WINAPI	SHWinHelpOnDemandA (HWND hwnd, LPCSTR helpfile, DWORD flags1, VOID *ptr1, DWORD flags2)
BOOL WINAPI	MLFreeLibrary (HMODULE hModule)
BOOL WINAPI	SHFlushSFCacheWrap (void)
BOOL WINAPI	MLIsMLHInstance (HINSTANCE hInst)
DWORD WINAPI	MLSetMLHInstance (HINSTANCE hInst, HANDLE hHeap)
DWORD WINAPI	MLClearMLHInstance (DWORD x)
DWORD WINAPI	SHSendMessageBroadcastA (UINT uMsg, WPARAM wParam, LPARAM lParam)
DWORD WINAPI	SHSendMessageBroadcastW (UINT uMsg, WPARAM wParam, LPARAM lParam)
HRESULT WINAPI	CLSIDFromStringWrap (LPCWSTR idstr, CLSID *id)
BOOL WINAPI	IsOS (DWORD feature)
HRESULT WINAPI	SHLoadRegUIStringW (HKEY hkey, LPCWSTR value, LPWSTR buf, DWORD size)
HRESULT WINAPI	IUnknown_TranslateAcceleratorIO (IUnknown *lpUnknown, LPMSG lpMsg)
HRESULT WINAPI	IUnknown_HasFocusIO (IUnknown *lpUnknown)
VOID WINAPI	ColorRGBToHLS (COLORREF cRGB, LPWORD pwHue, LPWORD pwLuminance, LPWORD pwSaturation)
HPALETTE WINAPI	SHCreateShellPalette (HDC hdc)
HRESULT WINAPI	SHGetInverseCMAP (LPDWORD dest, DWORD dwSize)
BOOL WINAPI	SHIsLowMemoryMachine (DWORD dwType)
INT WINAPI	GetMenuPosFromID (HMENU hMenu, UINT wID)
DWORD WINAPI	SHMenuIndexFromID (HMENU hMenu, UINT uID)
VOID WINAPI	FixSlashesAndColonW (LPWSTR lpwstr)
DWORD WINAPI	SHGetAppCompatFlags (DWORD dwUnknown)
HRESULT WINAPI	SHCoCreateInstanceAC (REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
BOOL WINAPI	SHSkipJunction (IBindCtx *pbc, const CLSID *pclsid)
HKEY WINAPI	SHGetShellKey (DWORD flags, LPCWSTR sub_key, BOOL create)
BOOL WINAPI	SHQueueUserWorkItem (LPTHREAD_START_ROUTINE pfnCallback, LPVOID pContext, LONG lPriority, DWORD_PTR dwTag, DWORD_PTR *pdwId, LPCSTR pszModule, DWORD dwFlags)
HANDLE WINAPI	SHSetTimerQueueTimer (HANDLE hQueue, WAITORTIMERCALLBACK pfnCallback, LPVOID pContext, DWORD dwDueTime, DWORD dwPeriod, LPCSTR lpszLibrary, DWORD dwFlags)
HRESULT WINAPI	IUnknown_OnFocusChangeIS (LPUNKNOWN lpUnknown, LPUNKNOWN pFocusObject, BOOL bFocus)
HRESULT WINAPI	SKAllocValueW (DWORD flags, LPCWSTR subkey, LPCWSTR value, DWORD *type, LPVOID *data, DWORD *count)
HRESULT WINAPI	SKDeleteValueW (DWORD flags, LPCWSTR subkey, LPCWSTR value)
HRESULT WINAPI	SKGetValueW (DWORD flags, LPCWSTR subkey, LPCWSTR value, DWORD *type, void *data, DWORD *count)
HRESULT WINAPI	SKSetValueW (DWORD flags, LPCWSTR subkey, LPCWSTR value, DWORD type, void *data, DWORD count)
DWORD WINAPI	GetUIVersion (void)
INT WINAPIV	ShellMessageBoxWrapW (HINSTANCE hInstance, HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,...)
UINT WINAPI	ZoneComputePaneSize (HWND hwnd)
void WINAPI	SHChangeNotifyWrap (LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
PSECURITY_DESCRIPTOR WINAPI	GetShellSecurityDescriptor (const PSHELL_USER_PERMISSION *apUserPerm, int cUserPerm)
HRESULT WINAPI	SHCreatePropertyBagOnRegKey (HKEY hKey, LPCWSTR subkey, DWORD grfMode, REFIID riid, void **ppv)
HRESULT WINAPI	SHGetViewStatePropertyBag (LPCITEMIDLIST pidl, LPWSTR bag_name, DWORD flags, REFIID riid, void **ppv)
INT WINAPI	SHFormatDateTimeW (const FILETIME UNALIGNED *fileTime, DWORD *flags, LPWSTR buf, UINT size)
INT WINAPI	SHFormatDateTimeA (const FILETIME UNALIGNED *fileTime, DWORD *flags, LPSTR buf, UINT size)
INT WINAPI	ZoneCheckUrlExW (LPWSTR szURL, PVOID pUnknown, DWORD dwUnknown2, DWORD dwUnknown3, DWORD dwUnknown4, DWORD dwUnknown5, DWORD dwUnknown6, DWORD dwUnknown7)
INT WINAPI	SHVerbExistsNA (LPSTR verb, PVOID pUnknown, PVOID pUnknown2, DWORD dwUnknown3)
HRESULT WINAPI	IUnknown_QueryServiceForWebBrowserApp (IUnknown *lpUnknown, REFGUID riid, LPVOID *lppOut)
HRESULT WINAPI	SHPropertyBag_ReadLONG (IPropertyBag *ppb, LPCWSTR pszPropName, LPLONG pValue)
DWORD WINAPI	SHGetObjectCompatFlags (IUnknown *pUnk, const CLSID *clsid)

Variables
HINSTANCE	shlwapi_hInstance
DWORD	SHLWAPI_ThreadRef_index
static const WCHAR	strRegistryPolicyW []
static const struct objcompat_entry	objcompat_table []

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 30 of file ordinal.c.

EnableModeless

#define EnableModeless

(

type

)

type##_EnableModeless((type*)lpObj, bModeless)

Definition at line 3540 of file ordinal.c.

FDSA_FLAG_INTERNAL_ALLOC

#define FDSA_FLAG_INTERNAL_ALLOC   0x01 /* When set we have allocated mem internally */

Definition at line 2279 of file ordinal.c.

GET_RGB

#define GET_RGB

(

h

)

(ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240

Definition at line 3902 of file ordinal.c.

IShellBrowser_EnableModeless

#define IShellBrowser_EnableModeless   IShellBrowser_EnableModelessSB

Definition at line 3539 of file ordinal.c.

IsIface

#define IsIface

(

type

)

SUCCEEDED((hRet = IUnknown_QueryInterface(lpUnknown, &IID_##type, (void**)&lpObj)))

Definition at line 3538 of file ordinal.c.

ISOS_RETURN

#define ISOS_RETURN

(

x

)

Value:

    TRACE("(0x%x) ret=%d\n",feature,(x)); \
    return (x);

OBJCOMPAT_COCREATESHELLFOLDERONLY

#define OBJCOMPAT_COCREATESHELLFOLDERONLY   0x00000100

Definition at line 6260 of file ordinal.c.

OBJCOMPAT_CTXMENU_LIMITEDQI

#define OBJCOMPAT_CTXMENU_LIMITEDQI   0x00000080

Definition at line 6259 of file ordinal.c.

OBJCOMPAT_CTXMENU_NOVERBS

#define OBJCOMPAT_CTXMENU_NOVERBS   0x00000040

Definition at line 6258 of file ordinal.c.

OBJCOMPAT_CTXMENU_XPQCMFLAGS

#define OBJCOMPAT_CTXMENU_XPQCMFLAGS   0x00001000

Definition at line 6263 of file ordinal.c.

OBJCOMPAT_NEEDSFILESYSANCESTOR

#define OBJCOMPAT_NEEDSFILESYSANCESTOR   0x00000010

Definition at line 6256 of file ordinal.c.

OBJCOMPAT_NEEDSSTORAGEANCESTOR

#define OBJCOMPAT_NEEDSSTORAGEANCESTOR   0x00000200

Definition at line 6261 of file ordinal.c.

OBJCOMPAT_NO_WEBVIEW

#define OBJCOMPAT_NO_WEBVIEW   0x00000002

Definition at line 6253 of file ordinal.c.

OBJCOMPAT_NOIPROPERTYSTORE

#define OBJCOMPAT_NOIPROPERTYSTORE   0x00002000

Definition at line 6264 of file ordinal.c.

OBJCOMPAT_NOLEGACYWEBVIEW

#define OBJCOMPAT_NOLEGACYWEBVIEW   0x00000400

Definition at line 6262 of file ordinal.c.

OBJCOMPAT_NOTAFILESYSTEM

#define OBJCOMPAT_NOTAFILESYSTEM   0x00000020

Definition at line 6257 of file ordinal.c.

OBJCOMPAT_OTNEEDSSFCACHE

#define OBJCOMPAT_OTNEEDSSFCACHE   0x00000001

Definition at line 6252 of file ordinal.c.

OBJCOMPAT_PINDLL

#define OBJCOMPAT_PINDLL   0x00000008

Definition at line 6255 of file ordinal.c.

OBJCOMPAT_UNBINDABLE

#define OBJCOMPAT_UNBINDABLE   0x00000004

Definition at line 6254 of file ordinal.c.

SHELL_NO_POLICY

#define SHELL_NO_POLICY   0xffffffff

Definition at line 2722 of file ordinal.c.

SHFORMATDT_UNSUPPORTED_FLAGS

#define SHFORMATDT_UNSUPPORTED_FLAGS   (FDTF_RELATIVE | FDTF_LTRDATE | FDTF_RTLDATE | FDTF_NOAUTOREADINGORDER)

Typedef Documentation

DllGetVersion_func

typedef HRESULT(WINAPI * DllGetVersion_func) (DLLVERSIONINFO *)

Definition at line 4925 of file ordinal.c.

enumWndData

typedef struct _enumWndData enumWndData

LPPOLICYDATA

typedef struct tagPOLICYDATA * LPPOLICYDATA

POLICYDATA

typedef struct tagPOLICYDATA POLICYDATA

PSHELL_USER_PERMISSION

typedef struct SHELL_USER_PERMISSION * PSHELL_USER_PERMISSION

PSHELL_USER_SID

typedef struct SHELL_USER_SID * PSHELL_USER_SID

SHELL_USER_PERMISSION

typedef struct SHELL_USER_PERMISSION SHELL_USER_PERMISSION

SHELL_USER_SID

typedef struct SHELL_USER_SID SHELL_USER_SID

Function Documentation

CLSIDFromStringWrap()

HRESULT WINAPI CLSIDFromStringWrap	(	LPCWSTR	idstr,
		CLSID *	id
	)

Definition at line 4090 of file ordinal.c.

{
    return CLSIDFromString((LPCOLESTR)idstr, id);
}

ColorAdjustLuma()

COLORREF WINAPI ColorAdjustLuma	(	COLORREF	cRGB,
		int	dwLuma,
		BOOL	bUnknown
	)

Definition at line 3786 of file ordinal.c.

{
  TRACE("(0x%8x,%d,%d)\n", cRGB, dwLuma, bUnknown);
 
  if (dwLuma)
  {
    WORD wH, wL, wS;
 
    ColorRGBToHLS(cRGB, &wH, &wL, &wS);
 
    FIXME("Ignoring luma adjustment\n");
 
    /* FIXME: The adjustment is not linear */
 
    cRGB = ColorHLSToRGB(wH, wL, wS);
  }
  return cRGB;
}

ColorHLSToRGB()

COLORREF WINAPI ColorHLSToRGB	(	WORD	wHue,
		WORD	wLuminosity,
		WORD	wSaturation
	)

Definition at line 3920 of file ordinal.c.

{
  WORD wRed;
 
  if (wSaturation)
  {
    WORD wGreen, wBlue, wMid1, wMid2;
 
    if (wLuminosity > 120)
      wMid2 = wSaturation + wLuminosity - (wSaturation * wLuminosity + 120) / 240;
    else
      wMid2 = ((wSaturation + 240) * wLuminosity + 120) / 240;
 
    wMid1 = wLuminosity * 2 - wMid2;
 
    wRed   = GET_RGB(wHue + 80);
    wGreen = GET_RGB(wHue);
    wBlue  = GET_RGB(wHue - 80);
 
    return RGB(wRed, wGreen, wBlue);
  }
 
  wRed = wLuminosity * 255 / 240;
  return RGB(wRed, wRed, wRed);
}

Referenced by ColorAdjustLuma().

ColorRGBToHLS()

VOID WINAPI ColorRGBToHLS	(	COLORREF	cRGB,
		LPWORD	pwHue,
		LPWORD	pwLuminance,
		LPWORD	pwSaturation
	)

Definition at line 4370 of file ordinal.c.

{
  int wR, wG, wB, wMax, wMin, wHue, wLuminosity, wSaturation;
 
  TRACE("(%08x,%p,%p,%p)\n", cRGB, pwHue, pwLuminance, pwSaturation);
 
  wR = GetRValue(cRGB);
  wG = GetGValue(cRGB);
  wB = GetBValue(cRGB);
 
  wMax = max(wR, max(wG, wB));
  wMin = min(wR, min(wG, wB));
 
  /* Luminosity */
  wLuminosity = ((wMax + wMin) * 240 + 255) / 510;
 
  if (wMax == wMin)
  {
    /* Achromatic case */
    wSaturation = 0;
    /* Hue is now unrepresentable, but this is what native returns... */
    wHue = 160;
  }
  else
  {
    /* Chromatic case */
    int wDelta = wMax - wMin, wRNorm, wGNorm, wBNorm;
 
    /* Saturation */
    if (wLuminosity <= 120)
      wSaturation = ((wMax + wMin)/2 + wDelta * 240) / (wMax + wMin);
    else
      wSaturation = ((510 - wMax - wMin)/2 + wDelta * 240) / (510 - wMax - wMin);
 
    /* Hue */
    wRNorm = (wDelta/2 + wMax * 40 - wR * 40) / wDelta;
    wGNorm = (wDelta/2 + wMax * 40 - wG * 40) / wDelta;
    wBNorm = (wDelta/2 + wMax * 40 - wB * 40) / wDelta;
 
    if (wR == wMax)
      wHue = wBNorm - wGNorm;
    else if (wG == wMax)
      wHue = 80 + wRNorm - wBNorm;
    else
      wHue = 160 + wGNorm - wRNorm;
    if (wHue < 0)
      wHue += 240;
    else if (wHue > 240)
      wHue -= 240;
  }
  if (pwHue)
    *pwHue = wHue;
  if (pwLuminance)
    *pwLuminance = wLuminosity;
  if (pwSaturation)
    *pwSaturation = wSaturation;
}

Referenced by ColorAdjustLuma().

ConnectToConnectionPoint()

HRESULT WINAPI ConnectToConnectionPoint	(	IUnknown *	lpUnkSink,
		REFIID	riid,
		BOOL	fConnect,
		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().

ConvertHue()

static WORD ConvertHue ( int  wHue, WORD  wMid1, WORD  wMid2  )

static

Definition at line 3887 of file ordinal.c.

{
  wHue = wHue > 240 ? wHue - 240 : wHue < 0 ? wHue + 240 : wHue;
 
  if (wHue > 160)
    return wMid1;
  else if (wHue > 120)
    wHue = 160 - wHue;
  else if (wHue > 40)
    return wMid2;
 
  return ((wHue * (wMid2 - wMid1) + 20) / 40) + wMid1;
}

DragQueryFileWrapW()

UINT WINAPI DragQueryFileWrapW	(	HDROP	hDrop,
		UINT	lFile,
		LPWSTR	lpszFile,
		UINT	lLength
	)

Definition at line 3452 of file ordinal.c.

{
    return DragQueryFileW(hDrop, lFile, lpszFile, lLength);
}

ExtractIconWrapW()

HICON WINAPI ExtractIconWrapW	(	HINSTANCE	hInstance,
		LPCWSTR	lpszExeFileName,
		UINT	nIconIndex
	)

Definition at line 3692 of file ordinal.c.

{
    return ExtractIconW(hInstance, lpszExeFileName, nIconIndex);
}

FDSA_DeleteItem()

BOOL WINAPI FDSA_DeleteItem	(	FDSA_info *	info,
		DWORD	where
	)

Definition at line 2368 of file ordinal.c.

{
    TRACE("(%p 0x%08x)\n", info, where);
 
    if(where >= info->num_items)
        return FALSE;
 
    if(where < info->num_items - 1)
    {
        memmove((char*)info->mem + where * info->block_size,
                (char*)info->mem + (where + 1) * info->block_size,
                (info->num_items - where - 1) * info->block_size);
    }
    memset((char*)info->mem + (info->num_items - 1) * info->block_size,
           0, info->block_size);
    info->num_items--;
    return TRUE;
}

FDSA_Destroy()

BOOL WINAPI FDSA_Destroy

(

FDSA_info *

info

)

Definition at line 2312 of file ordinal.c.

{
    TRACE("(%p)\n", info);
 
    if(info->flags & FDSA_FLAG_INTERNAL_ALLOC)
    {
        HeapFree(GetProcessHeap(), 0, info->mem);
        return FALSE;
    }
 
    return TRUE;
}

FDSA_Initialize()

BOOL WINAPI FDSA_Initialize	(	DWORD	block_size,
		DWORD	inc,
		FDSA_info *	info,
		void *	mem,
		DWORD	init_blocks
	)

Definition at line 2286 of file ordinal.c.

{
    TRACE("(0x%08x 0x%08x %p %p 0x%08x)\n", block_size, inc, info, mem, init_blocks);
 
    if(inc == 0)
        inc = 1;
 
    if(mem)
        memset(mem, 0, block_size * init_blocks);
    
    info->num_items = 0;
    info->inc = inc;
    info->mem = mem;
    info->blocks_alloced = init_blocks;
    info->block_size = block_size;
    info->flags = 0;
 
    return TRUE;
}

FDSA_InsertItem()

DWORD WINAPI FDSA_InsertItem	(	FDSA_info *	info,
		DWORD	where,
		const void *	block
	)

Definition at line 2330 of file ordinal.c.

{
    TRACE("(%p 0x%08x %p)\n", info, where, block);
    if(where > info->num_items)
        where = info->num_items;
 
    if(info->num_items >= info->blocks_alloced)
    {
        DWORD size = (info->blocks_alloced + info->inc) * info->block_size;
        if(info->flags & 0x1)
            info->mem = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->mem, size);
        else
        {
            void *old_mem = info->mem;
            info->mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
            memcpy(info->mem, old_mem, info->blocks_alloced * info->block_size);
        }
        info->blocks_alloced += info->inc;
        info->flags |= 0x1;
    }
 
    if(where < info->num_items)
    {
        memmove((char*)info->mem + (where + 1) * info->block_size,
                (char*)info->mem + where * info->block_size,
                (info->num_items - where) * info->block_size);
    }
    memcpy((char*)info->mem + where * info->block_size, block, info->block_size);
 
    info->num_items++;
    return where;
}

FixSlashesAndColonW()

VOID WINAPI FixSlashesAndColonW

(

LPWSTR

lpwstr

)

Definition at line 4551 of file ordinal.c.

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

Referenced by PathQualifyExW().

GetAcceptLanguagesA()

HRESULT WINAPI GetAcceptLanguagesA	(	LPSTR	langbuf,
		LPDWORD	buflen
	)

Definition at line 577 of file ordinal.c.

{
    WCHAR *langbufW;
    DWORD buflenW, convlen;
    HRESULT retval;
 
    TRACE("(%p, %p) *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
 
    if(!langbuf || !buflen || !*buflen) return E_FAIL;
 
    buflenW = *buflen;
    langbufW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * buflenW);
    retval = GetAcceptLanguagesW(langbufW, &buflenW);
 
    if (retval == S_OK)
    {
        convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, -1, langbuf, *buflen, NULL, NULL);
        convlen--;  /* do not count the terminating 0 */
    }
    else  /* copy partial string anyway */
    {
        convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, *buflen, langbuf, *buflen, NULL, NULL);
        if (convlen < *buflen)
        {
            langbuf[convlen] = 0;
            convlen--;  /* do not count the terminating 0 */
        }
        else
        {
            convlen = *buflen;
        }
    }
    *buflen = buflenW ? convlen : 0;
 
    HeapFree(GetProcessHeap(), 0, langbufW);
    return retval;
}

Referenced by init_pointers().

GetAcceptLanguagesW()

HRESULT WINAPI GetAcceptLanguagesW	(	LPWSTR	langbuf,
		LPDWORD	buflen
	)

Definition at line 518 of file ordinal.c.

{
    static const WCHAR szkeyW[] = {
    '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','\\',
    'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
    static const WCHAR valueW[] = {
    'A','c','c','e','p','t','L','a','n','g','u','a','g','e',0};
    DWORD mystrlen, mytype;
    DWORD len;
    HKEY mykey;
    LCID mylcid;
    WCHAR *mystr;
    LONG lres;
 
    TRACE("(%p, %p) *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
 
    if(!langbuf || !buflen || !*buflen)
    return E_FAIL;
 
    mystrlen = (*buflen > 20) ? *buflen : 20 ;
    len = mystrlen * sizeof(WCHAR);
    mystr = HeapAlloc(GetProcessHeap(), 0, len);
    mystr[0] = 0;
    RegOpenKeyW(HKEY_CURRENT_USER, szkeyW, &mykey);
    lres = RegQueryValueExW(mykey, valueW, 0, &mytype, (PBYTE)mystr, &len);
    RegCloseKey(mykey);
    len = lstrlenW(mystr);
 
    if (!lres && (*buflen > len)) {
        lstrcpyW(langbuf, mystr);
        *buflen = len;
        HeapFree(GetProcessHeap(), 0, mystr);
        return S_OK;
    }
 
    /* Did not find a value in the registry or the user buffer is too small */
    mylcid = GetUserDefaultLCID();
    LcidToRfc1766W(mylcid, mystr, mystrlen);
    len = lstrlenW(mystr);
 
    memcpy( langbuf, mystr, min(*buflen, len+1)*sizeof(WCHAR) );
    HeapFree(GetProcessHeap(), 0, mystr);
 
    if (*buflen > len) {
        *buflen = len;
        return S_OK;
    }
 
    *buflen = 0;
    return E_NOT_SUFFICIENT_BUFFER;
}

Referenced by GetAcceptLanguagesA().

GetFileVersionInfoSizeWrapW()

DWORD WINAPI GetFileVersionInfoSizeWrapW	(	LPCWSTR	filename,
		LPDWORD	handle
	)

Definition at line 3511 of file ordinal.c.

{
    return GetFileVersionInfoSizeW( filename, handle );
}

GetFileVersionInfoWrapW()

BOOL WINAPI GetFileVersionInfoWrapW	(	LPCWSTR	filename,
		DWORD	handle,
		DWORD	datasize,
		LPVOID	data
	)

Definition at line 3521 of file ordinal.c.

{
    return GetFileVersionInfoW( filename, handle, datasize, data );
}

GetMenuPosFromID()

INT WINAPI GetMenuPosFromID	(	HMENU	hMenu,
		UINT	wID
	)

Definition at line 4514 of file ordinal.c.

{
    MENUITEMINFOW mi;
    INT nCount = GetMenuItemCount(hMenu), nIter = 0;
 
    TRACE("%p %u\n", hMenu, wID);
 
    while (nIter < nCount)
    {
        mi.cbSize = sizeof(mi);
        mi.fMask = MIIM_ID;
        if (GetMenuItemInfoW(hMenu, nIter, TRUE, &mi) && mi.wID == wID)
        {
            TRACE("ret %d\n", nIter);
            return nIter;
        }
        nIter++;
    }
 
    return -1;
}

Referenced by DeleteMenuEx(), and SHMenuIndexFromID().

GetOpenFileNameWrapW()

BOOL WINAPI GetOpenFileNameWrapW

(

LPOPENFILENAMEW

ofn

)

Definition at line 3861 of file ordinal.c.

{
    return GetOpenFileNameW(ofn);
}

GetSaveFileNameWrapW()

BOOL WINAPI GetSaveFileNameWrapW

(

LPOPENFILENAMEW

ofn

)

Definition at line 3810 of file ordinal.c.

{
    return GetSaveFileNameW(ofn);
}

GetShellSecurityDescriptor()

PSECURITY_DESCRIPTOR WINAPI GetShellSecurityDescriptor	(	const PSHELL_USER_PERMISSION *	apUserPerm,
		int	cUserPerm
	)

Definition at line 5080 of file ordinal.c.

{
    PSID *sidlist;
    PSID  cur_user = NULL;
    BYTE  tuUser[2000];
    DWORD acl_size;
    int   sid_count, i;
    PSECURITY_DESCRIPTOR psd = NULL;
 
    TRACE("%p %d\n", apUserPerm, cUserPerm);
 
    if (apUserPerm == NULL || cUserPerm <= 0)
        return NULL;
 
    sidlist = HeapAlloc(GetProcessHeap(), 0, cUserPerm * sizeof(PSID));
    if (!sidlist)
        return NULL;
 
    acl_size = sizeof(ACL);
 
    for(sid_count = 0; sid_count < cUserPerm; sid_count++)
    {
        static SHELL_USER_SID null_sid = {{SECURITY_NULL_SID_AUTHORITY}, 0, 0};
        PSHELL_USER_PERMISSION perm = apUserPerm[sid_count];
        PSHELL_USER_SID sid = &perm->susID;
        PSID pSid;
        BOOL ret = TRUE;
 
        if (!memcmp((void*)sid, (void*)&null_sid, sizeof(SHELL_USER_SID)))
        {  /* current user's SID */ 
            if (!cur_user)
            {
                HANDLE Token;
                DWORD bufsize = sizeof(tuUser);
 
                ret = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &Token);
                if (ret)
                {
                    ret = GetTokenInformation(Token, TokenUser, (void*)tuUser, bufsize, &bufsize );
                    if (ret)
                        cur_user = ((PTOKEN_USER)tuUser)->User.Sid;
                    CloseHandle(Token);
                }
            }
            pSid = cur_user;
        } else if (sid->dwUserID==0) /* one sub-authority */
            ret = AllocateAndInitializeSid(&sid->sidAuthority, 1, sid->dwUserGroupID, 0,
                    0, 0, 0, 0, 0, 0, &pSid);
        else
            ret = AllocateAndInitializeSid(&sid->sidAuthority, 2, sid->dwUserGroupID, sid->dwUserID,
                    0, 0, 0, 0, 0, 0, &pSid);
        if (!ret)
            goto free_sids;
 
        sidlist[sid_count] = pSid;
        /* increment acl_size (1 ACE for non-inheritable and 2 ACEs for inheritable records */
        acl_size += (sizeof(ACCESS_ALLOWED_ACE)-sizeof(DWORD) + GetLengthSid(pSid)) * (perm->fInherit ? 2 : 1);
    }
 
    psd = LocalAlloc(0, sizeof(SECURITY_DESCRIPTOR) + acl_size);
 
    if (psd != NULL)
    {
        PACL pAcl = (PACL)(((BYTE*)psd)+sizeof(SECURITY_DESCRIPTOR));
 
        if (!InitializeSecurityDescriptor(psd, SECURITY_DESCRIPTOR_REVISION))
            goto error;
 
        if (!InitializeAcl(pAcl, acl_size, ACL_REVISION))
            goto error;
 
        for(i = 0; i < sid_count; i++)
        {
            PSHELL_USER_PERMISSION sup = apUserPerm[i];
            PSID sid = sidlist[i];
 
            switch(sup->dwAccessType)
            {
                case ACCESS_ALLOWED_ACE_TYPE:
                    if (!AddAccessAllowedAce(pAcl, ACL_REVISION, sup->dwAccessMask, sid))
                        goto error;
                    if (sup->fInherit && !AddAccessAllowedAceEx(pAcl, ACL_REVISION, 
                                (BYTE)sup->dwInheritMask, sup->dwInheritAccessMask, sid))
                        goto error;
                    break;
                case ACCESS_DENIED_ACE_TYPE:
                    if (!AddAccessDeniedAce(pAcl, ACL_REVISION, sup->dwAccessMask, sid))
                        goto error;
                    if (sup->fInherit && !AddAccessDeniedAceEx(pAcl, ACL_REVISION, 
                                (BYTE)sup->dwInheritMask, sup->dwInheritAccessMask, sid))
                        goto error;
                    break;
                default:
                    goto error;
            }
        }
 
        if (!SetSecurityDescriptorDacl(psd, TRUE, pAcl, FALSE))
            goto error;
    }
    goto free_sids;
 
error:
    LocalFree(psd);
    psd = NULL;
free_sids:
    for(i = 0; i < sid_count; i++)
    {
        if (!cur_user || sidlist[i] != cur_user)
            FreeSid(sidlist[i]);
    }
    HeapFree(GetProcessHeap(), 0, sidlist);
 
    return psd;
}

Referenced by init_pointers().

GetStringType3ExW()

BOOL WINAPI GetStringType3ExW	(	LPWSTR	src,
		INT	count,
		LPWORD	type
	)

Definition at line 783 of file ordinal.c.

{
    return GetStringTypeW(CT_CTYPE3, src, count, type);
}

GetUIVersion()

DWORD WINAPI GetUIVersion

(

void

)

Definition at line 4930 of file ordinal.c.

{
    static DWORD version;
 
    if (!version)
    {
        DllGetVersion_func pDllGetVersion;
        HMODULE dll = LoadLibraryA("shell32.dll");
        if (!dll) return 0;
 
        pDllGetVersion = (DllGetVersion_func)GetProcAddress(dll, "DllGetVersion");
        if (pDllGetVersion)
        {
            DLLVERSIONINFO dvi;
            dvi.cbSize = sizeof(DLLVERSIONINFO);
            if (pDllGetVersion(&dvi) == S_OK) version = dvi.dwMajorVersion;
        }
        FreeLibrary( dll );
        if (!version) version = 3;  /* old shell dlls don't have DllGetVersion */
    }
    return version;
}

GUIDFromStringA()

BOOL WINAPI GUIDFromStringA	(	LPCSTR	idstr,
		CLSID *	id
	)

Definition at line 2916 of file ordinal.c.

{
  WCHAR wClsid[40];
  MultiByteToWideChar(CP_ACP, 0, idstr, -1, wClsid, sizeof(wClsid)/sizeof(WCHAR));
  return SUCCEEDED(CLSIDFromString(wClsid, id));
}

Referenced by init_pointers().

GUIDFromStringW()

BOOL WINAPI GUIDFromStringW	(	LPCWSTR	idstr,
		CLSID *	id
	)

Definition at line 2928 of file ordinal.c.

{
    return SUCCEEDED(CLSIDFromString((LPCOLESTR)idstr, id));
}

IConnectionPoint_InvokeWithCancel()

HRESULT WINAPI IConnectionPoint_InvokeWithCancel	(	IConnectionPoint *	iCP,
		DISPID	dispId,
		DISPPARAMS *	dispParams,
		DWORD	unknown1,
		DWORD	unknown2
	)

Definition at line 3184 of file ordinal.c.

{
    IID iid;
    HRESULT result;
 
    FIXME("(%p)->(0x%x %p %x %x) partial stub\n", iCP, dispId, dispParams, unknown1, unknown2);
 
    result = IConnectionPoint_GetConnectionInterface(iCP, &iid);
    if (SUCCEEDED(result))
        result = SHLWAPI_InvokeByIID(iCP, &iid, dispId, dispParams);
    else
        result = SHLWAPI_InvokeByIID(iCP, NULL, dispId, dispParams);
 
    return result;
}

Referenced by init_pointers().

IConnectionPoint_OnChanged()

HRESULT WINAPI IConnectionPoint_OnChanged	(	IConnectionPoint *	lpCP,
		DISPID	dispID
	)

Definition at line 3241 of file ordinal.c.

{
  IEnumConnections *lpEnum;
  HRESULT hRet = E_NOINTERFACE;
 
  TRACE("(%p,0x%8X)\n", lpCP, dispID);
 
  /* Get an enumerator for the connections */
  if (lpCP)
    hRet = IConnectionPoint_EnumConnections(lpCP, &lpEnum);
 
  if (SUCCEEDED(hRet))
  {
    IPropertyNotifySink *lpSink;
    CONNECTDATA connData;
    ULONG ulFetched;
 
    /* Call OnChanged() for every notify sink in the connection point */
    while (IEnumConnections_Next(lpEnum, 1, &connData, &ulFetched) == S_OK)
    {
      if (SUCCEEDED(IUnknown_QueryInterface(connData.pUnk, &IID_IPropertyNotifySink, (void**)&lpSink)) &&
          lpSink)
      {
        IPropertyNotifySink_OnChanged(lpSink, dispID);
        IPropertyNotifySink_Release(lpSink);
      }
      IUnknown_Release(connData.pUnk);
    }
 
    IEnumConnections_Release(lpEnum);
  }
  return hRet;
}

Referenced by IUnknown_CPContainerOnChanged().

IConnectionPoint_SimpleInvoke()

HRESULT WINAPI IConnectionPoint_SimpleInvoke	(	IConnectionPoint *	iCP,
		DISPID	dispId,
		DISPPARAMS *	dispParams
	)

Definition at line 3208 of file ordinal.c.

{
  IID iid;
  HRESULT result;
 
  TRACE("(%p)->(0x%x %p)\n",iCP,dispId,dispParams);
 
  result = IConnectionPoint_GetConnectionInterface(iCP, &iid);
  if (SUCCEEDED(result))
    result = SHLWAPI_InvokeByIID(iCP, &iid, dispId, dispParams);
  else
    result = SHLWAPI_InvokeByIID(iCP, NULL, dispId, dispParams);
 
  return result;
}

Referenced by init_pointers().

IsCharBlankW()

BOOL WINAPI IsCharBlankW

(

WCHAR

wc

)

Definition at line 696 of file ordinal.c.

{
    WORD CharType;
 
    return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_BLANK);
}

IsCharCntrlW()

BOOL WINAPI IsCharCntrlW

(

WCHAR

wc

)

Definition at line 734 of file ordinal.c.

{
    WORD CharType;
 
    return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_CNTRL);
}

IsCharDigitW()

BOOL WINAPI IsCharDigitW

(

WCHAR

wc

)

Definition at line 753 of file ordinal.c.

{
    WORD CharType;
 
    return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_DIGIT);
}

IsCharPunctW()

BOOL WINAPI IsCharPunctW

(

WCHAR

wc

)

Definition at line 715 of file ordinal.c.

{
    WORD CharType;
 
    return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_PUNCT);
}

IsCharXDigitW()

BOOL WINAPI IsCharXDigitW

(

WCHAR

wc

)

Definition at line 772 of file ordinal.c.

{
    WORD CharType;
 
    return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_XDIGIT);
}

IsOS()

BOOL WINAPI IsOS

(

DWORD

feature

)

Definition at line 4107 of file ordinal.c.

{
#ifdef __REACTOS__
    OSVERSIONINFOEXA osvi;
    DWORD platform, majorv, minorv;
 
    osvi.dwOSVersionInfoSize = sizeof(osvi);
    if (!GetVersionExA((OSVERSIONINFOA*)&osvi))
    {
        osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
        if (!GetVersionExA((OSVERSIONINFOA*)&osvi))
        {
            ERR("GetVersionEx failed\n");
            return FALSE;
        }
        osvi.wProductType = VER_NT_WORKSTATION;
        osvi.wSuiteMask = 0;
    }
#else
    OSVERSIONINFOA osvi;
    DWORD platform, majorv, minorv;
 
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
    if(!GetVersionExA(&osvi))  {
        ERR("GetVersionEx failed\n");
        return FALSE;
    }
#endif
    majorv = osvi.dwMajorVersion;
    minorv = osvi.dwMinorVersion;
    platform = osvi.dwPlatformId;
 
#define ISOS_RETURN(x) \
    TRACE("(0x%x) ret=%d\n",feature,(x)); \
    return (x);
 
    switch(feature)  {
    case OS_WIN32SORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32s
                 || platform == VER_PLATFORM_WIN32_WINDOWS)
    case OS_NT:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
    case OS_WIN95ORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS)
    case OS_NT4ORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 4)
    case OS_WIN2000ORGREATER_ALT:
    case OS_WIN2000ORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5)
    case OS_WIN98ORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv >= 10)
    case OS_WIN98_GOLD:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv == 10)
    case OS_WIN2000PRO:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5)
    case OS_WIN2000SERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
    case OS_WIN2000ADVSERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
    case OS_WIN2000DATACENTER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
    case OS_WIN2000TERMINAL:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
    case OS_EMBEDDED:
        FIXME("(OS_EMBEDDED) What should we return here?\n");
        return FALSE;
    case OS_TERMINALCLIENT:
        FIXME("(OS_TERMINALCLIENT) What should we return here?\n");
        return FALSE;
    case OS_TERMINALREMOTEADMIN:
        FIXME("(OS_TERMINALREMOTEADMIN) What should we return here?\n");
        return FALSE;
    case OS_WIN95_GOLD:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv == 0)
    case OS_MEORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv >= 90)
    case OS_XPORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5 && minorv >= 1)
    case OS_HOME:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5 && minorv >= 1)
    case OS_PROFESSIONAL:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
    case OS_DATACENTER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
    case OS_ADVSERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5)
    case OS_SERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
    case OS_TERMINALSERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
    case OS_PERSONALTERMINALSERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && minorv >= 1 && majorv >= 5)
    case OS_FASTUSERSWITCHING:
        FIXME("(OS_FASTUSERSWITCHING) What should we return here?\n");
        return TRUE;
    case OS_WELCOMELOGONUI:
        FIXME("(OS_WELCOMELOGONUI) What should we return here?\n");
        return FALSE;
    case OS_DOMAINMEMBER:
        FIXME("(OS_DOMAINMEMBER) What should we return here?\n");
        return TRUE;
    case OS_ANYSERVER:
#ifdef __REACTOS__
        ISOS_RETURN(osvi.wProductType > VER_NT_WORKSTATION)
#else
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
#endif
    case OS_WOW6432:
        {
            BOOL is_wow64;
            IsWow64Process(GetCurrentProcess(), &is_wow64);
            return is_wow64;
        }
    case OS_WEBSERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
    case OS_SMALLBUSINESSSERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
    case OS_TABLETPC:
        FIXME("(OS_TABLETPC) What should we return here?\n");
        return FALSE;
    case OS_SERVERADMINUI:
        FIXME("(OS_SERVERADMINUI) What should we return here?\n");
        return FALSE;
    case OS_MEDIACENTER:
        FIXME("(OS_MEDIACENTER) What should we return here?\n");
        return FALSE;
    case OS_APPLIANCE:
        FIXME("(OS_APPLIANCE) What should we return here?\n");
        return FALSE;
    case 0x25: /*OS_VISTAORGREATER*/
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 6)
    }
 
#undef ISOS_RETURN
 
    WARN("(0x%x) unknown parameter\n",feature);
 
    return FALSE;
}

Referenced by CDefView::GetDefaultViewMode(), CShellDispatch::GetSetting(), CShellDispatch::GetSystemInformation(), and IsSystem64Bit().

IsQSForward()

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

Definition at line 2235 of file ordinal.c.

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

IUnknown_AtomicRelease()

void WINAPI IUnknown_AtomicRelease

(

IUnknown **

lpUnknown

)

Definition at line 1245 of file ordinal.c.

{
    TRACE("(%p)\n", lpUnknown);
 
    if(!lpUnknown || !*lpUnknown) return;
 
    TRACE("doing Release\n");
 
    IUnknown_Release(*lpUnknown);
    *lpUnknown = NULL;
}

Referenced by IUnknown_Set(), and SHWeakReleaseInterface().

IUnknown_CPContainerInvokeParam()

HRESULT WINAPIV IUnknown_CPContainerInvokeParam	(	IUnknown *	container,
		REFIID	riid,
		DISPID	dispId,
		VARIANTARG *	buffer,
		DWORD	cParams,
			...
	)

Definition at line 3280 of file ordinal.c.

{
  HRESULT result;
  IConnectionPoint *iCP;
  IConnectionPointContainer *iCPC;
  DISPPARAMS dispParams = {buffer, NULL, cParams, 0};
  __ms_va_list valist;
 
  if (!container)
    return E_NOINTERFACE;
 
  result = IUnknown_QueryInterface(container, &IID_IConnectionPointContainer,(LPVOID*) &iCPC);
  if (FAILED(result))
      return result;
 
  result = IConnectionPointContainer_FindConnectionPoint(iCPC, riid, &iCP);
  IConnectionPointContainer_Release(iCPC);
  if(FAILED(result))
      return result;
 
  __ms_va_start(valist, cParams);
  SHPackDispParamsV(&dispParams, buffer, cParams, valist);
  __ms_va_end(valist);
 
  result = SHLWAPI_InvokeByIID(iCP, riid, dispId, &dispParams);
  IConnectionPoint_Release(iCP);
 
  return result;
}

IUnknown_CPContainerOnChanged()

HRESULT WINAPI IUnknown_CPContainerOnChanged	(	IUnknown *	lpUnknown,
		DISPID	dispID
	)

Definition at line 3329 of file ordinal.c.

{
  IConnectionPointContainer* lpCPC = NULL;
  HRESULT hRet = E_NOINTERFACE;
 
  TRACE("(%p,0x%8X)\n", lpUnknown, dispID);
 
  if (lpUnknown)
    hRet = IUnknown_QueryInterface(lpUnknown, &IID_IConnectionPointContainer, (void**)&lpCPC);
 
  if (SUCCEEDED(hRet))
  {
    IConnectionPoint* lpCP;
 
    hRet = IConnectionPointContainer_FindConnectionPoint(lpCPC, &IID_IPropertyNotifySink, &lpCP);
    IConnectionPointContainer_Release(lpCPC);
 
    hRet = IConnectionPoint_OnChanged(lpCP, dispID);
    IConnectionPoint_Release(lpCP);
  }
  return hRet;
}

IUnknown_EnableModeless()

HRESULT WINAPI IUnknown_EnableModeless	(	IUnknown *	lpUnknown,
		BOOL	bModeless
	)

Definition at line 3561 of file ordinal.c.

{
  IUnknown *lpObj;
  HRESULT hRet;
 
  TRACE("(%p,%d)\n", lpUnknown, bModeless);
 
  if (!lpUnknown)
    return E_FAIL;
 
  if (IsIface(IOleInPlaceActiveObject))
    EnableModeless(IOleInPlaceActiveObject);
  else if (IsIface(IOleInPlaceFrame))
    EnableModeless(IOleInPlaceFrame);
  else if (IsIface(IShellBrowser))
    EnableModeless(IShellBrowser);
  else if (IsIface(IInternetSecurityMgrSite))
    EnableModeless(IInternetSecurityMgrSite);
  else if (IsIface(IDocHostUIHandler))
    EnableModeless(IDocHostUIHandler);
  else
    return hRet;
 
  IUnknown_Release(lpObj);
  return S_OK;
}

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(), CTrayWindow::CheckTrayWndPosition(), CInternetToolbar::CreateMenuBar(), CBaseBar::Exec(), CShellBrowser::Exec(), CMenuSite::Exec(), ExecResetDefViewFolderSettings(), CShellBrowser::Initialize(), CISFBand::InvokeCommand(), 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 *	clsid
	)

Definition at line 1457 of file ordinal.c.

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

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

IUnknown_GetSite()

HRESULT WINAPI IUnknown_GetSite	(	LPUNKNOWN	lpUnknown,
		REFIID	iid,
		PVOID *	lppSite
	)

Definition at line 2642 of file ordinal.c.

{
  HRESULT hRet = E_INVALIDARG;
  LPOBJECTWITHSITE lpSite = NULL;
 
  TRACE("(%p,%s,%p)\n", lpUnknown, debugstr_guid(iid), lppSite);
 
  if (lpUnknown && iid && lppSite)
  {
    hRet = IUnknown_QueryInterface(lpUnknown, &IID_IObjectWithSite,
                                   (void**)&lpSite);
    if (SUCCEEDED(hRet) && lpSite)
    {
      hRet = IObjectWithSite_GetSite(lpSite, iid, lppSite);
      IObjectWithSite_Release(lpSite);
    }
  }
  return hRet;
}

Referenced by CMenuDeskBar::_IsSubMenuParent(), CShellMenuCallback::OnInitMenu(), and CMenuFocusManager::UpdateFocus().

IUnknown_GetWindow()

HRESULT WINAPI IUnknown_GetWindow	(	IUnknown *	lpUnknown,
		HWND *	lphWnd
	)

Definition at line 1336 of file ordinal.c.

{
  IUnknown *lpOle;
  HRESULT hRet = E_FAIL;
 
  TRACE("(%p,%p)\n", lpUnknown, lphWnd);
 
  if (!lpUnknown)
    return hRet;
 
  hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleWindow, (void**)&lpOle);
 
  if (FAILED(hRet))
  {
    hRet = IUnknown_QueryInterface(lpUnknown,&IID_IShellView, (void**)&lpOle);
 
    if (FAILED(hRet))
    {
      hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInternetSecurityMgrSite,
                                      (void**)&lpOle);
    }
  }
 
  if (SUCCEEDED(hRet))
  {
    /* Laziness here - Since GetWindow() is the first method for the above 3
     * interfaces, we use the same call for them all.
     */
    hRet = IOleWindow_GetWindow((IOleWindow*)lpOle, lphWnd);
    IUnknown_Release(lpOle);
    if (lphWnd)
      TRACE("Returning HWND=%p\n", *lphWnd);
  }
 
  return hRet;
}

Referenced by CMenuDeskBar::_IsSubMenuParent(), CMenuSite::AddBand(), BindCtx_GetUIWindow(), CInternetToolbar::CreateMenuBar(), CFSDropTarget::Drop(), CAddressEditBox::Execute(), CShellBrowser::GetControlWindow(), GetUiOwner(), CDockSite::Initialize(), CInternetToolbar::InitNew(), CTrayNotifyWnd::OnCreate(), CTrayWindow::OnCreate(), CShellMenuCallback::OnInitMenu(), CTrayWindow::OnOpenStartMenu(), CInternetToolbar::OnWinIniChange(), CAddressEditBox::ParseNow(), CShellBrowser::RepositionBars(), CMenuDeskBar::SetClient(), CMenuSite::SetDeskBarSite(), CISFBand::SetSite(), CTaskBand::SetSite(), CAddressBand::SetSite(), CInternetToolbar::SetSite(), CSearchBar::SetSite(), CToolsBand::SetSite(), and SHMultiFileProperties().

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 *

lpUnknown

)

Definition at line 4332 of file ordinal.c.

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

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

IUnknown_OnFocusChangeIS()

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

Definition at line 4804 of file ordinal.c.

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

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

IUnknown_OnFocusOCS()

HRESULT WINAPI IUnknown_OnFocusOCS	(	IUnknown *	lpUnknown,
		BOOL	fGotFocus
	)

Definition at line 1931 of file ordinal.c.

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

IUnknown_ProfferService()

HRESULT WINAPI IUnknown_ProfferService	(	IUnknown *	lpUnknown,
		REFGUID	service,
		IServiceProvider *	pService,
		DWORD *	pCookie
	)

Definition at line 1592 of file ordinal.c.

{
    IProfferService *proffer;
    HRESULT hr;
 
    TRACE("%p %s %p %p\n", lpUnknown, debugstr_guid(service), pService, pCookie);
 
    hr = IUnknown_QueryService(lpUnknown, &IID_IProfferService, &IID_IProfferService, (void**)&proffer);
    if (hr == S_OK)
    {
        if (pService)
            hr = IProfferService_ProfferService(proffer, service, pService, pCookie);
        else
        {
            hr = IProfferService_RevokeService(proffer, *pCookie);
            *pCookie = 0;
        }
 
        IProfferService_Release(proffer);
    }
 
    return hr;
}

Referenced by init_pointers().

IUnknown_QueryService()

HRESULT WINAPI IUnknown_QueryService	(	IUnknown *	lpUnknown,
		REFGUID	sid,
		REFIID	riid,
		LPVOID *	lppOut
	)

Definition at line 1501 of file ordinal.c.

{
  IServiceProvider* pService = NULL;
  HRESULT hRet;
 
  if (!lppOut)
    return E_FAIL;
 
  *lppOut = NULL;
 
  if (!lpUnknown)
    return E_FAIL;
 
  hRet = IUnknown_QueryInterface(lpUnknown, &IID_IServiceProvider,
                                 (LPVOID*)&pService);
 
  if (hRet == S_OK && pService)
  {
    TRACE("QueryInterface returned (IServiceProvider*)%p\n", pService);
 
    /* Get a Service interface from the object */
    hRet = IServiceProvider_QueryService(pService, sid, riid, lppOut);
 
    TRACE("(IServiceProvider*)%p returned (IUnknown*)%p\n", pService, *lppOut);
 
    IServiceProvider_Release(pService);
  }
  return hRet;
}

Referenced by CDefViewBckgrndMenu::_bIsDesktopBrowserMenu(), CExplorerBand::_CreateTreeView(), CExplorerBand::_DestroyTreeView(), CDefView::_MergeToolbar(), CMenuDeskBar::_OnActivate(), CDefaultContextMenu::BrowserFlagsFromVerb(), CDefaultContextMenu::DoCopyOrCut(), CDefaultContextMenu::DoCreateNewFolder(), CDefaultContextMenu::DoRename(), CFSDropTarget::Drop(), CAddressEditBox::Execute(), CBandProxy::FindBrowserWindow(), CAddressEditBox::GetAbsolutePidl(), CShellBrowser::GetMenuBand(), CSearchBar::GetSearchResultsFolder(), CFolderOptions::HandleDefFolderSettings(), CAddressEditBox::Init(), CDefViewBckgrndMenu::InvokeCommand(), CNetConUiObject::InvokeCommand(), CAddressBand::IsGoButtonVisible(), CMenuFocusManager::IsTrackedWindowOrParent(), IUnknown_HandleIRestrict(), IUnknown_ProfferService(), IUnknown_QueryServiceExec(), IUnknown_QueryServiceForWebBrowserApp(), IUnknown_QueryServicePropertyBag(), CFindFolder::MessageSFVCB(), CSearchBar::OnInitDialog(), CInternetToolbar::OnMenuDropDown(), CSearchBar::OnSearchButtonClicked(), CInternetToolbar::OnTravelBack(), CInternetToolbar::OnTravelForward(), CAddressEditBox::ParseNow(), CMenuDeskBar::Popup(), CInternetToolbar::QueryService(), CDefView::QueryService(), CMenuDeskBar::QueryService(), CMenuSite::QueryService(), CDefaultContextMenu::QueryService(), RegisterDefaultAcceptHeaders(), CNewMenu::SelectNewItem(), CAddressEditBox::SetOwner(), CInternetToolbar::SetSite(), CMenuBand::SetSite(), CMenuDeskBar::SetSite(), SHShouldShowWizards(), CDefaultContextMenu::TryToBrowse(), and CMenuBand::UIActivateIO().

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	(	IUnknown *	lpUnknown,
		REFGUID	riid,
		LPVOID *	lppOut
	)

Definition at line 5414 of file ordinal.c.

{
    FIXME("%p %s %p semi-STUB\n", lpUnknown, debugstr_guid(riid), lppOut);
    return IUnknown_QueryService(lpUnknown,&IID_IWebBrowserApp,riid,lppOut);
}

IUnknown_QueryStatus()

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

Definition at line 1048 of file ordinal.c.

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

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

IUnknown_Set()

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

Definition at line 2190 of file ordinal.c.

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

Referenced by Free(), and CObjectWithSiteBase::SetSite().

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

HRESULT WINAPI IUnknown_SetSite	(	IUnknown *	obj,
		IUnknown *	site
	)

Definition at line 1411 of file ordinal.c.

{
    HRESULT hr;
    IObjectWithSite *iobjwithsite;
    IInternetSecurityManager *isecmgr;
 
    if (!obj) return E_FAIL;
 
    hr = IUnknown_QueryInterface(obj, &IID_IObjectWithSite, (LPVOID *)&iobjwithsite);
    TRACE("IID_IObjectWithSite QI ret=%08x, %p\n", hr, iobjwithsite);
    if (SUCCEEDED(hr))
    {
    hr = IObjectWithSite_SetSite(iobjwithsite, site);
    TRACE("done IObjectWithSite_SetSite ret=%08x\n", hr);
    IObjectWithSite_Release(iobjwithsite);
    }
    else
    {
    hr = IUnknown_QueryInterface(obj, &IID_IInternetSecurityManager, (LPVOID *)&isecmgr);
    TRACE("IID_IInternetSecurityManager QI ret=%08x, %p\n", hr, isecmgr);
    if (FAILED(hr)) return hr;
 
    hr = IInternetSecurityManager_SetSecuritySite(isecmgr, (IInternetSecurityMgrSite *)site);
    TRACE("done IInternetSecurityManager_SetSecuritySite ret=%08x\n", hr);
    IInternetSecurityManager_Release(isecmgr);
    }
    return hr;
}

Referenced by CMenuBand::_OnPopupSubMenu(), CMenuSite::AddBand(), CShellBrowser::BrowseToPath(), CreateStartMenu(), CShellBrowser::DoFolderOptions(), CDefView::drag_notify_subitem(), CDefView::FillFileMenu(), CShellBrowser::GetBaseBar(), CDefView::GetItemObject(), CShellBrowser::Initialize(), CDockSite::Initialize(), CDefView::InvokeContextMenuCommand(), InvokeIExecuteCommand(), CDefaultContextMenu::InvokeRegVerb(), CDefaultContextMenu::LoadDynamicContextMenuHandler(), CDefView::OnDestroy(), CMenuBand::SetClient(), CMenuSite::SetDeskBarSite(), CDefViewBckgrndMenu::SetSite(), SHInvokeCommandOnContextMenuInternal(), CDefaultContextMenu::~CDefaultContextMenu(), and MenuCleanup::~MenuCleanup().

IUnknown_TranslateAcceleratorIO()

HRESULT WINAPI IUnknown_TranslateAcceleratorIO	(	IUnknown *	lpUnknown,
		LPMSG	lpMsg
	)

Definition at line 4300 of file ordinal.c.

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

Referenced by CBaseBarSite::TranslateAcceleratorIO(), CInternetToolbar::TranslateAcceleratorIO(), CBaseBar::TranslateAcceleratorIO(), CMenuDeskBar::TranslateAcceleratorIO(), and CShellBrowser::v_MayTranslateAccelerator().

IUnknown_TranslateAcceleratorOCS()

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

Definition at line 1898 of file ordinal.c.

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

IUnknown_UIActivateIO()

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

Definition at line 1633 of file ordinal.c.

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

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

MayExecForward()

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

Definition at line 2222 of file ordinal.c.

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

MayQSForward()

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

Definition at line 2207 of file ordinal.c.

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

MLClearMLHInstance()

DWORD WINAPI MLClearMLHInstance

(

DWORD

x

)

Definition at line 4048 of file ordinal.c.

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

MLFreeLibrary()

BOOL WINAPI MLFreeLibrary

(

HMODULE

hModule

)

Definition at line 4011 of file ordinal.c.

{
    FIXME("(%p) semi-stub\n", hModule);
    return FreeLibrary(hModule);
}

Referenced by MLBuildResURLW().

MLIsMLHInstance()

BOOL WINAPI MLIsMLHInstance

(

HINSTANCE

hInst

)

Definition at line 4029 of file ordinal.c.

{
       FIXME("(%p) stub\n", hInst);
       return FALSE;
}

MLLoadLibraryA()

HMODULE WINAPI MLLoadLibraryA	(	LPCSTR	new_mod,
		HMODULE	inst_hwnd,
		DWORD	dwCrossCodePage
	)

Definition at line 3712 of file ordinal.c.

{
  /* FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for
   *        each call here.
   * FIXME: Native shows calls to:
   *  SHRegGetUSValue for "Software\Microsoft\Internet Explorer\International"
   *                      CheckVersion
   *  RegOpenKeyExA for "HKLM\Software\Microsoft\Internet Explorer"
   *  RegQueryValueExA for "LPKInstalled"
   *  RegCloseKey
   *  RegOpenKeyExA for "HKCU\Software\Microsoft\Internet Explorer\International"
   *  RegQueryValueExA for "ResourceLocale"
   *  RegCloseKey
   *  RegOpenKeyExA for "HKLM\Software\Microsoft\Active Setup\Installed Components\{guid}"
   *  RegQueryValueExA for "Locale"
   *  RegCloseKey
   *  and then tests the Locale ("en" for me).
   *     code below
   *  after the code then a DPA_Create (first time) and DPA_InsertPtr are done.
   */
    CHAR mod_path[2*MAX_PATH];
    LPSTR ptr;
    DWORD len;
 
    FIXME("(%s,%p,%d) semi-stub!\n", debugstr_a(new_mod), inst_hwnd, dwCrossCodePage);
    len = GetModuleFileNameA(inst_hwnd, mod_path, sizeof(mod_path));
    if (!len || len >= sizeof(mod_path)) return NULL;
 
    ptr = strrchr(mod_path, '\\');
    if (ptr) {
    strcpy(ptr+1, new_mod);
    TRACE("loading %s\n", debugstr_a(mod_path));
    return LoadLibraryA(mod_path);
    }
    return NULL;
}

MLLoadLibraryW()

HMODULE WINAPI MLLoadLibraryW	(	LPCWSTR	new_mod,
		HMODULE	inst_hwnd,
		DWORD	dwCrossCodePage
	)

Definition at line 3754 of file ordinal.c.

{
    WCHAR mod_path[2*MAX_PATH];
    LPWSTR ptr;
    DWORD len;
 
    FIXME("(%s,%p,%d) semi-stub!\n", debugstr_w(new_mod), inst_hwnd, dwCrossCodePage);
    len = GetModuleFileNameW(inst_hwnd, mod_path, sizeof(mod_path) / sizeof(WCHAR));
    if (!len || len >= sizeof(mod_path) / sizeof(WCHAR)) return NULL;
 
    ptr = strrchrW(mod_path, '\\');
    if (ptr) {
    strcpyW(ptr+1, new_mod);
    TRACE("loading %s\n", debugstr_w(mod_path));
    return LoadLibraryW(mod_path);
    }
    return NULL;
}

Referenced by MLBuildResURLW().

MLSetMLHInstance()

DWORD WINAPI MLSetMLHInstance	(	HINSTANCE	hInst,
		HANDLE	hHeap
	)

Definition at line 4039 of file ordinal.c.

{
    FIXME("(%p,%p) stub\n", hInst, hHeap);
    return E_FAIL;   /* This is what is used if shlwapi not loaded */
}

PageSetupDlgWrapW()

BOOL WINAPI PageSetupDlgWrapW

(

LPPAGESETUPDLGW

pagedlg

)

Definition at line 3841 of file ordinal.c.

{
    return PageSetupDlgW(pagedlg);
}

PathSkipLeadingSlashesA()

LPCSTR WINAPI PathSkipLeadingSlashesA

(

LPCSTR

lpszSrc

)

Definition at line 1269 of file ordinal.c.

{
  if (lpszSrc && lpszSrc[0] == '/' && lpszSrc[1] == '/')
    lpszSrc += 2;
  return lpszSrc;
}

PlaySoundWrapW()

BOOL WINAPI PlaySoundWrapW	(	LPCWSTR	pszSound,
		HMODULE	hmod,
		DWORD	fdwSound
	)

Definition at line 3357 of file ordinal.c.

{
    return PlaySoundW(pszSound, hmod, fdwSound);
}

PrintDlgWrapW()

BOOL WINAPI PrintDlgWrapW

(

LPPRINTDLGW

printdlg

)

Definition at line 3851 of file ordinal.c.

{
    return PrintDlgW(printdlg);
}

QISearch()

HRESULT WINAPI QISearch	(	void *	base,
		const QITAB *	table,
		REFIID	riid,
		void **	ppv
	)

Definition at line 2396 of file ordinal.c.

{
    HRESULT ret;
    IUnknown *a_vtbl;
    const QITAB *xmove;
 
    TRACE("(%p %p %s %p)\n", base, table, debugstr_guid(riid), ppv);
    if (ppv) {
        xmove = table;
        while (xmove->piid) {
        TRACE("trying (offset %d) %s\n", xmove->dwOffset, debugstr_guid(xmove->piid));
        if (IsEqualIID(riid, xmove->piid)) {
            a_vtbl = (IUnknown*)(xmove->dwOffset + (LPBYTE)base);
            TRACE("matched, returning (%p)\n", a_vtbl);
                    *ppv = a_vtbl;
            IUnknown_AddRef(a_vtbl);
            return S_OK;
        }
        xmove++;
        }
 
        if (IsEqualIID(riid, &IID_IUnknown)) {
        a_vtbl = (IUnknown*)(table->dwOffset + (LPBYTE)base);
        TRACE("returning first for IUnknown (%p)\n", a_vtbl);
                *ppv = a_vtbl;
        IUnknown_AddRef(a_vtbl);
        return S_OK;
        }
        *ppv = 0;
        ret = E_NOINTERFACE;
    } else
        ret = E_POINTER;
 
    TRACE("-- 0x%08x\n", ret);
    return ret;
}

Referenced by ExplorerInstance::QueryInterface(), and CUnknownBase< Interface >::QueryInterface().

RegisterDefaultAcceptHeaders()

HRESULT WINAPI RegisterDefaultAcceptHeaders	(	LPBC	lpBC,
		IUnknown *	lpUnknown
	)

Definition at line 348 of file ordinal.c.

{
  static const WCHAR szProperty[] = { '{','D','0','F','C','A','4','2','0',
      '-','D','3','F','5','-','1','1','C','F', '-','B','2','1','1','-','0',
      '0','A','A','0','0','4','A','E','8','3','7','}','\0' };
  BSTR property;
  IEnumFORMATETC* pIEnumFormatEtc = NULL;
  VARIANTARG var;
  HRESULT hr;
  IWebBrowserApp* pBrowser;
 
  TRACE("(%p, %p)\n", lpBC, lpUnknown);
 
  hr = IUnknown_QueryService(lpUnknown, &IID_IWebBrowserApp, &IID_IWebBrowserApp, (void**)&pBrowser);
  if (FAILED(hr))
    return hr;
 
  V_VT(&var) = VT_EMPTY;
 
  /* The property we get is the browsers clipboard enumerator */
  property = SysAllocString(szProperty);
  hr = IWebBrowserApp_GetProperty(pBrowser, property, &var);
  SysFreeString(property);
  if (FAILED(hr)) goto exit;
 
  if (V_VT(&var) == VT_EMPTY)
  {
    /* Iterate through accepted documents and RegisterClipBoardFormatA() them */
    char szKeyBuff[128], szValueBuff[128];
    DWORD dwKeySize, dwValueSize, dwRet = 0, dwCount = 0, dwNumValues, dwType;
    FORMATETC* formatList, *format;
    HKEY hDocs;
 
    TRACE("Registering formats and creating IEnumFORMATETC instance\n");
 
    if (!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\Current"
                     "Version\\Internet Settings\\Accepted Documents", &hDocs))
    {
      hr = E_FAIL;
      goto exit;
    }
 
    /* Get count of values in key */
    while (!dwRet)
    {
      dwKeySize = sizeof(szKeyBuff);
      dwRet = RegEnumValueA(hDocs,dwCount,szKeyBuff,&dwKeySize,0,&dwType,0,0);
      dwCount++;
    }
 
    dwNumValues = dwCount;
 
    /* Note: dwCount = number of items + 1; The extra item is the end node */
    format = formatList = HeapAlloc(GetProcessHeap(), 0, dwCount * sizeof(FORMATETC));
    if (!formatList)
    {
      RegCloseKey(hDocs);
      hr = E_OUTOFMEMORY;
      goto exit;
    }
 
    if (dwNumValues > 1)
    {
      dwRet = 0;
      dwCount = 0;
 
      dwNumValues--;
 
      /* Register clipboard formats for the values and populate format list */
      while(!dwRet && dwCount < dwNumValues)
      {
        dwKeySize = sizeof(szKeyBuff);
        dwValueSize = sizeof(szValueBuff);
        dwRet = RegEnumValueA(hDocs, dwCount, szKeyBuff, &dwKeySize, 0, &dwType,
                              (PBYTE)szValueBuff, &dwValueSize);
        if (!dwRet)
        {
          HeapFree(GetProcessHeap(), 0, formatList);
          RegCloseKey(hDocs);
          hr = E_FAIL;
          goto exit;
        }
 
        format->cfFormat = RegisterClipboardFormatA(szValueBuff);
        format->ptd = NULL;
        format->dwAspect = 1;
        format->lindex = 4;
        format->tymed = -1;
 
        format++;
        dwCount++;
      }
    }
 
    RegCloseKey(hDocs);
 
    /* Terminate the (maybe empty) list, last entry has a cfFormat of 0 */
    format->cfFormat = 0;
    format->ptd = NULL;
    format->dwAspect = 1;
    format->lindex = 4;
    format->tymed = -1;
 
    /* Create a clipboard enumerator */
    hr = CreateFormatEnumerator(dwNumValues, formatList, &pIEnumFormatEtc);
    HeapFree(GetProcessHeap(), 0, formatList);
    if (FAILED(hr)) goto exit;
 
    /* Set our enumerator as the browsers property */
    V_VT(&var) = VT_UNKNOWN;
    V_UNKNOWN(&var) = (IUnknown*)pIEnumFormatEtc;
 
    property = SysAllocString(szProperty);
    hr = IWebBrowserApp_PutProperty(pBrowser, property, var);
    SysFreeString(property);
    if (FAILED(hr))
    {
       IEnumFORMATETC_Release(pIEnumFormatEtc);
       goto exit;
    }
  }
 
  if (V_VT(&var) == VT_UNKNOWN)
  {
    /* Our variant is holding the clipboard enumerator */
    IUnknown* pIUnknown = V_UNKNOWN(&var);
    IEnumFORMATETC* pClone = NULL;
 
    TRACE("Retrieved IEnumFORMATETC property\n");
 
    /* Get an IEnumFormatEtc interface from the variants value */
    pIEnumFormatEtc = NULL;
    hr = IUnknown_QueryInterface(pIUnknown, &IID_IEnumFORMATETC, (void**)&pIEnumFormatEtc);
    if (hr == S_OK && pIEnumFormatEtc)
    {
      /* Clone and register the enumerator */
      hr = IEnumFORMATETC_Clone(pIEnumFormatEtc, &pClone);
      if (hr == S_OK && pClone)
      {
        RegisterFormatEnumerator(lpBC, pClone, 0);
 
        IEnumFORMATETC_Release(pClone);
      }
 
      IUnknown_Release(pIUnknown);
    }
    IUnknown_Release(V_UNKNOWN(&var));
  }
 
exit:
  IWebBrowserApp_Release(pBrowser);
  return hr;
}

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

SHAllocShared()

HANDLE WINAPI SHAllocShared	(	LPCVOID	lpvData,
		DWORD	dwSize,
		DWORD	dwProcId
	)

Definition at line 169 of file ordinal.c.

{
  HANDLE hMap;
  LPVOID pMapped;
  HANDLE hRet = NULL;
 
  TRACE("(%p,%d,%d)\n", lpvData, dwSize, dwProcId);
 
  /* Create file mapping of the correct length */
  hMap = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, FILE_MAP_READ, 0,
                            dwSize + sizeof(dwSize), NULL);
  if (!hMap)
    return hRet;
 
  /* Get a view in our process address space */
  pMapped = MapViewOfFile(hMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
 
  if (pMapped)
  {
    /* Write size of data, followed by the data, to the view */
    *((DWORD*)pMapped) = dwSize;
    if (lpvData)
      memcpy((char *) pMapped + sizeof(dwSize), lpvData, dwSize);
 
    /* Release view. All further views mapped will be opaque */
    UnmapViewOfFile(pMapped);
    hRet = SHMapHandle(hMap, GetCurrentProcessId(), dwProcId,
                       FILE_MAP_ALL_ACCESS, DUPLICATE_SAME_ACCESS);
  }
 
  CloseHandle(hMap);
  return hRet;
}

Referenced by CreateNotificationParam(), CreateRegistrationParam(), init_pointers(), MakeSharedPacket(), and SHELL_ArgifyW().

SHBrowseForFolderWrapW()

LPITEMIDLIST WINAPI SHBrowseForFolderWrapW

(

LPBROWSEINFOW

lpBi

)

Definition at line 3462 of file ordinal.c.

{
    return SHBrowseForFolderW(lpBi);
}

SHChangeNotifyWrap()

void WINAPI SHChangeNotifyWrap	(	LONG	wEventId,
		UINT	uFlags,
		LPCVOID	dwItem1,
		LPCVOID	dwItem2
	)

Definition at line 5043 of file ordinal.c.

{
    SHChangeNotify(wEventId, uFlags, dwItem1, dwItem2);
}

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

SHCoCreateInstanceAC()

HRESULT WINAPI SHCoCreateInstanceAC	(	REFCLSID	rclsid,
		LPUNKNOWN	pUnkOuter,
		DWORD	dwClsContext,
		REFIID	iid,
		LPVOID *	ppv
	)

Definition at line 4575 of file ordinal.c.

{
    return CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, ppv);
}

SHCreatePropertyBagOnRegKey()

HRESULT WINAPI SHCreatePropertyBagOnRegKey	(	HKEY	hKey,
		LPCWSTR	subkey,
		DWORD	grfMode,
		REFIID	riid,
		void **	ppv
	)

Definition at line 5214 of file ordinal.c.

{
    FIXME("%p %s %d %s %p STUB\n", hKey, debugstr_w(subkey), grfMode,
          debugstr_guid(riid), ppv);
 
    return E_NOTIMPL;
}

Referenced by CDefaultContextMenu::InvokeRegVerb(), and SHPropertyBag_OnRegKey().

SHCreateShellPalette()

HPALETTE WINAPI SHCreateShellPalette

(

HDC

hdc

)

Definition at line 4432 of file ordinal.c.

{
    FIXME("stub\n");
    return CreateHalftonePalette(hdc);
}

SHCreateWorkerWindowA()

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

Definition at line 2679 of file ordinal.c.

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

Referenced by init_pointers(), and SHCreateWorkerWindowW().

SHCreateWorkerWindowW()

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

Definition at line 3004 of file ordinal.c.

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

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

SHDefExtractIconWrapW()

UINT WINAPI SHDefExtractIconWrapW	(	LPCWSTR	pszIconFile,
		int	iIndex,
		UINT	uFlags,
		HICON *	phiconLarge,
		HICON *	phiconSmall,
		UINT	nIconSize
	)

Definition at line 3604 of file ordinal.c.

{
    return SHDefExtractIconW(pszIconFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
}

SHDefWindowProc()

LRESULT CALLBACK SHDefWindowProc	(	HWND	hWnd,
		UINT	uMessage,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 2632 of file ordinal.c.

{
    if (IsWindowUnicode(hWnd))
        return DefWindowProcW(hWnd, uMessage, wParam, lParam);
    return DefWindowProcA(hWnd, uMessage, wParam, lParam);
}

ShellExecuteExWrapW()

BOOL WINAPI ShellExecuteExWrapW

(

LPSHELLEXECUTEINFOW

lpExecInfo

)

Definition at line 3482 of file ordinal.c.

{
    return ShellExecuteExW(lpExecInfo);
}

ShellMessageBoxWrapW()

INT WINAPIV ShellMessageBoxWrapW	(	HINSTANCE	hInstance,
		HWND	hWnd,
		LPCWSTR	lpText,
		LPCWSTR	lpCaption,
		UINT	uType,
			...
	)

Definition at line 4978 of file ordinal.c.

{
    WCHAR *szText = NULL, szTitle[100];
    LPCWSTR pszText, pszTitle = szTitle;
    LPWSTR pszTemp;
    __ms_va_list args;
    int ret;
 
    __ms_va_start(args, uType);
 
    TRACE("(%p,%p,%p,%p,%08x)\n", hInstance, hWnd, lpText, lpCaption, uType);
 
    if (IS_INTRESOURCE(lpCaption))
        LoadStringW(hInstance, LOWORD(lpCaption), szTitle, ARRAY_SIZE(szTitle));
    else
        pszTitle = lpCaption;
 
    if (IS_INTRESOURCE(lpText))
    {
        const WCHAR *ptr;
        UINT len = LoadStringW(hInstance, LOWORD(lpText), (LPWSTR)&ptr, 0);
 
        if (len)
        {
            szText = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
            if (szText) LoadStringW(hInstance, LOWORD(lpText), szText, len + 1);
        }
        pszText = szText;
        if (!pszText) {
            WARN("Failed to load id %d\n", LOWORD(lpText));
            __ms_va_end(args);
            return 0;
        }
    }
    else
        pszText = lpText;
 
    FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
                   pszText, 0, 0, (LPWSTR)&pszTemp, 0, &args);
 
    __ms_va_end(args);
 
#ifdef __REACTOS__
    uType |= MB_SETFOREGROUND;
#endif
    ret = MessageBoxW(hWnd, pszTemp, pszTitle, uType);
 
    HeapFree(GetProcessHeap(), 0, szText);
    LocalFree(pszTemp);
    return ret;
}

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

SHFileOperationWrapW()

INT WINAPI SHFileOperationWrapW

(

LPSHFILEOPSTRUCTW

lpFileOp

)

Definition at line 3492 of file ordinal.c.

{
    return SHFileOperationW(lpFileOp);
}

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

SHFlushSFCacheWrap()

BOOL WINAPI SHFlushSFCacheWrap

(

void

)

Definition at line 4020 of file ordinal.c.

                                     {
  FIXME(": stub\n");
  return TRUE;
}

SHFormatDateTimeA()

INT WINAPI SHFormatDateTimeA	(	const FILETIME UNALIGNED *	fileTime,
		DWORD *	flags,
		LPSTR	buf,
		UINT	size
	)

Definition at line 5334 of file ordinal.c.

{
    WCHAR *bufW;
    INT retval;
 
    if (!buf || !size)
        return 0;
 
    bufW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * size);
    retval = SHFormatDateTimeW(fileTime, flags, bufW, size);
 
    if (retval != 0)
        WideCharToMultiByte(CP_ACP, 0, bufW, -1, buf, size, NULL, NULL);
 
    HeapFree(GetProcessHeap(), 0, bufW);
    return retval;
}

Referenced by CCabFolder::GetItemDetails(), and init_pointers().

SHFormatDateTimeW()

INT WINAPI SHFormatDateTimeW	(	const FILETIME UNALIGNED *	fileTime,
		DWORD *	flags,
		LPWSTR	buf,
		UINT	size
	)

Definition at line 5269 of file ordinal.c.

{
#define SHFORMATDT_UNSUPPORTED_FLAGS (FDTF_RELATIVE | FDTF_LTRDATE | FDTF_RTLDATE | FDTF_NOAUTOREADINGORDER)
    DWORD fmt_flags = flags ? *flags : FDTF_DEFAULT;
    SYSTEMTIME st;
    FILETIME ft;
    INT ret = 0;
 
    TRACE("%p %p %p %u\n", fileTime, flags, buf, size);
 
    if (!buf || !size)
        return 0;
 
    if (fmt_flags & SHFORMATDT_UNSUPPORTED_FLAGS)
        FIXME("ignoring some flags - 0x%08x\n", fmt_flags & SHFORMATDT_UNSUPPORTED_FLAGS);
 
    FileTimeToLocalFileTime(fileTime, &ft);
    FileTimeToSystemTime(&ft, &st);
 
    /* first of all date */
    if (fmt_flags & (FDTF_LONGDATE | FDTF_SHORTDATE))
    {
        static const WCHAR sep1[] = {',',' ',0};
        static const WCHAR sep2[] = {' ',0};
 
        DWORD date = fmt_flags & FDTF_LONGDATE ? DATE_LONGDATE : DATE_SHORTDATE;
        ret = GetDateFormatW(LOCALE_USER_DEFAULT, date, &st, NULL, buf, size);
        if (ret >= size) return ret;
 
        /* add separator */
        if (ret < size && (fmt_flags & (FDTF_LONGTIME | FDTF_SHORTTIME)))
        {
            if ((fmt_flags & FDTF_LONGDATE) && (ret < size + 2))
            {
                lstrcatW(&buf[ret-1], sep1);
                ret += 2;
            }
            else
            {
                lstrcatW(&buf[ret-1], sep2);
                ret++;
            }
        }
    }
    /* time part */
    if (fmt_flags & (FDTF_LONGTIME | FDTF_SHORTTIME))
    {
        DWORD time = fmt_flags & FDTF_LONGTIME ? 0 : TIME_NOSECONDS;
 
        if (ret) ret--;
        ret += GetTimeFormatW(LOCALE_USER_DEFAULT, time, &st, NULL, &buf[ret], size - ret);
    }
 
    return ret;
 
#undef SHFORMATDT_UNSUPPORTED_FLAGS
}

Referenced by init_pointers(), and SHFormatDateTimeA().

SHFreeShared()

BOOL WINAPI SHFreeShared	(	HANDLE	hShared,
		DWORD	dwProcId
	)

Definition at line 315 of file ordinal.c.

{
  HANDLE hClose;
 
  TRACE("(%p %d)\n", hShared, dwProcId);
 
  if (!hShared)
    return TRUE;
 
  /* Get a copy of the handle for our process, closing the source handle */
  hClose = SHMapHandle(hShared, dwProcId, GetCurrentProcessId(),
                       FILE_MAP_ALL_ACCESS,DUPLICATE_CLOSE_SOURCE);
  /* Close local copy */
  return CloseHandle(hClose);
}

Referenced by _ILReadFromSharedMemory(), CreateNotificationParam(), CreateRegistrationParam(), init_pointers(), MakeSharedPacket(), CChangeNotifyServer::OnDeliverNotification(), ParseSharedPacket(), and SHChangeNotifyRegister().

SHGetAppCompatFlags()

DWORD WINAPI SHGetAppCompatFlags

(

DWORD

dwUnknown

)

Definition at line 4565 of file ordinal.c.

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

Referenced by ShellExecuteA(), and ShellExecuteW().

SHGetCurColorRes()

DWORD WINAPI SHGetCurColorRes

(

void

)

Definition at line 2023 of file ordinal.c.

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

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

SHGetFileInfoWrapW()

DWORD WINAPI SHGetFileInfoWrapW	(	LPCWSTR	path,
		DWORD	dwFileAttributes,
		SHFILEINFOW *	psfi,
		UINT	sizeofpsfi,
		UINT	flags
	)

Definition at line 3441 of file ordinal.c.

{
    return SHGetFileInfoW(path, dwFileAttributes, psfi, sizeofpsfi, flags);
}

SHGetIniStringW()

DWORD WINAPI SHGetIniStringW	(	LPCWSTR	appName,
		LPCWSTR	keyName,
		LPWSTR	out,
		DWORD	outLen,
		LPCWSTR	filename
	)

Definition at line 3379 of file ordinal.c.

{
    INT ret;
    WCHAR *buf;
 
    TRACE("(%s,%s,%p,%08x,%s)\n", debugstr_w(appName), debugstr_w(keyName),
        out, outLen, debugstr_w(filename));
 
    if(outLen == 0)
        return 0;
 
    buf = HeapAlloc(GetProcessHeap(), 0, outLen * sizeof(WCHAR));
    if(!buf){
        *out = 0;
        return 0;
    }
 
    ret = GetPrivateProfileStringW(appName, keyName, NULL, buf, outLen, filename);
    if(ret)
        strcpyW(out, buf);
    else
        *out = 0;
 
    HeapFree(GetProcessHeap(), 0, buf);
 
    return strlenW(out);
}

Referenced by init_pointers(), and SHPropertyBag_SHSetIniStringW().

SHGetInverseCMAP()

HRESULT WINAPI SHGetInverseCMAP	(	LPDWORD	dest,
		DWORD	dwSize
	)

Definition at line 4460 of file ordinal.c.

{
    if (dwSize == 4) {
    FIXME(" - returning bogus address for SHGetInverseCMAP\n");
    *dest = (DWORD)0xabba1249;
    return 0;
    }
    FIXME("(%p, %#x) stub\n", dest, dwSize);
    return 0;
}

SHGetMachineInfo()

DWORD WINAPI SHGetMachineInfo

(

DWORD

dwFlags

)

Definition at line 3958 of file ordinal.c.

{
  HW_PROFILE_INFOA hwInfo;
 
  TRACE("(0x%08x)\n", dwFlags);
 
  GetCurrentHwProfileA(&hwInfo);
  switch (hwInfo.dwDockInfo & (DOCKINFO_DOCKED|DOCKINFO_UNDOCKED))
  {
  case DOCKINFO_DOCKED:
  case DOCKINFO_UNDOCKED:
    return hwInfo.dwDockInfo & (DOCKINFO_DOCKED|DOCKINFO_UNDOCKED);
  default:
    return 0;
  }
}

SHGetMenuFromID()

HMENU WINAPI SHGetMenuFromID	(	HMENU	hMenu,
		UINT	uID
	)

Definition at line 1997 of file ordinal.c.

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

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

SHGetNewLinkInfoWrapW()

BOOL WINAPI SHGetNewLinkInfoWrapW	(	LPCWSTR	pszLinkTo,
		LPCWSTR	pszDir,
		LPWSTR	pszName,
		BOOL *	pfMustCopy,
		UINT	uFlags
	)

Definition at line 3593 of file ordinal.c.

{
    return SHGetNewLinkInfoW(pszLinkTo, pszDir, pszName, pfMustCopy, uFlags);
}

SHGetObjectCompatFlags()

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

Definition at line 6315 of file ordinal.c.

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

Referenced by init_pointers(), and SHGetAttributes().

SHGetPathFromIDListWrapW()

BOOL WINAPI SHGetPathFromIDListWrapW	(	LPCITEMIDLIST	pidl,
		LPWSTR	pszPath
	)

Definition at line 3472 of file ordinal.c.

{
    return SHGetPathFromIDListW(pidl, pszPath);
}

Referenced by _ILIsNetworkPlace().

SHGetRestriction()

DWORD WINAPI SHGetRestriction	(	LPCWSTR	lpSubKey,
		LPCWSTR	lpSubName,
		LPCWSTR	lpValue
	)

Definition at line 2744 of file ordinal.c.

{
#ifdef __REACTOS__
    WCHAR szPath[MAX_PATH];
    DWORD dwSize, dwValue = 0;
 
    TRACE("(%s, %s, %s)\n", debugstr_w(lpSubKey), debugstr_w(lpSubName), debugstr_w(lpValue));
 
    if (!lpSubKey)
        lpSubKey = L"Software\\Microsoft\\Windows\\CurrentVersion\\Policies";
 
    PathCombineW(szPath, lpSubKey, lpSubName);
 
    dwSize = sizeof(dwValue);
    if (SHGetValueW(HKEY_LOCAL_MACHINE, szPath, lpValue, NULL, &dwValue, &dwSize) == ERROR_SUCCESS)
        return dwValue;
 
    dwSize = sizeof(dwValue);
    SHGetValueW(HKEY_CURRENT_USER, szPath, lpValue, NULL, &dwValue, &dwSize);
    return dwValue;
#else
    DWORD retval, datsize = sizeof(retval);
    HKEY hKey;
 
    if (!lpSubKey)
      lpSubKey = strRegistryPolicyW;
 
    retval = RegOpenKeyW(HKEY_LOCAL_MACHINE, lpSubKey, &hKey);
        if (retval != ERROR_SUCCESS)
      retval = RegOpenKeyW(HKEY_CURRENT_USER, lpSubKey, &hKey);
    if (retval != ERROR_SUCCESS)
      return 0;
 
        SHGetValueW(hKey, lpSubName, lpValue, NULL, &retval, &datsize);
    RegCloseKey(hKey);
    return retval;
#endif
}

Referenced by CShellDispatch::IsRestricted(), and SHRestrictionLookup().

SHGetShellKey()

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

Definition at line 4622 of file ordinal.c.

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

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

SHGetViewStatePropertyBag()

HRESULT WINAPI SHGetViewStatePropertyBag	(	LPCITEMIDLIST	pidl,
		LPWSTR	bag_name,
		DWORD	flags,
		REFIID	riid,
		void **	ppv
	)

Definition at line 5243 of file ordinal.c.

{
    FIXME("%p %s %d %s %p STUB\n", pidl, debugstr_w(bag_name), flags,
          debugstr_guid(riid), ppv);
 
    return E_NOTIMPL;
}

Referenced by CDesktopBrowser::GetPropertyBag(), and CShellBrowser::GetPropertyBag().

SHInterlockedCompareExchange()

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

Definition at line 3501 of file ordinal.c.

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

SHInvokeCommand()

HRESULT WINAPI SHInvokeCommand	(	HWND	hWnd,
		IShellFolder *	lpFolder,
		LPCITEMIDLIST	lpApidl,
		DWORD	dwCommandId
	)

Definition at line 3633 of file ordinal.c.

{
  IContextMenu *iContext;
  HRESULT hRet;
 
  TRACE("(%p, %p, %p, %u)\n", hWnd, lpFolder, lpApidl, dwCommandId);
 
  if (!lpFolder)
    return E_FAIL;
 
  /* Get the context menu from the shell folder */
  hRet = IShellFolder_GetUIObjectOf(lpFolder, hWnd, 1, &lpApidl,
                                    &IID_IContextMenu, 0, (void**)&iContext);
  if (SUCCEEDED(hRet))
  {
    HMENU hMenu;
    if ((hMenu = CreatePopupMenu()))
    {
      HRESULT hQuery;
 
      /* Add the context menu entries to the popup */
      hQuery = IContextMenu_QueryContextMenu(iContext, hMenu, 0, 1, 0x7FFF,
                                             dwCommandId ? CMF_NORMAL : CMF_DEFAULTONLY);
 
      if (SUCCEEDED(hQuery))
      {
        if (!dwCommandId)
          dwCommandId = GetMenuDefaultItem(hMenu, 0, 0);
        if (dwCommandId != (UINT)-1)
        {
          CMINVOKECOMMANDINFO cmIci;
          /* Invoke the default item */
          memset(&cmIci,0,sizeof(cmIci));
          cmIci.cbSize = sizeof(cmIci);
          cmIci.fMask = CMIC_MASK_ASYNCOK;
          cmIci.hwnd = hWnd;
#ifdef __REACTOS__ /* r75561 */
          cmIci.lpVerb = MAKEINTRESOURCEA(dwCommandId - 1);
#else
          cmIci.lpVerb = MAKEINTRESOURCEA(dwCommandId);
#endif
          cmIci.nShow = SW_SHOWNORMAL;
 
          hRet = IContextMenu_InvokeCommand(iContext, &cmIci);
        }
      }
      DestroyMenu(hMenu);
    }
    IContextMenu_Release(iContext);
  }
  return hRet;
}

Referenced by SHInvokeDefaultCommand().

SHInvokeDefaultCommand()

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

Definition at line 3060 of file ordinal.c.

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

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

SHIsChildOrSelf()

BOOL WINAPI SHIsChildOrSelf	(	HWND	hParent,
		HWND	hChild
	)

Definition at line 2254 of file ordinal.c.

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

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;
}

SHIShellFolder_EnumObjects()

HRESULT WINAPI SHIShellFolder_EnumObjects	(	LPSHELLFOLDER	lpFolder,
		HWND	hwnd,
		SHCONTF	flags,
		IEnumIDList **	ppenum
	)

Definition at line 3869 of file ordinal.c.

{
    /* Windows attempts to get an IPersist interface and, if that fails, an
     * IPersistFolder interface on the folder passed-in here.  If one of those
     * interfaces is available, it then calls GetClassID on the folder... and
     * then calls IShellFolder_EnumObjects no matter what, even crashing if
     * lpFolder isn't actually an IShellFolder object.  The purpose of getting
     * the ClassID is unknown, so we don't do it here.
     *
     * For discussion and detailed tests, see:
     * "shlwapi: Be less strict on which type of IShellFolder can be enumerated"
     * wine-devel mailing list, 3 Jun 2010
     */
 
    return IShellFolder_EnumObjects(lpFolder, hwnd, flags, ppenum);
}

Referenced by init_pointers().

SHIsLowMemoryMachine()

BOOL WINAPI SHIsLowMemoryMachine

(

DWORD

dwType

)

Definition at line 4483 of file ordinal.c.

{
#ifdef __REACTOS__
    MEMORYSTATUS status;
    static int is_low = -1;
    TRACE("(0x%08x)\n", dwType);
    if (dwType == 0 && is_low == -1)
    {
        GlobalMemoryStatus(&status);
        is_low = (status.dwTotalPhys <= 0x1000000);
    }
    return is_low;
#else
  FIXME("(0x%08x) stub\n", dwType);
  return FALSE;
#endif
}

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;
}

SHLoadFromPropertyBag()

DWORD WINAPI SHLoadFromPropertyBag	(	IUnknown *	lpUnknown,
		IPropertyBag *	lpPropBag
	)

Definition at line 1864 of file ordinal.c.

{
  IPersistPropertyBag* lpPPBag;
  HRESULT hRet = E_FAIL;
 
  TRACE("(%p,%p)\n", lpUnknown, lpPropBag);
 
  if (lpUnknown)
  {
    hRet = IUnknown_QueryInterface(lpUnknown, &IID_IPersistPropertyBag,
                                   (void**)&lpPPBag);
    if (SUCCEEDED(hRet) && lpPPBag)
    {
      hRet = IPersistPropertyBag_Load(lpPPBag, lpPropBag, NULL);
      IPersistPropertyBag_Release(lpPPBag);
    }
  }
  return hRet;
}

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;
}

SHLoadRegUIStringW()

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

Definition at line 4277 of file ordinal.c.

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

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

SHLockShared()

PVOID WINAPI SHLockShared	(	HANDLE	hShared,
		DWORD	dwProcId
	)

Definition at line 259 of file ordinal.c.

{
#ifdef __REACTOS__
    return SHLockSharedEx(hShared, dwProcId, TRUE);
#else
  HANDLE hDup;
  LPVOID pMapped;
 
  TRACE("(%p %d)\n", hShared, dwProcId);
 
  /* Get handle to shared memory for current process */
  hDup = SHMapHandle(hShared, dwProcId, GetCurrentProcessId(), FILE_MAP_ALL_ACCESS, 0);
 
  /* Get View */
  pMapped = MapViewOfFile(hDup, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
  CloseHandle(hDup);
 
  if (pMapped)
    return (char *) pMapped + sizeof(DWORD); /* Hide size */
  return NULL;
#endif
}

Referenced by _ILReadFromSharedMemory(), init_pointers(), MakeSharedPacket(), ParseSharedPacket(), and SHELL_ArgifyW().

SHLWAPI_EnumChildProc()

static BOOL CALLBACK SHLWAPI_EnumChildProc ( HWND  hWnd, LPARAM  lParam  )

static

Definition at line 1692 of file ordinal.c.

{
  enumWndData *data = (enumWndData *)lParam;
 
  TRACE("(%p,%p)\n", hWnd, data);
  data->pfnPost(hWnd, data->uiMsgId, data->wParam, data->lParam);
  return TRUE;
}

Referenced by SHPropagateMessage().

SHLWAPI_InvokeByIID()

static HRESULT SHLWAPI_InvokeByIID ( IConnectionPoint *  iCP, REFIID  iid, DISPID  dispId, DISPPARAMS *  dispParams  )

static

Definition at line 3145 of file ordinal.c.

{
  IEnumConnections *enumerator;
  CONNECTDATA rgcd;
  static DISPPARAMS empty = {NULL, NULL, 0, 0};
  DISPPARAMS* params = dispParams;
 
  HRESULT result = IConnectionPoint_EnumConnections(iCP, &enumerator);
  if (FAILED(result))
    return result;
 
  /* Invoke is never happening with an NULL dispParams */
  if (!params)
    params = ∅
 
  while(IEnumConnections_Next(enumerator, 1, &rgcd, NULL)==S_OK)
  {
    IDispatch *dispIface;
    if ((iid && SUCCEEDED(IUnknown_QueryInterface(rgcd.pUnk, iid, (LPVOID*)&dispIface))) ||
        SUCCEEDED(IUnknown_QueryInterface(rgcd.pUnk, &IID_IDispatch, (LPVOID*)&dispIface)))
    {
      IDispatch_Invoke(dispIface, dispId, &IID_NULL, 0, DISPATCH_METHOD, params, NULL, NULL, NULL);
      IDispatch_Release(dispIface);
    }
    IUnknown_Release(rgcd.pUnk);
  }
 
  IEnumConnections_Release(enumerator);
 
  return S_OK;
}

Referenced by IConnectionPoint_InvokeWithCancel(), IConnectionPoint_SimpleInvoke(), and IUnknown_CPContainerInvokeParam().

SHMapHandle()

HANDLE WINAPI SHMapHandle	(	HANDLE	hShared,
		DWORD	dwSrcProcId,
		DWORD	dwDstProcId,
		DWORD	dwAccess,
		DWORD	dwOptions
	)

Definition at line 98 of file ordinal.c.

{
  HANDLE hDst, hSrc;
  DWORD dwMyProcId = GetCurrentProcessId();
  HANDLE hRet = NULL;
 
  TRACE("(%p,%d,%d,%08x,%08x)\n", hShared, dwDstProcId, dwSrcProcId,
        dwAccess, dwOptions);
 
  if (!hShared)
  {
    TRACE("Returning handle NULL\n");
    return NULL;
  }
 
  /* Get dest process handle */
  if (dwDstProcId == dwMyProcId)
    hDst = GetCurrentProcess();
  else
    hDst = OpenProcess(PROCESS_DUP_HANDLE, 0, dwDstProcId);
 
  if (hDst)
  {
    /* Get src process handle */
    if (dwSrcProcId == dwMyProcId)
      hSrc = GetCurrentProcess();
    else
      hSrc = OpenProcess(PROCESS_DUP_HANDLE, 0, dwSrcProcId);
 
    if (hSrc)
    {
      /* Make handle available to dest process */
      if (!DuplicateHandle(hSrc, hShared, hDst, &hRet,
                           dwAccess, 0, dwOptions | DUPLICATE_SAME_ACCESS))
        hRet = NULL;
 
      if (dwSrcProcId != dwMyProcId)
        CloseHandle(hSrc);
    }
 
    if (dwDstProcId != dwMyProcId)
      CloseHandle(hDst);
  }
 
  TRACE("Returning handle %p\n", hRet);
  return hRet;
}

Referenced by init_pointers(), SHAllocShared(), SHFreeShared(), and SHLockShared().

SHMenuIndexFromID()

DWORD WINAPI SHMenuIndexFromID	(	HMENU	hMenu,
		UINT	uID
	)

Definition at line 4541 of file ordinal.c.

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

Referenced by CDefView::FillViewMenu().

SHPackDispParams()

HRESULT WINAPIV SHPackDispParams	(	DISPPARAMS *	params,
		VARIANTARG *	args,
		UINT	cnt,
			...
	)

Definition at line 3127 of file ordinal.c.

{
  __ms_va_list valist;
  HRESULT hres;
 
  __ms_va_start(valist, cnt);
  hres = SHPackDispParamsV(params, args, cnt, valist);
  __ms_va_end(valist);
  return hres;
}

Referenced by init_pointers().

SHPackDispParamsV()

HRESULT WINAPI SHPackDispParamsV	(	DISPPARAMS *	params,
		VARIANTARG *	args,
		UINT	cnt,
		__ms_va_list	valist
	)

Definition at line 3075 of file ordinal.c.

{
  VARIANTARG *iter;
 
  TRACE("(%p %p %u ...)\n", params, args, cnt);
 
  params->rgvarg = args;
  params->rgdispidNamedArgs = NULL;
  params->cArgs = cnt;
  params->cNamedArgs = 0;
 
  iter = args+cnt;
 
  while(iter-- > args) {
    V_VT(iter) = va_arg(valist, enum VARENUM);
 
    TRACE("vt=%d\n", V_VT(iter));
 
    if(V_VT(iter) & VT_BYREF) {
      V_BYREF(iter) = va_arg(valist, LPVOID);
    } else {
      switch(V_VT(iter)) {
      case VT_I4:
        V_I4(iter) = va_arg(valist, LONG);
        break;
      case VT_BSTR:
        V_BSTR(iter) = va_arg(valist, BSTR);
        break;
      case VT_DISPATCH:
        V_DISPATCH(iter) = va_arg(valist, IDispatch*);
        break;
      case VT_BOOL:
        V_BOOL(iter) = va_arg(valist, int);
        break;
      case VT_UNKNOWN:
        V_UNKNOWN(iter) = va_arg(valist, IUnknown*);
        break;
      default:
        V_VT(iter) = VT_I4;
        V_I4(iter) = va_arg(valist, LONG);
      }
    }
  }
 
  return S_OK;
}

Referenced by IUnknown_CPContainerInvokeParam(), and SHPackDispParams().

SHPinDllOfCLSID()

HMODULE WINAPI SHPinDllOfCLSID

(

REFIID

refiid

)

Definition at line 2537 of file ordinal.c.

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

Referenced by SHAutoComplete().

SHPropagateMessage()

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

Definition at line 1719 of file ordinal.c.

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

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

SHPropertyBag_ReadLONG()

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

Definition at line 5622 of file ordinal.c.

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

Referenced by init_pointers(), and SHPropertyBag_ReadTest().

SHQueueUserWorkItem()

BOOL WINAPI SHQueueUserWorkItem	(	LPTHREAD_START_ROUTINE	pfnCallback,
		LPVOID	pContext,
		LONG	lPriority,
		DWORD_PTR	dwTag,
		DWORD_PTR *	pdwId,
		LPCSTR	pszModule,
		DWORD	dwFlags
	)

Definition at line 4762 of file ordinal.c.

{
    TRACE("(%p, %p, %d, %lx, %p, %s, %08x)\n", pfnCallback, pContext,
          lPriority, dwTag, pdwId, debugstr_a(pszModule), dwFlags);
 
    if(lPriority || dwTag || pdwId || pszModule || dwFlags)
        FIXME("Unsupported arguments\n");
 
    return QueueUserWorkItem(pfnCallback, pContext, 0);
}

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

SHRegisterClassW()

DWORD WINAPI SHRegisterClassW

(

WNDCLASSW *

lpWndClass

)

Definition at line 2559 of file ordinal.c.

{
    WNDCLASSW WndClass;
 
    TRACE("(%p %s)\n",lpWndClass->hInstance, debugstr_w(lpWndClass->lpszClassName));
 
    if (GetClassInfoW(lpWndClass->hInstance, lpWndClass->lpszClassName, &WndClass))
        return TRUE;
    return RegisterClassW(lpWndClass);
}

Referenced by SHCreateWorkerWindowW().

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;
}

SHRemoveDefaultDialogFont()

HANDLE WINAPI SHRemoveDefaultDialogFont

(

HWND

hWnd

)

Definition at line 2509 of file ordinal.c.

{
  HANDLE hProp;
 
  TRACE("(%p)\n", hWnd);
 
  hProp = GetPropA(hWnd, "PropDlgFont");
 
  if(hProp)
  {
    DeleteObject(hProp);
    hProp = RemovePropA(hWnd, "PropDlgFont");
  }
  return hProp;
}

SHRestrictionLookup()

DWORD WINAPI SHRestrictionLookup	(	DWORD	policy,
		LPCWSTR	initial,
		LPPOLICYDATA	polTable,
		LPDWORD	polArr
	)

Definition at line 2811 of file ordinal.c.

{
    TRACE("(0x%08x %s %p %p)\n", policy, debugstr_w(initial), polTable, polArr);
 
#ifndef __REACTOS__
    if (!polTable || !polArr)
      return 0;
#endif
 
#ifndef __REACTOS__
    for (;polTable->appstr; polTable++, polArr++)
#else
    for (;polTable->policy; polTable++, polArr++)
#endif
    {
      if (policy == polTable->policy)
      {
        /* we have a known policy */
 
        /* check if this policy has been cached */
            if (*polArr == SHELL_NO_POLICY)
          *polArr = SHGetRestriction(initial, polTable->appstr, polTable->keystr);
        return *polArr;
      }
    }
    /* we don't know this policy, return 0 */
    TRACE("unknown policy: (%08x)\n", policy);
    return 0;
}

Referenced by SHRestricted().

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

SHSendMessageBroadcastA()

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

Definition at line 4060 of file ordinal.c.

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

SHSendMessageBroadcastW()

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

Definition at line 4072 of file ordinal.c.

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

Referenced by SHGetSetSettings().

SHSetDefaultDialogFont()

HRESULT WINAPI SHSetDefaultDialogFont	(	HWND	hWnd,
		INT	id
	)

Definition at line 2457 of file ordinal.c.

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

SHSetIniStringW()

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

Definition at line 3426 of file ordinal.c.

{
    TRACE("(%s, %p, %s, %s)\n", debugstr_w(appName), keyName, debugstr_w(str),
            debugstr_w(filename));
 
    return WritePrivateProfileStringW(appName, keyName, str, filename);
}

Referenced by init_pointers(), and SHPropertyBag_SHSetIniStringW().

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 activate_inplace(), init_pointers(), and OleObject_SetClientSite().

SHSetTimerQueueTimer()

HANDLE WINAPI SHSetTimerQueueTimer	(	HANDLE	hQueue,
		WAITORTIMERCALLBACK	pfnCallback,
		LPVOID	pContext,
		DWORD	dwDueTime,
		DWORD	dwPeriod,
		LPCSTR	lpszLibrary,
		DWORD	dwFlags
	)

Definition at line 4778 of file ordinal.c.

{
    HANDLE hNewTimer;
 
    /* SHSetTimerQueueTimer flags -> CreateTimerQueueTimer flags */
    if (dwFlags & TPS_LONGEXECTIME) {
        dwFlags &= ~TPS_LONGEXECTIME;
        dwFlags |= WT_EXECUTELONGFUNCTION;
    }
    if (dwFlags & TPS_EXECUTEIO) {
        dwFlags &= ~TPS_EXECUTEIO;
        dwFlags |= WT_EXECUTEINIOTHREAD;
    }
 
    if (!CreateTimerQueueTimer(&hNewTimer, hQueue, pfnCallback, pContext,
                               dwDueTime, dwPeriod, dwFlags))
        return NULL;
 
    return hNewTimer;
}

SHSetWindowBits()

LONG WINAPI SHSetWindowBits	(	HWND	hwnd,
		INT	offset,
		UINT	mask,
		UINT	flags
	)

Definition at line 1130 of file ordinal.c.

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

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

SHSimulateDrop()

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

Definition at line 1828 of file ordinal.c.

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

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

SHSkipJunction()

BOOL WINAPI SHSkipJunction	(	IBindCtx *	pbc,
		const CLSID *	pclsid
	)

Definition at line 4595 of file ordinal.c.

{
  static WCHAR szSkipBinding[] = { 'S','k','i','p',' ',
    'B','i','n','d','i','n','g',' ','C','L','S','I','D','\0' };
  BOOL bRet = FALSE;
 
  if (pbc)
  {
    IUnknown* lpUnk;
 
    if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, szSkipBinding, &lpUnk)))
    {
      CLSID clsid;
 
      if (SUCCEEDED(IUnknown_GetClassID(lpUnk, &clsid)) &&
          IsEqualGUID(pclsid, &clsid))
        bRet = TRUE;
 
      IUnknown_Release(lpUnk);
    }
  }
  return bRet;
}

Referenced by SHSkipJunctionBinding().

SHStringFromGUIDA()

INT WINAPI SHStringFromGUIDA	(	REFGUID	guid,
		LPSTR	lpszDest,
		INT	cchMax
	)

Definition at line 628 of file ordinal.c.

{
  char xguid[40];
  INT iLen;
 
  TRACE("(%s,%p,%d)\n", debugstr_guid(guid), lpszDest, cchMax);
 
  sprintf(xguid, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
          (UINT)guid->Data1, guid->Data2, guid->Data3,
          guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
          guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 
  iLen = strlen(xguid) + 1;
 
  if (iLen > cchMax)
    return 0;
  memcpy(lpszDest, xguid, iLen);
  return iLen;
}

Referenced by SHGlobalCounterCreate(), SHPinDllOfCLSID(), and test_ordinal_imports().

SHStringFromGUIDW()

INT WINAPI SHStringFromGUIDW	(	REFGUID	guid,
		LPWSTR	lpszDest,
		INT	cchMax
	)

Definition at line 661 of file ordinal.c.

{
  WCHAR xguid[40];
  INT iLen;
  static const WCHAR wszFormat[] = {'{','%','0','8','l','X','-','%','0','4','X','-','%','0','4','X','-',
      '%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2',
      'X','%','0','2','X','%','0','2','X','}',0};
 
  TRACE("(%s,%p,%d)\n", debugstr_guid(guid), lpszDest, cchMax);
 
  sprintfW(xguid, wszFormat, guid->Data1, guid->Data2, guid->Data3,
          guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
          guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 
  iLen = strlenW(xguid) + 1;
 
  if (iLen > cchMax)
    return 0;
  memcpy(lpszDest, xguid, iLen*sizeof(WCHAR));
  return iLen;
}

Referenced by SHCoCreateInstance(), and SHRegGetCLSIDKeyW().

SHUnlockShared()

BOOL WINAPI SHUnlockShared

(

LPVOID

lpView

)

Definition at line 295 of file ordinal.c.

{
  TRACE("(%p)\n", lpView);
  return UnmapViewOfFile((char *) lpView - sizeof(DWORD)); /* Include size */
}

Referenced by _ILReadFromSharedMemory(), CreateNotificationParam(), CreateRegistrationParam(), CChangeNotifyServer::DeliverNotification(), DoGetHandbagFromTicket(), init_pointers(), MakeSharedPacket(), CChangeNotifyServer::OnRegister(), ParseSharedPacket(), SHChangeNotification_Unlock(), SHChangeNotifyRegister(), and SHELL_ArgifyW().

SHUnregisterClassesA()

void WINAPI SHUnregisterClassesA	(	HINSTANCE	hInst,
		LPCSTR *	lppClasses,
		INT	iCount
	)

Definition at line 2583 of file ordinal.c.

{
  WNDCLASSA WndClass;
 
  TRACE("(%p,%p,%d)\n", hInst, lppClasses, iCount);
 
  while (iCount > 0)
  {
    if (GetClassInfoA(hInst, *lppClasses, &WndClass))
      UnregisterClassA(*lppClasses, hInst);
    lppClasses++;
    iCount--;
  }
}

SHUnregisterClassesW()

void WINAPI SHUnregisterClassesW	(	HINSTANCE	hInst,
		LPCWSTR *	lppClasses,
		INT	iCount
	)

Definition at line 2603 of file ordinal.c.

{
  WNDCLASSW WndClass;
 
  TRACE("(%p,%p,%d)\n", hInst, lppClasses, iCount);
 
  while (iCount > 0)
  {
    if (GetClassInfoW(hInst, *lppClasses, &WndClass))
      UnregisterClassW(*lppClasses, hInst);
    lppClasses++;
    iCount--;
  }
}

SHVerbExistsNA()

INT WINAPI SHVerbExistsNA	(	LPSTR	verb,
		PVOID	pUnknown,
		PVOID	pUnknown2,
		DWORD	dwUnknown3
	)

Definition at line 5391 of file ordinal.c.

{
    FIXME("(%s, %p, %p, %i) STUB\n",verb, pUnknown, pUnknown2, dwUnknown3);
    return 0;
}

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;
}

SHWeakQueryInterface()

HRESULT WINAPI SHWeakQueryInterface	(	IUnknown *	pUnk,
		IUnknown *	pInner,
		IID *	riid,
		LPVOID *	ppv
	)

Definition at line 2861 of file ordinal.c.

{
    HRESULT hret = E_NOINTERFACE;
    TRACE("(pUnk=%p pInner=%p\n\tIID:  %s %p)\n",pUnk,pInner,debugstr_guid(riid), ppv);
 
    *ppv = NULL;
    if(pUnk && pInner) {
            hret = IUnknown_QueryInterface(pInner, riid, ppv);
        if (SUCCEEDED(hret)) IUnknown_Release(pUnk);
    }
    TRACE("-- 0x%08x\n", hret);
    return hret;
}

SHWeakReleaseInterface()

VOID WINAPI SHWeakReleaseInterface	(	IUnknown *	lpDest,
		IUnknown **	lppUnknown
	)

Definition at line 2891 of file ordinal.c.

{
  TRACE("(%p,%p)\n", lpDest, lppUnknown);
 
  if (*lppUnknown)
  {
    /* Copy Reference*/
    IUnknown_AddRef(lpDest);
    IUnknown_AtomicRelease(lppUnknown); /* Release existing interface */
  }
}

SHWinHelpOnDemandA()

DWORD WINAPI SHWinHelpOnDemandA	(	HWND	hwnd,
		LPCSTR	helpfile,
		DWORD	flags1,
		VOID *	ptr1,
		DWORD	flags2
	)

Definition at line 3990 of file ordinal.c.

{
 
    FIXME("(%p, %s, 0x%x, %p, %d)\n", hwnd, debugstr_a(helpfile), flags1, ptr1, flags2);
    return 0;
}

SHWinHelpOnDemandW()

DWORD WINAPI SHWinHelpOnDemandW	(	HWND	hwnd,
		LPCWSTR	helpfile,
		DWORD	flags1,
		VOID *	ptr1,
		DWORD	flags2
	)

Definition at line 3979 of file ordinal.c.

{
 
    FIXME("(%p, %s, 0x%x, %p, %d)\n", hwnd, debugstr_w(helpfile), flags1, ptr1, flags2);
    return 0;
}

SKAllocValueW()

HRESULT WINAPI SKAllocValueW	(	DWORD	flags,
		LPCWSTR	subkey,
		LPCWSTR	value,
		DWORD *	type,
		LPVOID *	data,
		DWORD *	count
	)

Definition at line 4827 of file ordinal.c.

{
    DWORD ret, size;
    HKEY hkey;
 
    TRACE("(0x%x, %s, %s, %p, %p, %p)\n", flags, debugstr_w(subkey),
        debugstr_w(value), type, data, count);
 
    hkey = SHGetShellKey(flags, subkey, FALSE);
    if (!hkey)
        return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 
    ret = SHQueryValueExW(hkey, value, NULL, type, NULL, &size);
    if (ret) {
        RegCloseKey(hkey);
        return HRESULT_FROM_WIN32(ret);
    }
 
    size += 2;
    *data = LocalAlloc(0, size);
    if (!*data) {
        RegCloseKey(hkey);
        return E_OUTOFMEMORY;
    }
 
    ret = SHQueryValueExW(hkey, value, NULL, type, *data, &size);
    if (count)
        *count = size;
 
    RegCloseKey(hkey);
    return HRESULT_FROM_WIN32(ret);
}

Referenced by init_pointers().

SKDeleteValueW()

HRESULT WINAPI SKDeleteValueW	(	DWORD	flags,
		LPCWSTR	subkey,
		LPCWSTR	value
	)

Definition at line 4864 of file ordinal.c.

{
    DWORD ret;
    HKEY hkey;
 
    TRACE("(0x%x, %s %s)\n", flags, debugstr_w(subkey), debugstr_w(value));
 
    hkey = SHGetShellKey(flags, subkey, FALSE);
    if (!hkey)
        return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 
    ret = RegDeleteValueW(hkey, value);
 
    RegCloseKey(hkey);
    return HRESULT_FROM_WIN32(ret);
}

Referenced by init_pointers().

SKGetValueW()

HRESULT WINAPI SKGetValueW	(	DWORD	flags,
		LPCWSTR	subkey,
		LPCWSTR	value,
		DWORD *	type,
		void *	data,
		DWORD *	count
	)

Definition at line 4884 of file ordinal.c.

{
    DWORD ret;
    HKEY hkey;
 
    TRACE("(0x%x, %s, %s, %p, %p, %p)\n", flags, debugstr_w(subkey),
        debugstr_w(value), type, data, count);
 
    hkey = SHGetShellKey(flags, subkey, FALSE);
    if (!hkey)
        return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 
    ret = SHQueryValueExW(hkey, value, NULL, type, data, count);
 
    RegCloseKey(hkey);
    return HRESULT_FROM_WIN32(ret);
}

Referenced by init_pointers().

SKSetValueW()

HRESULT WINAPI SKSetValueW	(	DWORD	flags,
		LPCWSTR	subkey,
		LPCWSTR	value,
		DWORD	type,
		void *	data,
		DWORD	count
	)

Definition at line 4906 of file ordinal.c.

{
    DWORD ret;
    HKEY hkey;
 
    TRACE("(0x%x, %s, %s, %x, %p, %d)\n", flags, debugstr_w(subkey),
            debugstr_w(value), type, data, count);
 
    hkey = SHGetShellKey(flags, subkey, TRUE);
    if (!hkey)
        return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 
    ret = RegSetValueExW(hkey, value, 0, type, data, count);
 
    RegCloseKey(hkey);
    return HRESULT_FROM_WIN32(ret);
}

Referenced by init_pointers().

StrCmpCA()

DWORD WINAPI StrCmpCA	(	LPCSTR	lpszSrc,
		LPCSTR	lpszCmp
	)

Definition at line 859 of file ordinal.c.

{
    return lstrcmpA(lpszSrc, lpszCmp);
}

StrCmpCW()

DWORD WINAPI StrCmpCW	(	LPCWSTR	lpszSrc,
		LPCWSTR	lpszCmp
	)

Definition at line 869 of file ordinal.c.

{
    return lstrcmpW(lpszSrc, lpszCmp);
}

StrCmpICA()

DWORD WINAPI StrCmpICA	(	LPCSTR	lpszSrc,
		LPCSTR	lpszCmp
	)

Definition at line 887 of file ordinal.c.

{
    return lstrcmpiA(lpszSrc, lpszCmp);
}

StrCmpICW()

DWORD WINAPI StrCmpICW	(	LPCWSTR	lpszSrc,
		LPCWSTR	lpszCmp
	)

Definition at line 897 of file ordinal.c.

{
    return lstrcmpiW(lpszSrc, lpszCmp);
}

StrCmpNCA()

DWORD WINAPI StrCmpNCA	(	LPCSTR	lpszSrc,
		LPCSTR	lpszCmp,
		INT	len
	)

Definition at line 802 of file ordinal.c.

{
    return StrCmpNA(lpszSrc, lpszCmp, len);
}

StrCmpNCW()

DWORD WINAPI StrCmpNCW	(	LPCWSTR	lpszSrc,
		LPCWSTR	lpszCmp,
		INT	len
	)

Definition at line 812 of file ordinal.c.

{
    return StrCmpNW(lpszSrc, lpszCmp, len);
}

StrCmpNICA()

DWORD WINAPI StrCmpNICA	(	LPCSTR	lpszSrc,
		LPCSTR	lpszCmp,
		DWORD	len
	)

Definition at line 831 of file ordinal.c.

{
    return StrCmpNIA(lpszSrc, lpszCmp, len);
}

StrCmpNICW()

DWORD WINAPI StrCmpNICW	(	LPCWSTR	lpszSrc,
		LPCWSTR	lpszCmp,
		DWORD	len
	)

Definition at line 841 of file ordinal.c.

{
    return StrCmpNIW(lpszSrc, lpszCmp, len);
}

VerQueryValueWrapW()

WORD WINAPI VerQueryValueWrapW	(	LPVOID	pBlock,
		LPCWSTR	lpSubBlock,
		LPVOID *	lplpBuffer,
		UINT *	puLen
	)

Definition at line 3532 of file ordinal.c.

{
    return VerQueryValueW( pBlock, lpSubBlock, lplpBuffer, puLen );
}

WhichPlatform()

DWORD WINAPI WhichPlatform

(

void

)

Definition at line 2951 of file ordinal.c.

{
  static const char szIntegratedBrowser[] = "IntegratedBrowser";
  static DWORD dwState = 0;
  HKEY hKey;
  DWORD dwRet, dwData, dwSize;
  HMODULE hshell32;
 
  if (dwState)
    return dwState;
 
  /* If shell32 exports DllGetVersion(), the browser is integrated */
  dwState = 1;
  hshell32 = LoadLibraryA("shell32.dll");
  if (hshell32)
  {
    FARPROC pDllGetVersion;
    pDllGetVersion = GetProcAddress(hshell32, "DllGetVersion");
    dwState = pDllGetVersion ? 2 : 1;
    FreeLibrary(hshell32);
  }
 
  /* Set or delete the key accordingly */
  dwRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
                        "Software\\Microsoft\\Internet Explorer", 0,
                         KEY_ALL_ACCESS, &hKey);
  if (!dwRet)
  {
    dwRet = RegQueryValueExA(hKey, szIntegratedBrowser, 0, 0,
                             (LPBYTE)&dwData, &dwSize);
 
    if (!dwRet && dwState == 1)
    {
      /* Value exists but browser is not integrated */
      RegDeleteValueA(hKey, szIntegratedBrowser);
    }
    else if (dwRet && dwState == 2)
    {
      /* Browser is integrated but value does not exist */
      dwData = TRUE;
      RegSetValueExA(hKey, szIntegratedBrowser, 0, REG_DWORD,
                     (LPBYTE)&dwData, sizeof(dwData));
    }
    RegCloseKey(hKey);
  }
  return dwState;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)

WNetGetLastErrorWrapW()

DWORD WINAPI WNetGetLastErrorWrapW	(	LPDWORD	lpError,
		LPWSTR	lpErrorBuf,
		DWORD	nErrorBufSize,
		LPWSTR	lpNameBuf,
		DWORD	nNameBufSize
	)

Definition at line 3830 of file ordinal.c.

{
    return WNetGetLastErrorW(lpError, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize);
}

WNetRestoreConnectionWrapW()

DWORD WINAPI WNetRestoreConnectionWrapW	(	HWND	hwndOwner,
		LPWSTR	lpszDevice
	)

Definition at line 3820 of file ordinal.c.

{
    return WNetRestoreConnectionW(hwndOwner, lpszDevice);
}

ZoneCheckUrlExW()

INT WINAPI ZoneCheckUrlExW	(	LPWSTR	szURL,
		PVOID	pUnknown,
		DWORD	dwUnknown2,
		DWORD	dwUnknown3,
		DWORD	dwUnknown4,
		DWORD	dwUnknown5,
		DWORD	dwUnknown6,
		DWORD	dwUnknown7
	)

Definition at line 5368 of file ordinal.c.

{
    FIXME("(%s,%p,%x,%x,%x,%x,%x,%x) STUB\n", debugstr_w(szURL), pUnknown, dwUnknown2,
        dwUnknown3, dwUnknown4, dwUnknown5, dwUnknown6, dwUnknown7);
 
    return 0;
}

ZoneComputePaneSize()

UINT WINAPI ZoneComputePaneSize

(

HWND

hwnd

)

Definition at line 5034 of file ordinal.c.

{
    FIXME("\n");
    return 0x95;
}

Variable Documentation

objcompat_table

const struct objcompat_entry objcompat_table[]

static

Initial value:

= {
    { {'C','O','C','R','E','A','T','E','S','H','E','L','L','F','O','L','D','E','R','O','N','L','Y',0},
      OBJCOMPAT_COCREATESHELLFOLDERONLY },
    { {'C','T','X','M','E','N','U','_','L','I','M','I','T','E','D','Q','I',0},
      OBJCOMPAT_CTXMENU_LIMITEDQI },
    { {'C','T','X','M','E','N','U','_','N','O','V','E','R','B','S',0},
      OBJCOMPAT_CTXMENU_LIMITEDQI },
    { {'C','T','X','M','E','N','U','_','X','P','Q','C','M','F','L','A','G','S',0},
      OBJCOMPAT_CTXMENU_XPQCMFLAGS },
    { {'N','E','E','D','S','F','I','L','E','S','Y','S','A','N','C','E','S','T','O','R',0},
      OBJCOMPAT_NEEDSFILESYSANCESTOR },
    { {'N','E','E','D','S','S','T','O','R','A','G','E','A','N','C','E','S','T','O','R',0},
      OBJCOMPAT_NEEDSSTORAGEANCESTOR },
    { {'N','O','I','P','R','O','P','E','R','T','Y','S','T','O','R','E',0},
      OBJCOMPAT_NOIPROPERTYSTORE },
    { {'N','O','L','E','G','A','C','Y','W','E','B','V','I','E','W',0},
      OBJCOMPAT_NOLEGACYWEBVIEW },
    { {'N','O','T','A','F','I','L','E','S','Y','S','T','E','M',0},
      OBJCOMPAT_NOTAFILESYSTEM },
    { {'N','O','_','W','E','B','V','I','E','W',0},
      OBJCOMPAT_NO_WEBVIEW },
    { {'O','T','N','E','E','D','S','S','F','C','A','C','H','E',0},
      OBJCOMPAT_OTNEEDSSFCACHE },
    { {'P','I','N','D','L','L',0},
      OBJCOMPAT_PINDLL },
    { {'U','N','B','I','N','D','A','B','L','E',0},
      OBJCOMPAT_UNBINDABLE }
}

Definition at line 6273 of file ordinal.c.

Referenced by SHGetObjectCompatFlags().

shlwapi_hInstance

HINSTANCE shlwapi_hInstance

extern

Definition at line 33 of file shlwapi_main.c.

Referenced by SHCreateWorkerWindowA(), and SHCreateWorkerWindowW().

SHLWAPI_ThreadRef_index

DWORD SHLWAPI_ThreadRef_index

extern

Definition at line 34 of file shlwapi_main.c.

strRegistryPolicyW

const WCHAR strRegistryPolicyW[]

static

Initial value:

= {'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',
                                      '\\','P','o','l','i','c','i','e','s',0}

Definition at line 2725 of file ordinal.c.

Referenced by SHGetRestriction().