shlwapi_undoc.h File Reference

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

Go to the source code of this file.

Macros
#define	SHAboutInfo   SHAboutInfoA
#define	SHExpandEnvironmentStrings   SHExpandEnvironmentStringsA
#define	SHCreateWorkerWindow   SHCreateWorkerWindowA
#define	SHGetValueGoodBoot   SHGetValueGoodBootA

Functions
BOOL WINAPI	SHAboutInfoA (LPSTR lpszDest, DWORD dwDestLen)
BOOL WINAPI	SHAboutInfoW (LPWSTR 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 wMask, UINT wFlags)
HWND WINAPI	SHSetParentHwnd (HWND hWnd, HWND hWndParent)
HRESULT WINAPI	ConnectToConnectionPoint (IUnknown *lpUnkSink, REFIID riid, BOOL bAdviseOnly, IUnknown *lpUnknown, LPDWORD lpCookie, IConnectionPoint **lppCP)
BOOL WINAPI	SHIsSameObject (IUnknown *lpInt1, IUnknown *lpInt2)
BOOL WINAPI	SHLoadMenuPopup (HINSTANCE hInst, LPCWSTR szName)
void WINAPI	SHPropagateMessage (HWND hWnd, UINT uiMsgId, WPARAM wParam, LPARAM lParam, BOOL bSend)
DWORD WINAPI	SHRemoveAllSubMenus (HMENU hMenu)
UINT WINAPI	SHEnableMenuItem (HMENU hMenu, UINT wItemID, BOOL bEnable)
DWORD WINAPI	SHCheckMenuItem (HMENU hMenu, UINT uID, BOOL bCheck)
DWORD WINAPI	SHRegisterClassA (WNDCLASSA *wndclass)
BOOL WINAPI	SHSimulateDrop (IDropTarget *pDrop, IDataObject *pDataObj, DWORD grfKeyState, PPOINTL lpPt, DWORD *pdwEffect)
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)
HRESULT WINAPI	SHForwardContextMenuMsg (IUnknown *pUnk, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *pResult, BOOL useIContextMenu2)
HRESULT WINAPI	SHRegGetCLSIDKeyW (REFGUID guid, LPCWSTR lpszValue, BOOL bUseHKCU, BOOL bCreate, PHKEY phKey)
BOOL WINAPI	SHAddDataBlock (LPDBLIST *lppList, const DATABLOCK_HEADER *lpNewItem)
BOOL WINAPI	SHRemoveDataBlock (LPDBLIST *lppList, DWORD dwSignature)
DATABLOCK_HEADER *WINAPI	SHFindDataBlock (LPDBLIST lpList, DWORD dwSignature)
HRESULT WINAPI	SHWriteDataBlockList (IStream *lpStream, LPDBLIST lpList)
HRESULT WINAPI	SHReadDataBlockList (IStream *lpStream, LPDBLIST *lppList)
VOID WINAPI	SHFreeDataBlockList (LPDBLIST lpList)
DWORD WINAPI	SHExpandEnvironmentStringsA (LPCSTR, LPSTR, DWORD)
DWORD WINAPI	SHExpandEnvironmentStringsW (LPCWSTR, LPWSTR, DWORD)
BOOL WINAPI	SHIsEmptyStream (IStream *)
HRESULT WINAPI	SHInvokeDefaultCommand (HWND, IShellFolder *, LPCITEMIDLIST)
HRESULT WINAPI	SHPropertyBag_ReadPOINTL (IPropertyBag *, LPCWSTR, POINTL *)
HRESULT WINAPI	SHGetPerScreenResName (OUT LPWSTR lpResName, IN INT cchResName, IN DWORD dwReserved)
HRESULT WINAPI	SHPropertyBag_ReadStream (IPropertyBag *, LPCWSTR, IStream **)
HWND WINAPI	SHCreateWorkerWindowA (WNDPROC wndProc, HWND hWndParent, DWORD dwExStyle, DWORD dwStyle, HMENU hMenu, LONG_PTR wnd_extra)
HWND WINAPI	SHCreateWorkerWindowW (WNDPROC wndProc, HWND hWndParent, DWORD dwExStyle, DWORD dwStyle, HMENU hMenu, LONG_PTR wnd_extra)
HRESULT WINAPI	IUnknown_SetOwner (IUnknown *iface, IUnknown *pUnk)
HRESULT WINAPI	IUnknown_GetClassID (IUnknown *lpUnknown, CLSID *lpClassId)
HRESULT WINAPI	IUnknown_QueryServiceExec (IUnknown *lpUnknown, REFIID service, const GUID *group, DWORD cmdId, DWORD cmdOpt, VARIANT *pIn, VARIANT *pOut)
HRESULT WINAPI	IUnknown_UIActivateIO (IUnknown *unknown, BOOL activate, LPMSG msg)
HRESULT WINAPI	IUnknown_TranslateAcceleratorOCS (IUnknown *lpUnknown, LPMSG lpMsg, DWORD dwModifiers)
HRESULT WINAPI	IUnknown_OnFocusOCS (IUnknown *lpUnknown, BOOL fGotFocus)
HRESULT WINAPI	IUnknown_HandleIRestrict (LPUNKNOWN lpUnknown, PVOID lpArg1, PVOID lpArg2, PVOID lpArg3, PVOID lpArg4)
HRESULT WINAPI	IUnknown_HasFocusIO (IUnknown *punk)
HRESULT WINAPI	IUnknown_TranslateAcceleratorIO (IUnknown *punk, MSG *pmsg)
HRESULT WINAPI	IUnknown_OnFocusChangeIS (LPUNKNOWN lpUnknown, LPUNKNOWN pFocusObject, BOOL bFocus)
DWORD WINAPI	SHAnsiToUnicode (LPCSTR lpSrcStr, LPWSTR lpDstStr, INT iLen)
INT WINAPI	SHUnicodeToAnsi (LPCWSTR lpSrcStr, LPSTR lpDstStr, INT iLen)
DWORD WINAPI	SHAnsiToUnicodeCP (DWORD dwCp, LPCSTR lpSrcStr, LPWSTR lpDstStr, int iLen)
DWORD WINAPI	SHUnicodeToAnsiCP (UINT CodePage, LPCWSTR lpSrcStr, LPSTR lpDstStr, int dstlen)
PVOID WINAPI	SHLockSharedEx (HANDLE hData, DWORD dwProcessId, BOOL bWriteAccess)
DWORD WINAPI	SHGetValueGoodBootA (HKEY hkey, LPCSTR pSubKey, LPCSTR pValue, LPDWORD pwType, LPVOID pvData, LPDWORD pbData)
DWORD WINAPI	SHGetValueGoodBootW (HKEY hkey, LPCWSTR pSubKey, LPCWSTR pValue, LPDWORD pwType, LPVOID pvData, LPDWORD pbData)
int WINAPIV	ShellMessageBoxWrapW (_In_opt_ HINSTANCE hAppInst, _In_opt_ HWND hWnd, _In_ LPCWSTR lpcText, _In_opt_ LPCWSTR lpcTitle, _In_ UINT fuStyle,...)

Macro Definition Documentation

SHAboutInfo

#define SHAboutInfo   SHAboutInfoA

Definition at line 33 of file shlwapi_undoc.h.

SHCreateWorkerWindow

#define SHCreateWorkerWindow   SHCreateWorkerWindowA

Definition at line 110 of file shlwapi_undoc.h.

SHExpandEnvironmentStrings

#define SHExpandEnvironmentStrings   SHExpandEnvironmentStringsA

Definition at line 77 of file shlwapi_undoc.h.

SHGetValueGoodBoot

#define SHGetValueGoodBoot   SHGetValueGoodBootA

Definition at line 139 of file shlwapi_undoc.h.

Function Documentation

ConnectToConnectionPoint()

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

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

IsQSForward()

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

Definition at line 2228 of file ordinal.c.

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

IUnknown_Exec()

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

Definition at line 1080 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(), CMenuSite::Exec(), CBaseBar::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 *	lpClassId
	)

Definition at line 1450 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 CSearchBar::GetSearchResultsFolder(), init_pointers(), CSearchBar::Invoke(), and SHSkipJunction().

IUnknown_HandleIRestrict()

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

Definition at line 1946 of file ordinal.c.

{
  /* FIXME: {D12F26B2-D90A-11D0-830D-00AA005B4383} - What object does this represent? */
  static const DWORD service_id[] = { 0xd12f26b2, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
  /* FIXME: {D12F26B1-D90A-11D0-830D-00AA005B4383} - Also Unknown/undocumented */
  static const DWORD function_id[] = { 0xd12f26b1, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
  HRESULT hRet = E_INVALIDARG;
  LPUNKNOWN lpUnkInner = NULL; /* FIXME: Real type is unknown */

  TRACE("(%p,%p,%p,%p,%p)\n", lpUnknown, lpArg1, lpArg2, lpArg3, lpArg4);

  if (lpUnknown && lpArg4)
  {
     hRet = IUnknown_QueryService(lpUnknown, (REFGUID)service_id,
                                  (REFGUID)function_id, (void**)&lpUnkInner);

     if (SUCCEEDED(hRet) && lpUnkInner)
     {
       /* FIXME: The type of service object requested is unknown, however
    * testing shows that its first method is called with 4 parameters.
    * Fake this by using IParseDisplayName_ParseDisplayName since the
    * signature and position in the vtable matches our unknown object type.
    */
       hRet = IParseDisplayName_ParseDisplayName((LPPARSEDISPLAYNAME)lpUnkInner,
                                                 lpArg1, lpArg2, lpArg3, lpArg4);
       IUnknown_Release(lpUnkInner);
     }
  }
  return hRet;
}

IUnknown_HasFocusIO()

HRESULT WINAPI IUnknown_HasFocusIO

(

IUnknown *

punk

)

Definition at line 4182 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(), CBaseBar::HasFocusIO(), CInternetToolbar::HasFocusIO(), and CMenuDeskBar::HasFocusIO().

IUnknown_OnFocusChangeIS()

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

Definition at line 4652 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 CBaseBar::OnFocusChangeIS(), CBaseBarSite::OnFocusChangeIS(), CMenuDeskBar::OnFocusChangeIS(), CExplorerBand::OnKillFocus(), CSearchBar::OnSetFocus(), CExplorerBand::OnSetFocus(), and CAddressBand::UIActivateIO().

IUnknown_OnFocusOCS()

HRESULT WINAPI IUnknown_OnFocusOCS	(	IUnknown *	lpUnknown,
		BOOL	fGotFocus
	)

Definition at line 1924 of file ordinal.c.

{
  IOleControlSite* lpCSite = NULL;
  HRESULT hRet = E_FAIL;

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

IUnknown_QueryServiceExec()

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

Definition at line 1546 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_QueryStatus()

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

Definition at line 1041 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 2183 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 1378 of file ordinal.c.

{
  IShellService *service;
  HRESULT hr;

  TRACE("(%p, %p)\n", iface, pUnk);

  if (!iface) return E_FAIL;

  hr = IUnknown_QueryInterface(iface, &IID_IShellService, (void**)&service);
  if (hr == S_OK)
  {
    hr = IShellService_SetOwner(service, pUnk);
    IShellService_Release(service);
  }

  return hr;
}

Referenced by CTrayBandSite::AddContextMenus().

IUnknown_TranslateAcceleratorIO()

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

IUnknown_TranslateAcceleratorOCS()

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

Definition at line 1891 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 1626 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 CMenuSite::UIActivateIO(), CBaseBarSite::UIActivateIO(), CBaseBar::UIActivateIO(), and CMenuDeskBar::UIActivateIO().

MayExecForward()

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

Definition at line 2215 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 2200 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;
}

SHAboutInfoA()

BOOL WINAPI SHAboutInfoA	(	LPSTR	lpszDest,
		DWORD	dwDestLen
	)

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

{
  static const WCHAR szIEKey[] = { 'S','O','F','T','W','A','R','E','\\',
    'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
    ' ','E','x','p','l','o','r','e','r','\0' };
  static const WCHAR szWinNtKey[] = { 'S','O','F','T','W','A','R','E','\\',
    'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ',
    'N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
  static const WCHAR szWinKey[] = { 'S','O','F','T','W','A','R','E','\\',
    'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
    'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
  static const WCHAR szRegKey[] = { 'S','O','F','T','W','A','R','E','\\',
    'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
    ' ','E','x','p','l','o','r','e','r','\\',
    'R','e','g','i','s','t','r','a','t','i','o','n','\0' };
  static const WCHAR szVersion[] = { 'V','e','r','s','i','o','n','\0' };
  static const WCHAR szCustomized[] = { 'C','u','s','t','o','m','i','z','e','d',
    'V','e','r','s','i','o','n','\0' };
  static const WCHAR szOwner[] = { 'R','e','g','i','s','t','e','r','e','d',
    'O','w','n','e','r','\0' };
  static const WCHAR szOrg[] = { 'R','e','g','i','s','t','e','r','e','d',
    'O','r','g','a','n','i','z','a','t','i','o','n','\0' };
  static const WCHAR szProduct[] = { 'P','r','o','d','u','c','t','I','d','\0' };
  static const WCHAR szUpdate[] = { 'I','E','A','K',
    'U','p','d','a','t','e','U','r','l','\0' };
  static const WCHAR szHelp[] = { 'I','E','A','K',
    'H','e','l','p','S','t','r','i','n','g','\0' };
  WCHAR buff[2084];
  HKEY hReg;
  DWORD dwType, dwLen;

  TRACE("(%p,%d)\n", lpszDest, dwDestLen);

  if (!lpszDest)
    return FALSE;

  *lpszDest = '\0';

  /* Try the NT key first, followed by 95/98 key */
  if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szWinNtKey, 0, KEY_READ, &hReg) &&
      RegOpenKeyExW(HKEY_LOCAL_MACHINE, szWinKey, 0, KEY_READ, &hReg))
    return FALSE;

  /* OS Version */
  buff[0] = '\0';
  dwLen = 30;
  if (!SHGetValueW(HKEY_LOCAL_MACHINE, szIEKey, szVersion, &dwType, buff, &dwLen))
  {
    DWORD dwStrLen = strlenW(buff);
    dwLen = 30 - dwStrLen;
    SHGetValueW(HKEY_LOCAL_MACHINE, szIEKey,
                szCustomized, &dwType, buff+dwStrLen, &dwLen);
  }
  StrCatBuffW(lpszDest, buff, dwDestLen);

  /* ~Registered Owner */
  buff[0] = '~';
  dwLen = 256;
  if (SHGetValueW(hReg, szOwner, 0, &dwType, buff+1, &dwLen))
    buff[1] = '\0';
  StrCatBuffW(lpszDest, buff, dwDestLen);

  /* ~Registered Organization */
  dwLen = 256;
  if (SHGetValueW(hReg, szOrg, 0, &dwType, buff+1, &dwLen))
    buff[1] = '\0';
  StrCatBuffW(lpszDest, buff, dwDestLen);

  /* FIXME: Not sure where this number comes from  */
  buff[0] = '~';
  buff[1] = '0';
  buff[2] = '\0';
  StrCatBuffW(lpszDest, buff, dwDestLen);

  /* ~Product Id */
  dwLen = 256;
  if (SHGetValueW(HKEY_LOCAL_MACHINE, szRegKey, szProduct, &dwType, buff+1, &dwLen))
    buff[1] = '\0';
  StrCatBuffW(lpszDest, buff, dwDestLen);

  /* ~IE Update Url */
  dwLen = 2048;
  if(SHGetValueW(HKEY_LOCAL_MACHINE, szWinKey, szUpdate, &dwType, buff+1, &dwLen))
    buff[1] = '\0';
  StrCatBuffW(lpszDest, buff, dwDestLen);

  /* ~IE Help String */
  dwLen = 256;
  if(SHGetValueW(hReg, szHelp, 0, &dwType, buff+1, &dwLen))
    buff[1] = '\0';
  StrCatBuffW(lpszDest, buff, dwDestLen);

  RegCloseKey(hReg);
  return TRUE;
}

Referenced by SHAboutInfoA().

SHAddDataBlock()

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

Definition at line 68 of file clist.c.

{
  LPDATABLOCK_HEADER lpInsertAt = NULL;
  ULONG ulSize;

  TRACE("(%p,%p)\n", lppList, lpNewItem);

  if(!lppList || !lpNewItem)
    return FALSE;

  if (lpNewItem->cbSize < sizeof(DATABLOCK_HEADER) ||
      lpNewItem->dwSignature == CLIST_ID_CONTAINER)
    return FALSE;

  ulSize = lpNewItem->cbSize;

  if(ulSize & 0x3)
  {
    /* Tune size to a ULONG boundary, add space for container element */
    ulSize = ((ulSize + 0x3) & 0xFFFFFFFC) + sizeof(DATABLOCK_HEADER);
    TRACE("Creating container item, new size = %d\n", ulSize);
  }

  if(!*lppList)
  {
    /* An empty list. Allocate space for terminal ulSize also */
    *lppList = LocalAlloc(LMEM_ZEROINIT, ulSize + sizeof(ULONG));
    lpInsertAt = *lppList;
  }
  else
  {
    /* Append to the end of the list */
    ULONG ulTotalSize = 0;
    LPDATABLOCK_HEADER lpIter = *lppList;

    /* Iterate to the end of the list, calculating the total size */
    while (lpIter->cbSize)
    {
      ulTotalSize += lpIter->cbSize;
      lpIter = NextItem(lpIter);
    }

    /* Increase the size of the list */
    lpIter = LocalReAlloc(*lppList, ulTotalSize + ulSize+sizeof(ULONG),
                                          LMEM_ZEROINIT | LMEM_MOVEABLE);
    if(lpIter)
    {
      *lppList = lpIter;
      lpInsertAt = (LPDATABLOCK_HEADER)((char*)lpIter + ulTotalSize); /* At end */
    }
  }

  if(lpInsertAt)
  {
    /* Copy in the new item */
    LPDATABLOCK_HEADER lpDest = lpInsertAt;

    if(ulSize != lpNewItem->cbSize)
    {
      lpInsertAt->cbSize = ulSize;
      lpInsertAt->dwSignature = CLIST_ID_CONTAINER;
      lpDest++;
    }
    memcpy(lpDest, lpNewItem, lpNewItem->cbSize);

    /* Terminate the list */
    lpInsertAt = NextItem(lpInsertAt);
    lpInsertAt->cbSize = 0;

    return TRUE;
  }
  return FALSE;
}

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

SHAnsiToUnicode()

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

SHAnsiToUnicodeCP()

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

Definition at line 2634 of file string.c.

{
  DWORD dwRet;

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

Referenced by SHAnsiToUnicode().

SHCheckMenuItem()

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

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

SHCreateWorkerWindowA()

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

Definition at line 2630 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 2918 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(), and CUserNotification::Show().

ShellMessageBoxWrapW()

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

SHEnableMenuItem()

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

Definition at line 1774 of file ordinal.c.

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

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

SHExpandEnvironmentStringsA()

DWORD WINAPI SHExpandEnvironmentStringsA	(	LPCSTR	,
		LPSTR	,
		DWORD
	)

SHExpandEnvironmentStringsW()

DWORD WINAPI SHExpandEnvironmentStringsW	(	LPCWSTR	,
		LPWSTR	,
		DWORD
	)

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

SHFillRectClr()

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

Definition at line 2126 of file ordinal.c.

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

SHFindDataBlock()

DATABLOCK_HEADER* WINAPI SHFindDataBlock	(	LPDBLIST	lpList,
		DWORD	dwSignature
	)

Definition at line 424 of file clist.c.

{
  TRACE("(%p,%d)\n", lpList, dwSignature);

  if(lpList)
  {
    while(lpList->cbSize)
    {
      if(lpList->dwSignature == dwSignature)
        return lpList; /* Matched */
      else if(lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature)
        return lpList + 1; /* Contained item matches */

      lpList = NextItem(lpList);
    }
  }
  return NULL;
}

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

SHForwardContextMenuMsg()

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

Definition at line 11 of file rosordinal.c.

{
    HRESULT hr;
    IContextMenu3* pcmenu3;
    IContextMenu2* pcmenu2;

    /* First try to use the IContextMenu3 interface */
    hr = IUnknown_QueryInterface(pUnk, &IID_IContextMenu3, (void**)&pcmenu3);
    if (SUCCEEDED(hr))
    {
        hr = IContextMenu3_HandleMenuMsg2(pcmenu3, uMsg, wParam, lParam, pResult);
        IContextMenu3_Release(pcmenu3);
        return hr;
    }

    /* Return failure if we can't use the IContextMenu2 interface */
    if(!useIContextMenu2)
        return hr;

    /* Now try to use the IContextMenu2 interface */
    hr = IUnknown_QueryInterface(pUnk, &IID_IContextMenu2, (void**)&pcmenu2);
    if (FAILED(hr))
        return hr;

    hr = IContextMenu2_HandleMenuMsg(pcmenu2, uMsg, wParam, lParam);
    IContextMenu2_Release(pcmenu2);
    return hr;
}

Referenced by CDefaultContextMenu::HandleMenuMsg2(), and CDefView::OnCustomItem().

SHFreeDataBlockList()

VOID WINAPI SHFreeDataBlockList

(

LPDBLIST

lpList

)

Definition at line 331 of file clist.c.

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

  if (lpList)
    LocalFree(lpList);
}

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

SHGetCurColorRes()

DWORD WINAPI SHGetCurColorRes

(

void

)

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

SHGetMenuFromID()

HMENU WINAPI SHGetMenuFromID	(	HMENU	hMenu,
		UINT	uID
	)

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

SHGetPerScreenResName()

HRESULT WINAPI SHGetPerScreenResName	(	OUT LPWSTR	lpResName,
		IN INT	cchResName,
		IN DWORD	dwReserved
	)

SHGetValueGoodBootA()

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

Definition at line 1877 of file reg.c.

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

SHGetValueGoodBootW()

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

Definition at line 1890 of file reg.c.

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

SHInvokeDefaultCommand()

HRESULT WINAPI SHInvokeDefaultCommand	(	HWND	,
		IShellFolder *	,
		LPCITEMIDLIST
	)

Definition at line 2974 of file ordinal.c.

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

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

SHIsChildOrSelf()

BOOL WINAPI SHIsChildOrSelf	(	HWND	hParent,
		HWND	hChild
	)

Definition at line 2247 of file ordinal.c.

{
  TRACE("(%p,%p)\n", hParent, hChild);

  if (!hParent || !hChild)
    return TRUE;
  else if(hParent == hChild)
    return FALSE;
  return !IsChild(hParent, hChild);
}

SHIsEmptyStream()

BOOL WINAPI SHIsEmptyStream

(

IStream *

)

Definition at line 567 of file istream.c.

{
  STATSTG statstg;
  BOOL bRet = TRUE;

  TRACE("(%p)\n", lpStream);

  memset(&statstg, 0, sizeof(statstg));

  if(SUCCEEDED(IStream_Stat(lpStream, &statstg, 1)))
  {
    if(statstg.cbSize.QuadPart)
      bRet = FALSE; /* Non-Zero */
  }
  else
  {
    DWORD dwDummy;

    /* Try to read from the stream */
    if(SUCCEEDED(SHIStream_Read(lpStream, &dwDummy, sizeof(dwDummy))))
    {
      LARGE_INTEGER zero;
      zero.QuadPart = 0;

      IStream_Seek(lpStream, zero, 0, NULL);
      bRet = FALSE; /* Non-Zero */
    }
  }
  return bRet;
}

SHIsExpandableFolder()

HRESULT WINAPI SHIsExpandableFolder	(	LPSHELLFOLDER	lpFolder,
		LPCITEMIDLIST	pidl
	)

Definition at line 2081 of file ordinal.c.

{
  HRESULT hRet = E_INVALIDARG;
  IQueryInfo *lpInfo;

  if (lpFolder && pidl)
  {
    hRet = IShellFolder_GetUIObjectOf(lpFolder, NULL, 1, &pidl, &IID_IQueryInfo,
                                      NULL, (void**)&lpInfo);
    if (FAILED(hRet))
      hRet = S_FALSE; /* Doesn't expose IQueryInfo */
    else
    {
      DWORD dwFlags = 0;

      /* MSDN states of IQueryInfo_GetInfoFlags() that "This method is not
       * currently used". Really? You wouldn't be holding out on me would you?
       */
      hRet = IQueryInfo_GetInfoFlags(lpInfo, &dwFlags);

      if (SUCCEEDED(hRet))
      {
        /* 0x2 is an undocumented flag apparently indicating expandability */
        hRet = dwFlags & 0x2 ? S_OK : S_FALSE;
      }

      IQueryInfo_Release(lpInfo);
    }
  }
  return hRet;
}

SHIsSameObject()

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

Definition at line 1282 of file ordinal.c.

{
  IUnknown *lpUnknown1, *lpUnknown2;
  BOOL ret;

  TRACE("(%p %p)\n", lpInt1, lpInt2);

  if (!lpInt1 || !lpInt2)
    return FALSE;

  if (lpInt1 == lpInt2)
    return TRUE;

  if (IUnknown_QueryInterface(lpInt1, &IID_IUnknown, (void**)&lpUnknown1) != S_OK)
    return FALSE;

  if (IUnknown_QueryInterface(lpInt2, &IID_IUnknown, (void**)&lpUnknown2) != S_OK)
  {
    IUnknown_Release(lpUnknown1);
    return FALSE;
  }

  ret = lpUnknown1 == lpUnknown2;

  IUnknown_Release(lpUnknown1);
  IUnknown_Release(lpUnknown2);

  return ret;
}

SHLoadMenuPopup()

BOOL WINAPI SHLoadMenuPopup	(	HINSTANCE	hInst,
		LPCWSTR	szName
	)

Definition at line 1659 of file ordinal.c.

{
  HMENU hMenu;

  TRACE("%p %s\n", hInst, debugstr_w(szName));

  if ((hMenu = LoadMenuW(hInst, szName)))
  {
    if (GetSubMenu(hMenu, 0))
      RemoveMenu(hMenu, 0, MF_BYPOSITION);

    DestroyMenu(hMenu);
    return TRUE;
  }
  return FALSE;
}

SHLockSharedEx()

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

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

SHPropagateMessage()

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

Definition at line 1712 of file ordinal.c.

{
  enumWndData data;

  TRACE("(%p,%u,%ld,%ld,%d)\n", hWnd, uiMsgId, wParam, lParam, bSend);

  if(hWnd)
  {
    data.uiMsgId = uiMsgId;
    data.wParam  = wParam;
    data.lParam  = lParam;

    if (bSend)
      data.pfnPost = IsWindowUnicode(hWnd) ? (void*)SendMessageW : (void*)SendMessageA;
    else
      data.pfnPost = IsWindowUnicode(hWnd) ? (void*)PostMessageW : (void*)PostMessageA;

    EnumChildWindows(hWnd, SHLWAPI_EnumChildProc, (LPARAM)&data);
  }
}

Referenced by CShellBrowser::OnSettingChange().

SHPropertyBag_ReadPOINTL()

HRESULT WINAPI SHPropertyBag_ReadPOINTL	(	IPropertyBag *	,
		LPCWSTR	,
		POINTL *
	)

SHPropertyBag_ReadStream()

HRESULT WINAPI SHPropertyBag_ReadStream	(	IPropertyBag *	,
		LPCWSTR	,
		IStream **
	)

SHReadDataBlockList()

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

Definition at line 235 of file clist.c.

{
  DATABLOCK_HEADER bBuff[128]; /* Temporary storage for new list item */
  ULONG ulBuffSize = sizeof(bBuff);
  LPDATABLOCK_HEADER pItem = bBuff;
  ULONG ulRead, ulSize;
  HRESULT hRet = S_OK;

  TRACE("(%p,%p)\n", lpStream, lppList);

  if(*lppList)
  {
    /* Free any existing list */
    LocalFree(*lppList);
    *lppList = NULL;
  }

  do
  {
    /* Read the size of the next item */
    hRet = IStream_Read(lpStream, &ulSize,sizeof(ulSize),&ulRead);

    if(FAILED(hRet) || ulRead != sizeof(ulSize) || !ulSize)
      break; /* Read failed or read zero size (the end of the list) */

    if(ulSize > 0xFFFF)
    {
      LARGE_INTEGER liZero;
      ULARGE_INTEGER ulPos;

      liZero.QuadPart = 0;

      /* Back the stream up; this object is too big for the list */
      if(SUCCEEDED(IStream_Seek(lpStream, liZero, STREAM_SEEK_CUR, &ulPos)))
      {
        liZero.QuadPart = ulPos.QuadPart - sizeof(ULONG);
        IStream_Seek(lpStream, liZero, STREAM_SEEK_SET, NULL);
      }
      break;
    }
    else if (ulSize >= sizeof(DATABLOCK_HEADER))
    {
      /* Add this new item to the list */
      if(ulSize > ulBuffSize)
      {
        /* We need more buffer space, allocate it */
        LPDATABLOCK_HEADER lpTemp;

        if (pItem == bBuff)
          lpTemp = LocalAlloc(LMEM_ZEROINIT, ulSize);
        else
          lpTemp = LocalReAlloc(pItem, ulSize, LMEM_ZEROINIT|LMEM_MOVEABLE);

        if(!lpTemp)
        {
          hRet = E_OUTOFMEMORY;
          break;
        }
        ulBuffSize = ulSize;
        pItem = lpTemp;
      }

      pItem->cbSize = ulSize;
      ulSize -= sizeof(pItem->cbSize); /* already read this member */

      /* Read the item Id and data */
      hRet = IStream_Read(lpStream, &pItem->dwSignature, ulSize, &ulRead);

      if(FAILED(hRet) || ulRead != ulSize)
        break;

      SHAddDataBlock(lppList, pItem); /* Insert Item */
    }
  } while(1);

  /* If we allocated space, free it */
  if(pItem != bBuff)
    LocalFree(pItem);

  return hRet;
}

Referenced by CShellLink::Load().

SHRegGetCLSIDKeyW()

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

Definition at line 2422 of file reg.c.

{
#ifndef __REACTOS__
  static const WCHAR szClassIdKey[] = { 'S','o','f','t','w','a','r','e','\\',
    'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
    'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
    'E','x','p','l','o','r','e','r','\\','C','L','S','I','D','\\' };
#endif
#define szClassIdKeyLen (sizeof(szClassIdKey)/sizeof(WCHAR))
  WCHAR szKey[MAX_PATH];
  DWORD dwRet;
  HKEY hkey;

  /* Create the key string */
#ifdef __REACTOS__
  // https://www.geoffchappell.com/studies/windows/shell/shlwapi/api/reg/reggetclsidkey.htm
  WCHAR* ptr;

  wcscpy(szKey, bUseHKCU ? L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CLSID\\" : L"CLSID\\");
  ptr = szKey + wcslen(szKey);
  SHStringFromGUIDW(guid, ptr, 39); /* Append guid */
  if (lpszValue)
  {
      ptr = szKey + wcslen(szKey);
      wcscat(ptr, L"\\");
      wcscat(++ptr, lpszValue);
  }
#else
  memcpy(szKey, szClassIdKey, sizeof(szClassIdKey));
  SHStringFromGUIDW(guid, szKey + szClassIdKeyLen, 39); /* Append guid */

  if(lpszValue)
  {
    szKey[szClassIdKeyLen + 39] = '\\';
    strcpyW(szKey + szClassIdKeyLen + 40, lpszValue); /* Append value name */
  }
#endif

  hkey = bUseHKCU ? HKEY_CURRENT_USER : HKEY_CLASSES_ROOT;

  if(bCreate)
    dwRet = RegCreateKeyW(hkey, szKey, phKey);
  else
    dwRet = RegOpenKeyExW(hkey, szKey, 0, KEY_READ, phKey);

  return dwRet ? HRESULT_FROM_WIN32(dwRet) : S_OK;
}

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

SHRegisterClassA()

DWORD WINAPI SHRegisterClassA

(

WNDCLASSA *

wndclass

)

Definition at line 1810 of file ordinal.c.

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

Referenced by SHCreateWorkerWindowA().

SHRemoveAllSubMenus()

DWORD WINAPI SHRemoveAllSubMenus

(

HMENU

hMenu

)

Definition at line 1745 of file ordinal.c.

{
  int iItemCount = GetMenuItemCount(hMenu) - 1;

  TRACE("%p\n", hMenu);

  while (iItemCount >= 0)
  {
    HMENU hSubMenu = GetSubMenu(hMenu, iItemCount);
    if (hSubMenu)
      RemoveMenu(hMenu, iItemCount, MF_BYPOSITION);
    iItemCount--;
  }
  return iItemCount;
}

SHRemoveDataBlock()

BOOL WINAPI SHRemoveDataBlock	(	LPDBLIST *	lppList,
		DWORD	dwSignature
	)

Definition at line 355 of file clist.c.

{
  LPDATABLOCK_HEADER lpList = NULL;
  LPDATABLOCK_HEADER lpItem = NULL;
  LPDATABLOCK_HEADER lpNext;
  ULONG ulNewSize;

  TRACE("(%p,%d)\n", lppList, dwSignature);

  if(lppList && (lpList = *lppList))
  {
    /* Search for item in list */
    while (lpList->cbSize)
    {
      if(lpList->dwSignature == dwSignature ||
        (lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature))
      {
        lpItem = lpList; /* Found */
        break;
      }
      lpList = NextItem(lpList);
    }
  }

  if(!lpItem)
    return FALSE;

  lpList = lpNext = NextItem(lpItem);

  /* Locate the end of the list */
  while (lpList->cbSize)
    lpList = NextItem(lpList);

  /* Resize the list */
  ulNewSize = LocalSize(*lppList) - lpItem->cbSize;

  /* Copy following elements over lpItem */
  memmove(lpItem, lpNext, (char *)lpList - (char *)lpNext + sizeof(ULONG));

  if(ulNewSize <= sizeof(ULONG))
  {
    LocalFree(*lppList);
    *lppList = NULL; /* Removed the last element */
  }
  else
  {
    lpList = LocalReAlloc(*lppList, ulNewSize, LMEM_ZEROINIT|LMEM_MOVEABLE);
    if(lpList)
      *lppList = lpList;
  }
  return TRUE;
}

Referenced by CShellLink::RemoveDataBlock().

SHSearchMapInt()

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

Definition at line 2154 of file ordinal.c.

{
  if (lpKeys && lpValues)
  {
    int i = 0;

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

Referenced by init_pointers().

SHSetParentHwnd()

HWND WINAPI SHSetParentHwnd	(	HWND	hWnd,
		HWND	hWndParent
	)

Definition at line 1151 of file ordinal.c.

{
  TRACE("%p, %p\n", hWnd, hWndParent);

  if(GetParent(hWnd) == hWndParent)
    return NULL;

  if(hWndParent)
    SHSetWindowBits(hWnd, GWL_STYLE, WS_CHILD | WS_POPUP, WS_CHILD);
  else
    SHSetWindowBits(hWnd, GWL_STYLE, WS_CHILD | WS_POPUP, WS_POPUP);

  return hWndParent ? SetParent(hWnd, hWndParent) : NULL;
}

Referenced by init_pointers().

SHSetWindowBits()

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

Definition at line 1123 of file ordinal.c.

{
  LONG ret = GetWindowLongW(hwnd, offset);
  LONG new_flags = (flags & mask) | (ret & ~mask);

  TRACE("%p %d %x %x\n", hwnd, offset, mask, flags);

  if (new_flags != ret)
    ret = SetWindowLongW(hwnd, offset, new_flags);
  return ret;
}

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

SHSimulateDrop()

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

Definition at line 1821 of file ordinal.c.

{
  DWORD dwEffect = DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY;
  POINTL pt = { 0, 0 };

  TRACE("%p %p 0x%08x %p %p\n", pDrop, pDataObj, grfKeyState, lpPt, pdwEffect);

  if (!lpPt)
    lpPt = &pt;

  if (!pdwEffect)
    pdwEffect = &dwEffect;

  IDropTarget_DragEnter(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);

  if (*pdwEffect != DROPEFFECT_NONE)
    return IDropTarget_Drop(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);

  IDropTarget_DragLeave(pDrop);
  return TRUE;
}

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

SHUnicodeToAnsi()

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

Definition at line 2783 of file string.c.

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

Referenced by CheckEscapesA(), DoesStringRoundTripW(), CDefaultContextMenu::GetCommandString(), and MakeShellURLFromPathA().

SHUnicodeToAnsiCP()

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

Definition at line 2684 of file string.c.

{
  static const WCHAR emptyW[] = { '\0' };
  int len , reqLen;
  LPSTR mem;

  if (!lpDstStr || !dstlen)
    return 0;

  if (!lpSrcStr)
    lpSrcStr = emptyW;

  *lpDstStr = '\0';

  len = strlenW(lpSrcStr) + 1;

  switch (CodePage)
  {
  case CP_WINUNICODE:
    CodePage = CP_UTF8; /* Fall through... */
  case 0x0000C350: /* FIXME: CP_ #define */
  case CP_UTF7:
  case CP_UTF8:
    {
      DWORD dwMode = 0;
      INT lenW = len - 1;
      INT needed = dstlen - 1;
      HRESULT hr;

      /* try the user supplied buffer first */
      hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &lenW, lpDstStr, &needed);
      if (hr == S_OK)
      {
        lpDstStr[needed] = '\0';
        return needed + 1;
      }

      /* user buffer too small. exclude termination and copy as much as possible */
      lenW = len;
      hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &lenW, NULL, &needed);
      needed++;
      mem = HeapAlloc(GetProcessHeap(), 0, needed);
      if (!mem)
        return 0;

      hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &len, mem, &needed);
      if (hr == S_OK)
      {
          reqLen = SHTruncateString(mem, dstlen);
          if (reqLen > 0) memcpy(lpDstStr, mem, reqLen-1);
      }
      HeapFree(GetProcessHeap(), 0, mem);
      return 0;
    }
  default:
    break;
  }

  /* try the user supplied buffer first */
  reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, lpDstStr, dstlen, NULL, NULL);

  if (!reqLen && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
  {
    reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, NULL, 0, NULL, NULL);
    if (reqLen)
    {
      mem = HeapAlloc(GetProcessHeap(), 0, reqLen);
      if (mem)
      {
        WideCharToMultiByte(CodePage, 0, lpSrcStr, len, mem, reqLen, NULL, NULL);

        reqLen = SHTruncateString(mem, dstlen -1);
        reqLen++;

        lstrcpynA(lpDstStr, mem, reqLen);
        HeapFree(GetProcessHeap(), 0, mem);
        lpDstStr[reqLen-1] = '\0';
      }
    }
  }
  return reqLen;
}

Referenced by SHUnicodeToAnsi().

SHWaitForSendMessageThread()

DWORD WINAPI SHWaitForSendMessageThread	(	HANDLE	hand,
		DWORD	dwTimeout
	)

Definition at line 2043 of file ordinal.c.

{
  DWORD dwEndTicks = GetTickCount() + dwTimeout;
  DWORD dwRet;

  while ((dwRet = MsgWaitForMultipleObjectsEx(1, &hand, dwTimeout, QS_SENDMESSAGE, 0)) == 1)
  {
    MSG msg;

    PeekMessageW(&msg, NULL, 0, 0, PM_NOREMOVE);

    if (dwTimeout != INFINITE)
    {
        if ((int)(dwTimeout = dwEndTicks - GetTickCount()) <= 0)
            return WAIT_TIMEOUT;
    }
  }

  return dwRet;
}

SHWriteDataBlockList()

HRESULT WINAPI SHWriteDataBlockList	(	IStream *	lpStream,
		LPDBLIST	lpList
	)

Definition at line 179 of file clist.c.

{
  ULONG ulSize;
  HRESULT hRet = S_OK;

  TRACE("(%p,%p)\n", lpStream, lpList);

  if(lpList)
  {
    while (lpList->cbSize)
    {
      LPDATABLOCK_HEADER lpItem = lpList;

      if(lpList->dwSignature == CLIST_ID_CONTAINER)
        lpItem++;

      hRet = IStream_Write(lpStream,lpItem,lpItem->cbSize,&ulSize);
      if (FAILED(hRet))
        return hRet;

      if(lpItem->cbSize != ulSize)
        return STG_E_MEDIUMFULL;

      lpList = NextItem(lpList);
    }
  }

  if(SUCCEEDED(hRet))
  {
    ULONG ulDummy;
    ulSize = 0;

    /* Write a terminating list entry with zero size */
    hRet = IStream_Write(lpStream, &ulSize,sizeof(ulSize),&ulDummy);
  }

  return hRet;
}

Referenced by CShellLink::Save().