ordinal.c File Reference

#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	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)
static HRESULT	iunknown_query_service (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)
INT WINAPI	SHStringFromGUIDA (REFGUID guid, LPSTR lpszDest, INT cchMax)
INT WINAPI	SHStringFromGUIDW (REFGUID guid, LPWSTR lpszDest, INT cchMax)
BOOL WINAPI	GetStringType3ExW (LPWSTR src, INT count, LPWORD type)
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)
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_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)
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	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)
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)
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, 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)
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)
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)
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 27 of file ordinal.c.

EnableModeless

#define EnableModeless

(

type

)

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

Definition at line 3084 of file ordinal.c.

FDSA_FLAG_INTERNAL_ALLOC

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

Definition at line 1966 of file ordinal.c.

GET_RGB

#define GET_RGB

(

h

)

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

Definition at line 3446 of file ordinal.c.

IShellBrowser_EnableModeless

#define IShellBrowser_EnableModeless   IShellBrowser_EnableModelessSB

Definition at line 3083 of file ordinal.c.

IsIface

#define IsIface

(

type

)

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

Definition at line 3082 of file ordinal.c.

OBJCOMPAT_COCREATESHELLFOLDERONLY

#define OBJCOMPAT_COCREATESHELLFOLDERONLY   0x00000100

Definition at line 5672 of file ordinal.c.

OBJCOMPAT_CTXMENU_LIMITEDQI

#define OBJCOMPAT_CTXMENU_LIMITEDQI   0x00000080

Definition at line 5671 of file ordinal.c.

OBJCOMPAT_CTXMENU_NOVERBS

#define OBJCOMPAT_CTXMENU_NOVERBS   0x00000040

Definition at line 5670 of file ordinal.c.

OBJCOMPAT_CTXMENU_XPQCMFLAGS

#define OBJCOMPAT_CTXMENU_XPQCMFLAGS   0x00001000

Definition at line 5675 of file ordinal.c.

OBJCOMPAT_NEEDSFILESYSANCESTOR

#define OBJCOMPAT_NEEDSFILESYSANCESTOR   0x00000010

Definition at line 5668 of file ordinal.c.

OBJCOMPAT_NEEDSSTORAGEANCESTOR

#define OBJCOMPAT_NEEDSSTORAGEANCESTOR   0x00000200

Definition at line 5673 of file ordinal.c.

OBJCOMPAT_NO_WEBVIEW

#define OBJCOMPAT_NO_WEBVIEW   0x00000002

Definition at line 5665 of file ordinal.c.

OBJCOMPAT_NOIPROPERTYSTORE

#define OBJCOMPAT_NOIPROPERTYSTORE   0x00002000

Definition at line 5676 of file ordinal.c.

OBJCOMPAT_NOLEGACYWEBVIEW

#define OBJCOMPAT_NOLEGACYWEBVIEW   0x00000400

Definition at line 5674 of file ordinal.c.

OBJCOMPAT_NOTAFILESYSTEM

#define OBJCOMPAT_NOTAFILESYSTEM   0x00000020

Definition at line 5669 of file ordinal.c.

OBJCOMPAT_OTNEEDSSFCACHE

#define OBJCOMPAT_OTNEEDSSFCACHE   0x00000001

Definition at line 5664 of file ordinal.c.

OBJCOMPAT_PINDLL

#define OBJCOMPAT_PINDLL   0x00000008

Definition at line 5667 of file ordinal.c.

OBJCOMPAT_UNBINDABLE

#define OBJCOMPAT_UNBINDABLE   0x00000004

Definition at line 5666 of file ordinal.c.

SHELL_NO_POLICY

#define SHELL_NO_POLICY   0xffffffff

Definition at line 2335 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 4352 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 3634 of file ordinal.c.

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

ColorAdjustLuma()

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

Definition at line 3330 of file ordinal.c.

{
  TRACE("(0x%8lx,%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 3464 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 3762 of file ordinal.c.

{
  int wR, wG, wB, wMax, wMin, wHue, wLuminosity, wSaturation;
 
  TRACE("(%08lx,%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 868 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 3431 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 2996 of file ordinal.c.

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

ExtractIconWrapW()

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

Definition at line 3236 of file ordinal.c.

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

FDSA_DeleteItem()

BOOL WINAPI FDSA_DeleteItem	(	FDSA_info *	info,
		DWORD	where
	)

Definition at line 2055 of file ordinal.c.

{
    TRACE("(%p 0x%08lx)\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 1999 of file ordinal.c.

{
    TRACE("(%p)\n", info);
 
    if(info->flags & FDSA_FLAG_INTERNAL_ALLOC)
    {
        free(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 1973 of file ordinal.c.

{
    TRACE("(0x%08lx 0x%08lx %p %p 0x%08lx)\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 2017 of file ordinal.c.

{
    TRACE("(%p 0x%08lx %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 = _recalloc(info->mem, 1, size);
        else
        {
            void *old_mem = info->mem;
            info->mem = calloc(1, 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 3976 of file ordinal.c.

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

Referenced by PathQualifyExW().

GetFileVersionInfoSizeWrapW()

DWORD WINAPI GetFileVersionInfoSizeWrapW	(	LPCWSTR	filename,
		LPDWORD	handle
	)

Definition at line 3055 of file ordinal.c.

{
    return GetFileVersionInfoSizeW( filename, handle );
}

GetFileVersionInfoWrapW()

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

Definition at line 3065 of file ordinal.c.

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

GetMenuPosFromID()

INT WINAPI GetMenuPosFromID	(	HMENU	hMenu,
		UINT	wID
	)

Definition at line 3924 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 3405 of file ordinal.c.

{
    return GetOpenFileNameW(ofn);
}

GetSaveFileNameWrapW()

BOOL WINAPI GetSaveFileNameWrapW

(

LPOPENFILENAMEW

ofn

)

Definition at line 3354 of file ordinal.c.

{
    return GetSaveFileNameW(ofn);
}

GetShellSecurityDescriptor()

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

Definition at line 4507 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 = malloc(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]);
    }
    free(sidlist);
 
    return psd;
}

Referenced by init_pointers().

GetStringType3ExW()

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

Definition at line 572 of file ordinal.c.

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

GetUIVersion()

DWORD WINAPI GetUIVersion

(

void

)

Definition at line 4357 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 2530 of file ordinal.c.

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

Referenced by init_pointers().

GUIDFromStringW()

BOOL WINAPI GUIDFromStringW	(	LPCWSTR	idstr,
		CLSID *	id
	)

Definition at line 2542 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 2728 of file ordinal.c.

{
    IID iid;
    HRESULT result;
 
    FIXME("(%p)->(0x%lx %p %lx %lx) 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 2785 of file ordinal.c.

{
  IEnumConnections *lpEnum;
  HRESULT hRet = E_NOINTERFACE;
 
  TRACE("(%p,0x%8lX)\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 2752 of file ordinal.c.

{
  IID iid;
  HRESULT result;
 
  TRACE("(%p)->(0x%lx %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().

IsQSForward()

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

Definition at line 1921 of file ordinal.c.

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

Referenced by TEST_IsQSForward().

IUnknown_CPContainerInvokeParam()

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

Definition at line 2824 of file ordinal.c.

{
  HRESULT result;
  IConnectionPoint *iCP;
  IConnectionPointContainer *iCPC;
  DISPPARAMS dispParams = {buffer, NULL, cParams, 0};
  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;
 
  va_start(valist, cParams);
  SHPackDispParamsV(&dispParams, buffer, cParams, valist);
  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 2873 of file ordinal.c.

{
  IConnectionPointContainer* lpCPC = NULL;
  HRESULT hRet = E_NOINTERFACE;
 
  TRACE("(%p,0x%8lX)\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 3105 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 762 of file ordinal.c.

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

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

IUnknown_GetClassID()

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

Definition at line 1071 of file ordinal.c.

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

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

IUnknown_GetWindow()

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

Definition at line 988 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(), and CToolsBand::SetSite().

IUnknown_HandleIRestrict()

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

Definition at line 1548 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_query_service(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 3724 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 4231 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 1526 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 1187 of file ordinal.c.

{
    IProfferService *proffer;
    HRESULT hr;
 
    TRACE("%p %s %p %p\n", lpUnknown, debugstr_guid(service), pService, pCookie);
 
    hr = iunknown_query_service(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_query_service()

static HRESULT iunknown_query_service ( IUnknown *  lpUnknown, REFGUID  sid, REFIID  riid, LPVOID *  lppOut  )

static

Definition at line 1097 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 IUnknown_HandleIRestrict(), IUnknown_ProfferService(), IUnknown_QueryServiceExec(), and RegisterDefaultAcceptHeaders().

IUnknown_QueryServiceExec()

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

Definition at line 1148 of file ordinal.c.

{
    IOleCommandTarget *target;
    HRESULT hr;
 
    TRACE("%p %s %s %ld %08lx %p %p\n", lpUnknown, debugstr_guid(service),
        debugstr_guid(group), cmdId, cmdOpt, pIn, pOut);
 
    hr = iunknown_query_service(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%08lx\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 4814 of file ordinal.c.

{
#ifdef __REACTOS__
    IServiceProvider *pSP;
    HRESULT hr = IUnknown_QueryService(lpUnknown, &SID_STopLevelBrowser,
                                       &IID_IServiceProvider, (PVOID*)&pSP);
    if (FAILED(hr))
    {
        *lppOut = NULL;
        return hr;
    }
    hr = pSP->lpVtbl->QueryService(pSP, &IID_IWebBrowserApp, riid, lppOut);
    pSP->lpVtbl->Release(pSP);
    return hr;
#else
    FIXME("%p %s %p semi-STUB\n", lpUnknown, debugstr_guid(riid), lppOut);
    return IUnknown_QueryService(lpUnknown,&IID_IWebBrowserApp,riid,lppOut);
#endif
}

Referenced by IUnknown_ShowBrowserBar().

IUnknown_QueryStatus()

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

Definition at line 723 of file ordinal.c.

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

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

IUnknown_SetOwner()

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

Definition at line 1037 of file ordinal.c.

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

Referenced by CTrayBandSite::AddContextMenus().

IUnknown_TranslateAcceleratorIO()

HRESULT WINAPI IUnknown_TranslateAcceleratorIO	(	IUnknown *	lpUnknown,
		LPMSG	lpMsg
	)

Definition at line 3692 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 1493 of file ordinal.c.

{
  IOleControlSite* lpCSite = NULL;
  HRESULT hRet = E_INVALIDARG;
 
  TRACE("(%p,%p,0x%08lx)\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 1228 of file ordinal.c.

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

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

MayExecForward()

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

Definition at line 1834 of file ordinal.c.

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

Referenced by TEST_MayExecForwardMockup().

MayQSForward()

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

Definition at line 1796 of file ordinal.c.

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

Referenced by TEST_MayQSForwardMockup().

MLClearMLHInstance()

DWORD WINAPI MLClearMLHInstance

(

DWORD

x

)

Definition at line 3592 of file ordinal.c.

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

MLFreeLibrary()

BOOL WINAPI MLFreeLibrary

(

HMODULE

hModule

)

Definition at line 3555 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 3573 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 3256 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,%ld) 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 3298 of file ordinal.c.

{
    WCHAR mod_path[2*MAX_PATH];
    LPWSTR ptr;
    DWORD len;
 
    FIXME("(%s,%p,%ld) semi-stub!\n", debugstr_w(new_mod), inst_hwnd, dwCrossCodePage);
    len = GetModuleFileNameW(inst_hwnd, mod_path, ARRAY_SIZE(mod_path));
    if (!len || len >= ARRAY_SIZE(mod_path)) return NULL;
 
    ptr = wcsrchr(mod_path, '\\');
    if (ptr) {
    lstrcpyW(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 3583 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 3385 of file ordinal.c.

{
    return PageSetupDlgW(pagedlg);
}

PathSkipLeadingSlashesA()

LPCSTR WINAPI PathSkipLeadingSlashesA

(

LPCSTR

lpszSrc

)

Definition at line 921 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 2901 of file ordinal.c.

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

PrintDlgWrapW()

BOOL WINAPI PrintDlgWrapW

(

LPPRINTDLGW

printdlg

)

Definition at line 3395 of file ordinal.c.

{
    return PrintDlgW(printdlg);
}

RegisterDefaultAcceptHeaders()

HRESULT WINAPI RegisterDefaultAcceptHeaders	(	LPBC	lpBC,
		IUnknown *	lpUnknown
	)

Definition at line 346 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_query_service(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 = malloc(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)
        {
          free(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);
    free(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 590 of file ordinal.c.

{
  WCHAR buff[2084];
 
  TRACE("(%p,%ld)\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 609 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,%ld)\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 = lstrlenW(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 167 of file ordinal.c.

{
  HANDLE hMap;
  LPVOID pMapped;
  HANDLE hRet = NULL;
 
  TRACE("(%p,%ld,%ld)\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 AppBar_CopyIn(), CreateNotificationParam(), CreateRegistrationParam(), init_pointers(), MakeSharedPacket(), and SHELL_ArgifyW().

SHBrowseForFolderWrapW()

LPITEMIDLIST WINAPI SHBrowseForFolderWrapW

(

LPBROWSEINFOW

lpBi

)

Definition at line 3006 of file ordinal.c.

{
    return SHBrowseForFolderW(lpBi);
}

SHChangeNotifyWrap()

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

Definition at line 4470 of file ordinal.c.

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

SHCheckMenuItem()

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

Definition at line 1395 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 4002 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 4641 of file ordinal.c.

{
    FIXME("%p %s %ld %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 3871 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 2292 of file ordinal.c.

{
  static const char szClass[] = "WorkerA";
  WNDCLASSA wc;
  HWND hWnd;
 
  TRACE("(%p, %p, 0x%08lx, 0x%08lx, %p, 0x%08Ix)\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 2552 of file ordinal.c.

{
  static const WCHAR szClass[] = { 'W', 'o', 'r', 'k', 'e', 'r', 'W', 0 };
  WNDCLASSW wc;
  HWND hWnd;
 
  TRACE("(%p, %p, 0x%08lx, 0x%08lx, %p, 0x%08Ix)\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%08lx\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 3148 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 2268 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 3026 of file ordinal.c.

{
    return ShellExecuteExW(lpExecInfo);
}

ShellMessageBoxWrapW()

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

Definition at line 4405 of file ordinal.c.

{
    WCHAR *szText = NULL, szTitle[100];
    LPCWSTR pszText, pszTitle = szTitle;
    LPWSTR pszTemp;
    va_list args;
    int ret;
 
    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 = malloc((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));
            va_end(args);
            return 0;
        }
    }
    else
        pszText = lpText;
 
    FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
                   pszText, 0, 0, (LPWSTR)&pszTemp, 0, &args);
 
    va_end(args);
 
#ifdef __REACTOS__
    uType |= MB_SETFOREGROUND;
#endif
    ret = MessageBoxW(hWnd, pszTemp, pszTitle, uType);
 
    free(szText);
    LocalFree(pszTemp);
    return ret;
}

SHEnableMenuItem()

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

Definition at line 1376 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 3036 of file ordinal.c.

{
    return SHFileOperationW(lpFileOp);
}

SHFillRectClr()

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

Definition at line 1728 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 3564 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 4732 of file ordinal.c.

{
    WCHAR *bufW;
    INT retval;
 
    if (!buf || !size)
        return 0;
 
    bufW = malloc(sizeof(WCHAR) * size);
    retval = SHFormatDateTimeW(fileTime, flags, bufW, size);
 
    if (retval != 0)
        retval = WideCharToMultiByte(CP_ACP, 0, bufW, -1, buf, size, NULL, NULL);
 
    free(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 4667 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%08lx\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 313 of file ordinal.c.

{
  HANDLE hClose;
 
  TRACE("(%p %ld)\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(), AppBar_CopyIn(), AppBar_CopyOut(), CreateNotificationParam(), CreateNotificationParamAndSend(), CreateRegistrationParam(), init_pointers(), MakeSharedPacket(), CChangeNotifyServer::OnDeliverNotification(), ParseSharedPacket(), and SHChangeNotifyRegister().

SHGetAppCompatFlags()

DWORD WINAPI SHGetAppCompatFlags

(

DWORD

dwUnknown

)

Definition at line 3991 of file ordinal.c.

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

SHGetCurColorRes()

DWORD WINAPI SHGetCurColorRes

(

void

)

Definition at line 1618 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 2985 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 2923 of file ordinal.c.

{
    INT ret;
    WCHAR *buf;
 
    TRACE("(%s,%s,%p,%08lx,%s)\n", debugstr_w(appName), debugstr_w(keyName),
        out, outLen, debugstr_w(filename));
 
    if(outLen == 0)
        return 0;
 
    buf = malloc(outLen * sizeof(WCHAR));
    if(!buf){
        *out = 0;
        return 0;
    }
 
    ret = GetPrivateProfileStringW(appName, keyName, NULL, buf, outLen, filename);
    if(ret)
        lstrcpyW(out, buf);
    else
        *out = 0;
 
    free(buf);
 
    return lstrlenW(out);
}

Referenced by init_pointers(), and SHPropertyBag_SHSetIniStringW().

SHGetInverseCMAP()

HRESULT WINAPI SHGetInverseCMAP	(	LPDWORD	dest,
		DWORD	dwSize
	)

Definition at line 3900 of file ordinal.c.

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

SHGetMachineInfo()

DWORD WINAPI SHGetMachineInfo

(

DWORD

dwFlags

)

Definition at line 3502 of file ordinal.c.

{
  HW_PROFILE_INFOA hwInfo;
 
  TRACE("(0x%08lx)\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 1592 of file ordinal.c.

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

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

SHGetNewLinkInfoWrapW()

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

Definition at line 3137 of file ordinal.c.

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

SHGetObjectCompatFlags()

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

Definition at line 5727 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[ARRAY_SIZE(compatpathW) + 38 /* { CLSID } */];
    DWORD ret, length = ARRAY_SIZE(strW);
    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);
    swprintf(strW, ARRAY_SIZE(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 = ARRAY_SIZE(objcompat_table) - 1;
 
        while (right >= left) {
            x = (left + right) / 2;
            res = wcscmp(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 = ARRAY_SIZE(strW);
    }
 
    return ret;
}

Referenced by init_pointers(), and SHGetAttributes().

SHGetPathFromIDListWrapW()

BOOL WINAPI SHGetPathFromIDListWrapW	(	LPCITEMIDLIST	pidl,
		LPWSTR	pszPath
	)

Definition at line 3016 of file ordinal.c.

{
    return SHGetPathFromIDListW(pidl, pszPath);
}

Referenced by _ILIsNetworkPlace().

SHGetRestriction()

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

Definition at line 2357 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 4049 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%08lx, %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%08lx)\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%08lx)\n", flags);
        return NULL;
    }
 
    if(sub_key)
        size_user = lstrlenW(sub_key)*sizeof(WCHAR);
    else
        size_user = 0;
 
    path = malloc(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);
 
    free(path);
    return hkey;
}

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

SHInterlockedCompareExchange()

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

Definition at line 3045 of file ordinal.c.

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

SHInvokeCommand()

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

Definition at line 3177 of file ordinal.c.

{
  IContextMenu *iContext;
  HRESULT hRet;
 
  TRACE("(%p, %p, %p, %lu)\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 2608 of file ordinal.c.

{
    TRACE("%p %p %p\n", hWnd, lpFolder, lpApidl);
    return SHInvokeCommand(hWnd, lpFolder, lpApidl, 0);
}

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

SHIsChildOrSelf()

BOOL WINAPI SHIsChildOrSelf	(	HWND	hParent,
		HWND	hChild
	)

Definition at line 1941 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 1683 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 3413 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().

SHIsSameObject()

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

Definition at line 941 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 1459 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 1261 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 3669 of file ordinal.c.

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

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

SHLockShared()

PVOID WINAPI SHLockShared	(	HANDLE	hShared,
		DWORD	dwProcId
	)

Definition at line 257 of file ordinal.c.

{
#ifdef __REACTOS__
    return SHLockSharedEx(hShared, dwProcId, TRUE);
#else
  HANDLE hDup;
  LPVOID pMapped;
 
  TRACE("(%p %ld)\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(), AppBar_CopyIn(), AppBar_CopyOut(), AppBar_LockOutput(), init_pointers(), MakeSharedPacket(), ParseSharedPacket(), and SHELL_ArgifyW().

SHLWAPI_EnumChildProc()

static BOOL CALLBACK SHLWAPI_EnumChildProc ( HWND  hWnd, LPARAM  lParam  )

static

Definition at line 1287 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 2689 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 96 of file ordinal.c.

{
  HANDLE hDst, hSrc;
  DWORD dwMyProcId = GetCurrentProcessId();
  HANDLE hRet = NULL;
 
  TRACE("(%p,%ld,%ld,%08lx,%08lx)\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 3951 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 2671 of file ordinal.c.

{
  va_list valist;
  HRESULT hres;
 
  va_start(valist, cnt);
  hres = SHPackDispParamsV(params, args, cnt, valist);
  va_end(valist);
  return hres;
}

Referenced by init_pointers().

SHPackDispParamsV()

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

Definition at line 2619 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 2173 of file ordinal.c.

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

Referenced by SHAutoComplete(), and SHLWAPI_GetCachedZonesManagerInner().

SHPropagateMessage()

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

Definition at line 1314 of file ordinal.c.

{
  enumWndData data;
 
  TRACE("(%p,%u,%Id,%Id,%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 5036 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 4189 of file ordinal.c.

{
    TRACE("(%p, %p, %ld, %Ix, %p, %s, %08lx)\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 1412 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 2195 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 1347 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 2145 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 2424 of file ordinal.c.

{
    TRACE("(0x%08lx %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: (%08lx)\n", policy);
    return 0;
}

Referenced by SHRestricted().

SHSearchMapInt()

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

Definition at line 1756 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 3604 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 3616 of file ordinal.c.

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

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

SHSetDefaultDialogFont()

HRESULT WINAPI SHSetDefaultDialogFont	(	HWND	hWnd,
		INT	id
	)

Definition at line 2093 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 2970 of file ordinal.c.

{
    TRACE("(%s, %s, %s, %s)\n", debugstr_w(appName), debugstr_w(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 833 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 4205 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 805 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 1423 of file ordinal.c.

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

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

SHSkipJunction()

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

Definition at line 4022 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 513 of file ordinal.c.

{
  char xguid[40];
  INT iLen;
 
  TRACE("(%s,%p,%d)\n", debugstr_guid(guid), lpszDest, cchMax);
 
  sprintf(xguid, "{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
          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 546 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);
 
  swprintf(xguid, ARRAY_SIZE(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 = lstrlenW(xguid) + 1;
 
  if (iLen > cchMax)
    return 0;
  memcpy(lpszDest, xguid, iLen*sizeof(WCHAR));
  return iLen;
}

Referenced by SH32_CoCreateInstance(), and SHRegGetCLSIDKeyW().

SHUnlockShared()

BOOL WINAPI SHUnlockShared

(

LPVOID

lpView

)

Definition at line 293 of file ordinal.c.

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

Referenced by _ILReadFromSharedMemory(), AppBar_CopyIn(), AppBar_CopyOut(), AppBar_UnLockOutput(), 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 2219 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 2239 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 4791 of file ordinal.c.

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

SHWaitForSendMessageThread()

DWORD WINAPI SHWaitForSendMessageThread	(	HANDLE	hand,
		DWORD	dwTimeout
	)

Definition at line 1645 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 2474 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%08lx\n", hret);
    return hret;
}

SHWeakReleaseInterface()

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

Definition at line 2504 of file ordinal.c.

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

SHWinHelpOnDemandA()

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

Definition at line 3534 of file ordinal.c.

{
 
    FIXME("(%p, %s, 0x%lx, %p, %ld)\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 3523 of file ordinal.c.

{
 
    FIXME("(%p, %s, 0x%lx, %p, %ld)\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 4254 of file ordinal.c.

{
    DWORD ret, size;
    HKEY hkey;
 
    TRACE("(0x%lx, %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 4291 of file ordinal.c.

{
    DWORD ret;
    HKEY hkey;
 
    TRACE("(0x%lx, %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 4311 of file ordinal.c.

{
    DWORD ret;
    HKEY hkey;
 
    TRACE("(0x%lx, %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 4333 of file ordinal.c.

{
    DWORD ret;
    HKEY hkey;
 
    TRACE("(0x%lx, %s, %s, %lx, %p, %ld)\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().

VerQueryValueWrapW()

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

Definition at line 3076 of file ordinal.c.

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

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 3374 of file ordinal.c.

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

WNetRestoreConnectionWrapW()

DWORD WINAPI WNetRestoreConnectionWrapW	(	HWND	hwndOwner,
		LPWSTR	lpszDevice
	)

Definition at line 3364 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 4767 of file ordinal.c.

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

ZoneComputePaneSize()

UINT WINAPI ZoneComputePaneSize

(

HWND

hwnd

)

Definition at line 4461 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 5685 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 2338 of file ordinal.c.

Referenced by SHGetRestriction().