ordinal.c File Reference

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

Include dependency graph for ordinal.c:

Go to the source code of this file.

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

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

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

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

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

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 30 of file ordinal.c.

EnableModeless

#define EnableModeless

(

type

)

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

Definition at line 3453 of file ordinal.c.

FDSA_FLAG_INTERNAL_ALLOC

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

Definition at line 2275 of file ordinal.c.

GET_RGB

#define GET_RGB

(

h

)

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

Definition at line 3807 of file ordinal.c.

IShellBrowser_EnableModeless

#define IShellBrowser_EnableModeless   IShellBrowser_EnableModelessSB

Definition at line 3452 of file ordinal.c.

IsIface

#define IsIface

(

type

)

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

Definition at line 3451 of file ordinal.c.

ISOS_RETURN

#define ISOS_RETURN

(

x

)

Value:

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

OBJCOMPAT_COCREATESHELLFOLDERONLY

#define OBJCOMPAT_COCREATESHELLFOLDERONLY   0x00000100

Definition at line 6144 of file ordinal.c.

OBJCOMPAT_CTXMENU_LIMITEDQI

#define OBJCOMPAT_CTXMENU_LIMITEDQI   0x00000080

Definition at line 6143 of file ordinal.c.

OBJCOMPAT_CTXMENU_NOVERBS

#define OBJCOMPAT_CTXMENU_NOVERBS   0x00000040

Definition at line 6142 of file ordinal.c.

OBJCOMPAT_CTXMENU_XPQCMFLAGS

#define OBJCOMPAT_CTXMENU_XPQCMFLAGS   0x00001000

Definition at line 6147 of file ordinal.c.

OBJCOMPAT_NEEDSFILESYSANCESTOR

#define OBJCOMPAT_NEEDSFILESYSANCESTOR   0x00000010

Definition at line 6140 of file ordinal.c.

OBJCOMPAT_NEEDSSTORAGEANCESTOR

#define OBJCOMPAT_NEEDSSTORAGEANCESTOR   0x00000200

Definition at line 6145 of file ordinal.c.

OBJCOMPAT_NO_WEBVIEW

#define OBJCOMPAT_NO_WEBVIEW   0x00000002

Definition at line 6137 of file ordinal.c.

OBJCOMPAT_NOIPROPERTYSTORE

#define OBJCOMPAT_NOIPROPERTYSTORE   0x00002000

Definition at line 6148 of file ordinal.c.

OBJCOMPAT_NOLEGACYWEBVIEW

#define OBJCOMPAT_NOLEGACYWEBVIEW   0x00000400

Definition at line 6146 of file ordinal.c.

OBJCOMPAT_NOTAFILESYSTEM

#define OBJCOMPAT_NOTAFILESYSTEM   0x00000020

Definition at line 6141 of file ordinal.c.

OBJCOMPAT_OTNEEDSSFCACHE

#define OBJCOMPAT_OTNEEDSSFCACHE   0x00000001

Definition at line 6136 of file ordinal.c.

OBJCOMPAT_PINDLL

#define OBJCOMPAT_PINDLL   0x00000008

Definition at line 6139 of file ordinal.c.

OBJCOMPAT_UNBINDABLE

#define OBJCOMPAT_UNBINDABLE   0x00000004

Definition at line 6138 of file ordinal.c.

SHELL_NO_POLICY

#define SHELL_NO_POLICY   0xffffffff

Definition at line 2675 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 4809 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 3995 of file ordinal.c.

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

ColorAdjustLuma()

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

Definition at line 3691 of file ordinal.c.

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

ColorHLSToRGB()

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

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

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

Referenced by ColorAdjustLuma().

ConnectToConnectionPoint()

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

Definition at line 1189 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 3792 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 3365 of file ordinal.c.

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

ExtractIconWrapW()

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

Definition at line 3597 of file ordinal.c.

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

FDSA_DeleteItem()

BOOL WINAPI FDSA_DeleteItem	(	FDSA_info *	info,
		DWORD	where
	)

Definition at line 2364 of file ordinal.c.

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

FDSA_Destroy()

BOOL WINAPI FDSA_Destroy

(

FDSA_info *

info

)

Definition at line 2308 of file ordinal.c.

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

FDSA_Initialize()

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

Definition at line 2282 of file ordinal.c.

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

FDSA_InsertItem()

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

Definition at line 2326 of file ordinal.c.

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

FixSlashesAndColonW()

VOID WINAPI FixSlashesAndColonW

(

LPWSTR

lpwstr

)

Definition at line 4435 of file ordinal.c.

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

Referenced by PathQualifyExW().

GetAcceptLanguagesA()

HRESULT WINAPI GetAcceptLanguagesA	(	LPSTR	langbuf,
		LPDWORD	buflen
	)

Definition at line 573 of file ordinal.c.

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

Referenced by init_pointers().

GetAcceptLanguagesW()

HRESULT WINAPI GetAcceptLanguagesW	(	LPWSTR	langbuf,
		LPDWORD	buflen
	)

Definition at line 514 of file ordinal.c.

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

Referenced by GetAcceptLanguagesA().

GetFileVersionInfoSizeWrapW()

DWORD WINAPI GetFileVersionInfoSizeWrapW	(	LPCWSTR	filename,
		LPDWORD	handle
	)

Definition at line 3424 of file ordinal.c.

{
    return GetFileVersionInfoSizeW( filename, handle );
}

GetFileVersionInfoWrapW()

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

Definition at line 3434 of file ordinal.c.

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

GetMenuPosFromID()

INT WINAPI GetMenuPosFromID	(	HMENU	hMenu,
		UINT	wID
	)

Definition at line 4398 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 SHMenuIndexFromID().

GetOpenFileNameWrapW()

BOOL WINAPI GetOpenFileNameWrapW

(

LPOPENFILENAMEW

ofn

)

Definition at line 3766 of file ordinal.c.

{
    return GetOpenFileNameW(ofn);
}

GetSaveFileNameWrapW()

BOOL WINAPI GetSaveFileNameWrapW

(

LPOPENFILENAMEW

ofn

)

Definition at line 3715 of file ordinal.c.

{
    return GetSaveFileNameW(ofn);
}

GetShellSecurityDescriptor()

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

Definition at line 4964 of file ordinal.c.

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

Referenced by init_pointers().

GetStringType3ExW()

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

Definition at line 779 of file ordinal.c.

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

GetUIVersion()

DWORD WINAPI GetUIVersion

(

void

)

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

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

Referenced by init_pointers().

GUIDFromStringW()

BOOL WINAPI GUIDFromStringW	(	LPCWSTR	idstr,
		CLSID *	id
	)

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

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

Referenced by init_pointers().

IConnectionPoint_OnChanged()

HRESULT WINAPI IConnectionPoint_OnChanged	(	IConnectionPoint *	lpCP,
		DISPID	dispID
	)

Definition at line 3154 of file ordinal.c.

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

Referenced by IUnknown_CPContainerOnChanged().

IConnectionPoint_SimpleInvoke()

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

Definition at line 3121 of file ordinal.c.

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

Referenced by init_pointers().

IsCharBlankW()

BOOL WINAPI IsCharBlankW

(

WCHAR

wc

)

Definition at line 692 of file ordinal.c.

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

IsCharCntrlW()

BOOL WINAPI IsCharCntrlW

(

WCHAR

wc

)

Definition at line 730 of file ordinal.c.

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

IsCharDigitW()

BOOL WINAPI IsCharDigitW

(

WCHAR

wc

)

Definition at line 749 of file ordinal.c.

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

IsCharPunctW()

BOOL WINAPI IsCharPunctW

(

WCHAR

wc

)

Definition at line 711 of file ordinal.c.

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

IsCharXDigitW()

BOOL WINAPI IsCharXDigitW

(

WCHAR

wc

)

Definition at line 768 of file ordinal.c.

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

IsOS()

BOOL WINAPI IsOS

(

DWORD

feature

)

Definition at line 4012 of file ordinal.c.

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

IsQSForward()

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

Definition at line 2231 of file ordinal.c.

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

IUnknown_AtomicRelease()

void WINAPI IUnknown_AtomicRelease

(

IUnknown **

lpUnknown

)

Definition at line 1241 of file ordinal.c.

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

Referenced by IUnknown_Set(), and SHWeakReleaseInterface().

IUnknown_CPContainerInvokeParam()

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

Definition at line 3193 of file ordinal.c.

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

IUnknown_CPContainerOnChanged()

HRESULT WINAPI IUnknown_CPContainerOnChanged	(	IUnknown *	lpUnknown,
		DISPID	dispID
	)

Definition at line 3242 of file ordinal.c.

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

IUnknown_EnableModeless()

HRESULT WINAPI IUnknown_EnableModeless	(	IUnknown *	lpUnknown,
		BOOL	bModeless
	)

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

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

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

IUnknown_GetClassID()

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

Definition at line 1453 of file ordinal.c.

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

Referenced by CShellBrowser::BrowseToPIDL(), CSearchBar::GetSearchResultsFolder(), init_pointers(), CSearchBar::Invoke(), and SHSkipJunction().

IUnknown_GetSite()

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

Definition at line 2596 of file ordinal.c.

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

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

IUnknown_GetWindow()

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

Definition at line 1332 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(), CInternetToolbar::CreateMenuBar(), CFSDropTarget::Drop(), CAddressEditBox::Execute(), 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(), CExplorerBand::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 1949 of file ordinal.c.

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

IUnknown_HasFocusIO()

HRESULT WINAPI IUnknown_HasFocusIO

(

IUnknown *

lpUnknown

)

Definition at line 4216 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 4688 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(), CExplorerBand::OnKillFocus(), CExplorerBand::OnSetFocus(), CSearchBar::OnSetFocus(), and CAddressBand::UIActivateIO().

IUnknown_OnFocusOCS()

HRESULT WINAPI IUnknown_OnFocusOCS	(	IUnknown *	lpUnknown,
		BOOL	fGotFocus
	)

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

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

Referenced by init_pointers().

IUnknown_QueryService()

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

Definition at line 1497 of file ordinal.c.

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

Referenced by CDefViewBckgrndMenu::_bIsDesktopBrowserMenu(), CDefView::_MergeToolbar(), CMenuDeskBar::_OnActivate(), CDefaultContextMenu::BrowserFlagsFromVerb(), CExplorerBand::DestroyExplorerBand(), CDefaultContextMenu::DoCreateNewFolder(), CDefaultContextMenu::DoRename(), CFSDropTarget::Drop(), CAddressEditBox::Execute(), CExplorerBand::ExecuteCommand(), CBandProxy::FindBrowserWindow(), CAddressEditBox::GetAbsolutePidl(), CShellBrowser::GetMenuBand(), CSearchBar::GetSearchResultsFolder(), CAddressEditBox::Init(), CExplorerBand::InitializeExplorerBand(), CDefViewBckgrndMenu::InvokeCommand(), CNetConUiObject::InvokeCommand(), CMenuFocusManager::IsTrackedWindowOrParent(), IUnknown_HandleIRestrict(), IUnknown_ProfferService(), IUnknown_QueryServiceExec(), IUnknown_QueryServiceForWebBrowserApp(), IUnknown_QueryServicePropertyBag(), CExplorerBand::NavigateToCurrentFolder(), CSearchBar::OnInitDialog(), CInternetToolbar::OnMenuDropDown(), CSearchBar::OnSearchButtonClicked(), CInternetToolbar::OnTravelBack(), CInternetToolbar::OnTravelForward(), CAddressEditBox::ParseNow(), CMenuDeskBar::Popup(), CExplorerBand::QueryService(), CInternetToolbar::QueryService(), CMenuDeskBar::QueryService(), CMenuSite::QueryService(), RegisterDefaultAcceptHeaders(), CNewMenu::SelectNewItem(), CAddressEditBox::SetOwner(), CInternetToolbar::SetSite(), CMenuBand::SetSite(), CMenuDeskBar::SetSite(), CDefaultContextMenu::TryToBrowse(), CMenuBand::UIActivateIO(), and CExplorerBand::UpdateBrowser().

IUnknown_QueryServiceExec()

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

Definition at line 1549 of file ordinal.c.

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

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

IUnknown_QueryServiceForWebBrowserApp()

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

Definition at line 5298 of file ordinal.c.

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

IUnknown_QueryStatus()

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

Definition at line 1044 of file ordinal.c.

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

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

IUnknown_Set()

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

Definition at line 2186 of file ordinal.c.

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

IUnknown_SetOwner()

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

Definition at line 1381 of file ordinal.c.

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

Referenced by CTrayBandSite::AddContextMenus().

IUnknown_SetSite()

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

Definition at line 1407 of file ordinal.c.

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

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

IUnknown_TranslateAcceleratorIO()

HRESULT WINAPI IUnknown_TranslateAcceleratorIO	(	IUnknown *	lpUnknown,
		LPMSG	lpMsg
	)

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

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

IUnknown_UIActivateIO()

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

Definition at line 1629 of file ordinal.c.

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

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

MayExecForward()

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

Definition at line 2218 of file ordinal.c.

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

MayQSForward()

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

Definition at line 2203 of file ordinal.c.

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

MLClearMLHInstance()

DWORD WINAPI MLClearMLHInstance

(

DWORD

x

)

Definition at line 3953 of file ordinal.c.

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

MLFreeLibrary()

BOOL WINAPI MLFreeLibrary

(

HMODULE

hModule

)

Definition at line 3916 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 3934 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 3617 of file ordinal.c.

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

MLLoadLibraryW()

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

Definition at line 3659 of file ordinal.c.

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

Referenced by MLBuildResURLW().

MLSetMLHInstance()

DWORD WINAPI MLSetMLHInstance	(	HINSTANCE	hInst,
		HANDLE	hHeap
	)

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

{
    return PageSetupDlgW(pagedlg);
}

PathSkipLeadingSlashesA()

LPCSTR WINAPI PathSkipLeadingSlashesA

(

LPCSTR

lpszSrc

)

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

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

PrintDlgWrapW()

BOOL WINAPI PrintDlgWrapW

(

LPPRINTDLGW

printdlg

)

Definition at line 3756 of file ordinal.c.

{
    return PrintDlgW(printdlg);
}

QISearch()

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

Definition at line 2392 of file ordinal.c.

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

Referenced by CUnknownBase< Interface >::QueryInterface().

RegisterDefaultAcceptHeaders()

HRESULT WINAPI RegisterDefaultAcceptHeaders	(	LPBC	lpBC,
		IUnknown *	lpUnknown
	)

Definition at line 344 of file ordinal.c.

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

SHAboutInfoA()

BOOL WINAPI SHAboutInfoA	(	LPSTR	lpszDest,
		DWORD	dwDestLen
	)

Definition at line 911 of file ordinal.c.

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

SHAboutInfoW()

BOOL WINAPI SHAboutInfoW	(	LPWSTR	lpszDest,
		DWORD	dwDestLen
	)

Definition at line 930 of file ordinal.c.

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

Referenced by SHAboutInfoA().

SHAllocShared()

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

Definition at line 165 of file ordinal.c.

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

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

SHBrowseForFolderWrapW()

LPITEMIDLIST WINAPI SHBrowseForFolderWrapW

(

LPBROWSEINFOW

lpBi

)

Definition at line 3375 of file ordinal.c.

{
    return SHBrowseForFolderW(lpBi);
}

SHChangeNotifyWrap()

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

Definition at line 4927 of file ordinal.c.

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

SHCheckMenuItem()

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

Definition at line 1796 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 4459 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 5098 of file ordinal.c.

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

Referenced by SHPropertyBag_OnRegKey().

SHCreateShellPalette()

HPALETTE WINAPI SHCreateShellPalette

(

HDC

hdc

)

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

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

Referenced by init_pointers(), and SHCreateWorkerWindowW().

SHCreateWorkerWindowW()

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

Definition at line 2921 of file ordinal.c.

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

Referenced by 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 3517 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 2586 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 3395 of file ordinal.c.

{
    return ShellExecuteExW(lpExecInfo);
}

ShellMessageBoxWrapW()

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

Definition at line 4862 of file ordinal.c.

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

SHEnableMenuItem()

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

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

{
    return SHFileOperationW(lpFileOp);
}

SHFillRectClr()

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

Definition at line 2129 of file ordinal.c.

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

SHFlushSFCacheWrap()

BOOL WINAPI SHFlushSFCacheWrap

(

void

)

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

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

Referenced by init_pointers().

SHFormatDateTimeW()

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

Definition at line 5153 of file ordinal.c.

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

Referenced by init_pointers(), and SHFormatDateTimeA().

SHFreeShared()

BOOL WINAPI SHFreeShared	(	HANDLE	hShared,
		DWORD	dwProcId
	)

Definition at line 311 of file ordinal.c.

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

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

SHGetAppCompatFlags()

DWORD WINAPI SHGetAppCompatFlags

(

DWORD

dwUnknown

)

Definition at line 4449 of file ordinal.c.

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

SHGetCurColorRes()

DWORD WINAPI SHGetCurColorRes

(

void

)

Definition at line 2019 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().

SHGetFileInfoWrapW()

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

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

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

Referenced by init_pointers(), and SHPropertyBag_SHSetIniStringW().

SHGetInverseCMAP()

HRESULT WINAPI SHGetInverseCMAP	(	LPDWORD	dest,
		DWORD	dwSize
	)

Definition at line 4344 of file ordinal.c.

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

SHGetMachineInfo()

DWORD WINAPI SHGetMachineInfo

(

DWORD

dwFlags

)

Definition at line 3863 of file ordinal.c.

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

SHGetMenuFromID()

HMENU WINAPI SHGetMenuFromID	(	HMENU	hMenu,
		UINT	uID
	)

Definition at line 1993 of file ordinal.c.

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

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

SHGetNewLinkInfoWrapW()

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

Definition at line 3506 of file ordinal.c.

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

SHGetObjectCompatFlags()

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

Definition at line 6199 of file ordinal.c.

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

Referenced by init_pointers().

SHGetPathFromIDListWrapW()

BOOL WINAPI SHGetPathFromIDListWrapW	(	LPCITEMIDLIST	pidl,
		LPWSTR	pszPath
	)

Definition at line 3385 of file ordinal.c.

{
    return SHGetPathFromIDListW(pidl, pszPath);
}

Referenced by _ILIsNetworkPlace().

SHGetRestriction()

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

Definition at line 2696 of file ordinal.c.

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

Referenced by SHRestrictionLookup().

SHGetShellKey()

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

Definition at line 4506 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',