utils.cpp File Reference

#include "precomp.h"
#include <shellapi.h>
#include <shlwapi.h>
#include <shlobj_undoc.h>
#include <shlguid_undoc.h>
#include <atlstr.h>
#include <shlwapi_undoc.h>
#include <ishellfolder_helpers.h>
#include <strsafe.h>

Include dependency graph for utils.cpp:

Go to the source code of this file.

Classes
struct	RETRY_DATA

Macros
#define	_ATL_NO_EXCEPTIONS
#define	IShellFolder_GetDisplayNameOf   _disabled_IShellFolder_GetDisplayNameOf_
#define	IShellFolder_ParseDisplayName   _disabled_IShellFolder_ParseDisplayName_
#define	IShellFolder_CompareIDs   _disabled_IShellFolder_CompareIDs_
#define	FAILED_UNEXPECTEDLY   FAILED /* FIXME: Make shellutils.h usable without ATL */

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
static WORD	GetVersionMajorMinor ()
static HRESULT	SHInvokeCommandOnContextMenuInternal (_In_opt_ HWND hWnd, _In_opt_ IUnknown *pUnk, _In_ IContextMenu *pCM, _In_ UINT fCMIC, _In_ UINT fCMF, _In_opt_ LPCSTR pszVerb, _In_opt_ LPCWSTR pwszDir, _In_ bool ForceQCM)
EXTERN_C HRESULT WINAPI	SHInvokeCommandOnContextMenuEx (_In_opt_ HWND hWnd, _In_opt_ IUnknown *pUnk, _In_ IContextMenu *pCM, _In_ UINT fCMIC, _In_ UINT fCMF, _In_opt_ LPCSTR pszVerb, _In_opt_ LPCWSTR pwszDir)
EXTERN_C HRESULT WINAPI	SHInvokeCommandOnContextMenu (_In_opt_ HWND hWnd, _In_opt_ IUnknown *pUnk, _In_ IContextMenu *pCM, _In_ UINT fCMIC, _In_opt_ LPCSTR pszVerb)
EXTERN_C HRESULT WINAPI	SHInvokeCommandWithFlagsAndSite (_In_opt_ HWND hWnd, _In_opt_ IUnknown *pUnk, _In_ IShellFolder *pShellFolder, _In_ LPCITEMIDLIST pidl, _In_ UINT fCMIC, _In_opt_ LPCSTR pszVerb)
EXTERN_C BOOL WINAPI	IContextMenu_Invoke (_In_ IContextMenu *pContextMenu, _In_ HWND hwnd, _In_ LPCSTR lpVerb, _In_ UINT uFlags)
BOOL WINAPI	PathFileExistsDefExtAndAttributesW (_Inout_ LPWSTR pszPath, _In_ DWORD dwWhich, _Out_opt_ LPDWORD pdwFileAttributes)
static BOOL	SHLWAPI_IsBogusHRESULT (HRESULT hr)
EXTERN_C HRESULT WINAPI	IShellFolder_GetDisplayNameOf (_In_ IShellFolder *psf, _In_ LPCITEMIDLIST pidl, _In_ SHGDNF uFlags, _Out_ LPSTRRET lpName, _In_ DWORD dwRetryFlags)
EXTERN_C HRESULT WINAPI	IShellFolder_ParseDisplayName (_In_ IShellFolder *psf, _In_opt_ HWND hwndOwner, _In_opt_ LPBC pbcReserved, _In_ LPOLESTR lpszDisplayName, _Out_opt_ ULONG *pchEaten, _Out_opt_ PIDLIST_RELATIVE *ppidl, _Out_opt_ ULONG *pdwAttributes)
EXTERN_C HRESULT WINAPI	IShellFolder_CompareIDs (_In_ IShellFolder *psf, _In_ LPARAM lParam, _In_ PCUIDLIST_RELATIVE pidl1, _In_ PCUIDLIST_RELATIVE pidl2)

Variables
static const RETRY_DATA	g_RetryData []

Macro Definition Documentation

_ATL_NO_EXCEPTIONS

#define _ATL_NO_EXCEPTIONS

Definition at line 8 of file utils.cpp.

FAILED_UNEXPECTEDLY

#define FAILED_UNEXPECTEDLY   FAILED /* FIXME: Make shellutils.h usable without ATL */

Definition at line 30 of file utils.cpp.

IShellFolder_CompareIDs

#define IShellFolder_CompareIDs   _disabled_IShellFolder_CompareIDs_

Definition at line 15 of file utils.cpp.

IShellFolder_GetDisplayNameOf

#define IShellFolder_GetDisplayNameOf   _disabled_IShellFolder_GetDisplayNameOf_

Definition at line 13 of file utils.cpp.

IShellFolder_ParseDisplayName

#define IShellFolder_ParseDisplayName   _disabled_IShellFolder_ParseDisplayName_

Definition at line 14 of file utils.cpp.

Function Documentation

GetVersionMajorMinor()

static WORD GetVersionMajorMinor ( )

inlinestatic

Definition at line 36 of file utils.cpp.

{
    DWORD version = GetVersion();
    return MAKEWORD(HIBYTE(version), LOBYTE(version));
}

Referenced by SHInvokeCommandOnContextMenuInternal().

IContextMenu_Invoke()

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

Definition at line 194 of file utils.cpp.

{
    TRACE("(%p, %p, %s, %u)\n", pContextMenu, hwnd, debugstr_a(lpVerb), uFlags);
    HRESULT hr = SHInvokeCommandOnContextMenuInternal(hwnd, NULL, pContextMenu, 0,
                                                      uFlags, lpVerb, NULL, false);
    return !FAILED_UNEXPECTEDLY(hr);
}

IShellFolder_CompareIDs()

EXTERN_C HRESULT WINAPI IShellFolder_CompareIDs	(	_In_ IShellFolder *	psf,
		_In_ LPARAM	lParam,
		_In_ PCUIDLIST_RELATIVE	pidl1,
		_In_ PCUIDLIST_RELATIVE	pidl2
	)

Definition at line 362 of file utils.cpp.

{
    TRACE("(%p, %p, %p, %p)\n", psf, lParam, pidl1, pidl2);
 
    if (lParam & ~(SIZE_T)SHCIDS_COLUMNMASK)
    {
        /* Try as IShellFolder2 if possible */
        HRESULT hr = psf->QueryInterface(IID_IShellFolder2, (void **)&psf);
        if (FAILED(hr))
            lParam &= SHCIDS_COLUMNMASK;
        else
            psf->Release();
    }
 
    return psf->CompareIDs(lParam, pidl1, pidl2);
}

IShellFolder_GetDisplayNameOf()

EXTERN_C HRESULT WINAPI IShellFolder_GetDisplayNameOf	(	_In_ IShellFolder *	psf,
		_In_ LPCITEMIDLIST	pidl,
		_In_ SHGDNF	uFlags,
		_Out_ LPSTRRET	lpName,
		_In_ DWORD	dwRetryFlags
	)

Definition at line 274 of file utils.cpp.

{
    HRESULT hr;
 
    TRACE("(%p)->(%p, 0x%lX, %p, 0x%lX)\n", psf, pidl, uFlags, lpName, dwRetryFlags);
 
    hr = psf->GetDisplayNameOf(pidl, uFlags, lpName);
    if (!SHLWAPI_IsBogusHRESULT(hr))
        return hr;
 
    dwRetryFlags |= SFGDNO_RETRYALWAYS;
 
    if ((uFlags & SHGDN_FORPARSING) == 0)
        dwRetryFlags |= SFGDNO_RETRYWITHFORPARSING;
 
    // Retry with other flags to get successful results
    for (SIZE_T iEntry = 0; iEntry < _countof(g_RetryData); ++iEntry)
    {
        const RETRY_DATA *pData = &g_RetryData[iEntry];
        if (!(dwRetryFlags & pData->dwRetryFlags))
            continue;
 
        SHGDNF uNewFlags = ((uFlags & ~pData->uRemove) | pData->uAdd);
        if (uNewFlags == uFlags)
            continue;
 
        hr = psf->GetDisplayNameOf(pidl, uNewFlags, lpName);
        if (!SHLWAPI_IsBogusHRESULT(hr))
            break;
 
        uFlags = uNewFlags; // Update flags every time
    }
 
    return hr;
}

IShellFolder_ParseDisplayName()

EXTERN_C HRESULT WINAPI IShellFolder_ParseDisplayName	(	_In_ IShellFolder *	psf,
		_In_opt_ HWND	hwndOwner,
		_In_opt_ LPBC	pbcReserved,
		_In_ LPOLESTR	lpszDisplayName,
		_Out_opt_ ULONG *	pchEaten,
		_Out_opt_ PIDLIST_RELATIVE *	ppidl,
		_Out_opt_ ULONG *	pdwAttributes
	)

Definition at line 322 of file utils.cpp.

{
    ULONG dummy1, dummy2;
 
    TRACE("(%p)->(%p, %p, %s, %p, %p, %p)\n", psf, hwndOwner, pbcReserved,
          debugstr_w(lpszDisplayName), pchEaten, ppidl, pdwAttributes);
 
    if (!pdwAttributes)
    {
        dummy1 = 0;
        pdwAttributes = &dummy1;
    }
 
    if (!pchEaten)
    {
        dummy2 = 0;
        pchEaten = &dummy2;
    }
 
    if (ppidl)
        *ppidl = NULL;
 
    return psf->ParseDisplayName(hwndOwner, pbcReserved, lpszDisplayName, pchEaten,
                                 ppidl, pdwAttributes);
}

PathFileExistsDefExtAndAttributesW()

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

Definition at line 215 of file utils.cpp.

{
    TRACE("(%s, 0x%lX, %p)\n", debugstr_w(pszPath), dwWhich, pdwFileAttributes);
 
    if (pdwFileAttributes)
        *pdwFileAttributes = INVALID_FILE_ATTRIBUTES;
 
    if (!pszPath)
        return FALSE;
 
    if (!dwWhich || (*PathFindExtensionW(pszPath) && (dwWhich & WHICH_OPTIONAL)))
        return PathFileExistsAndAttributesW(pszPath, pdwFileAttributes);
 
    if (!PathFileExistsDefExtW(pszPath, dwWhich))
    {
        if (pdwFileAttributes)
            *pdwFileAttributes = INVALID_FILE_ATTRIBUTES;
        return FALSE;
    }
 
    if (pdwFileAttributes)
        *pdwFileAttributes = GetFileAttributesW(pszPath);
 
    return TRUE;
}

Referenced by START_TEST().

SHInvokeCommandOnContextMenu()

EXTERN_C HRESULT WINAPI SHInvokeCommandOnContextMenu	(	_In_opt_ HWND	hWnd,
		_In_opt_ IUnknown *	pUnk,
		_In_ IContextMenu *	pCM,
		_In_ UINT	fCMIC,
		_In_opt_ LPCSTR	pszVerb
	)

Definition at line 148 of file utils.cpp.

{
    return SHInvokeCommandOnContextMenuEx(hWnd, pUnk, pCM, fCMIC, CMF_EXTENDEDVERBS, pszVerb, NULL);
}

SHInvokeCommandOnContextMenuEx()

EXTERN_C HRESULT WINAPI SHInvokeCommandOnContextMenuEx	(	_In_opt_ HWND	hWnd,
		_In_opt_ IUnknown *	pUnk,
		_In_ IContextMenu *	pCM,
		_In_ UINT	fCMIC,
		_In_ UINT	fCMF,
		_In_opt_ LPCSTR	pszVerb,
		_In_opt_ LPCWSTR	pwszDir
	)

Definition at line 131 of file utils.cpp.

{
    return SHInvokeCommandOnContextMenuInternal(hWnd, pUnk, pCM, fCMIC, fCMF, pszVerb, pwszDir, true);
}

Referenced by SHInvokeCommandOnContextMenu(), and SHInvokeCommandWithFlagsAndSite().

SHInvokeCommandOnContextMenuInternal()

static HRESULT SHInvokeCommandOnContextMenuInternal ( _In_opt_ HWND  hWnd, _In_opt_ IUnknown *  pUnk, _In_ IContextMenu *  pCM, _In_ UINT  fCMIC, _In_ UINT  fCMF, _In_opt_ LPCSTR  pszVerb, _In_opt_ LPCWSTR  pwszDir, _In_ bool  ForceQCM  )

static

Definition at line 43 of file utils.cpp.

{
    CMINVOKECOMMANDINFOEX info = { sizeof(info), fCMIC, hWnd, pszVerb };
    INT iDefItem = 0;
    HMENU hMenu = NULL;
    HCURSOR hOldCursor;
    HRESULT hr = S_OK;
    WCHAR wideverb[MAX_PATH];
 
    if (!pCM)
        return E_INVALIDARG;
 
    hOldCursor = SetCursor(LoadCursorW(NULL, (LPCWSTR)IDC_WAIT));
    info.nShow = SW_NORMAL;
    if (pUnk)
        IUnknown_SetSite(pCM, pUnk);
 
    if (IS_INTRESOURCE(pszVerb))
    {
        hMenu = CreatePopupMenu();
        if (hMenu)
        {
            hr = pCM->QueryContextMenu(hMenu, 0, 1, MAXSHORT, fCMF | CMF_DEFAULTONLY);
            iDefItem = GetMenuDefaultItem(hMenu, 0, 0);
            if (iDefItem != -1)
                info.lpVerb = MAKEINTRESOURCEA(iDefItem - 1);
        }
        info.lpVerbW = MAKEINTRESOURCEW(info.lpVerb);
    }
    else
    {
        if (GetVersionMajorMinor() >= _WIN32_WINNT_WIN7)
        {
            info.fMask |= CMF_OPTIMIZEFORINVOKE;
        }
        if (pszVerb && SHAnsiToUnicode(pszVerb, wideverb, _countof(wideverb)))
        {
            info.fMask |= CMIC_MASK_UNICODE;
            info.lpVerbW = wideverb;
        }
        if (ForceQCM)
        {
            hMenu = CreatePopupMenu();
            hr = pCM->QueryContextMenu(hMenu, 0, 1, MAXSHORT, fCMF);
        }
    }
 
    SetCursor(hOldCursor);
 
    if (!FAILED_UNEXPECTEDLY(hr) && (iDefItem != -1 || info.lpVerb))
    {
        if (!hWnd)
            info.fMask |= CMIC_MASK_FLAG_NO_UI;
 
        CHAR dir[MAX_PATH];
        if (pwszDir)
        {
            info.fMask |= CMIC_MASK_UNICODE;
            info.lpDirectoryW = pwszDir;
            if (SHUnicodeToAnsi(pwszDir, dir, _countof(dir)))
                info.lpDirectory = dir;
        }
 
        hr = pCM->InvokeCommand((LPCMINVOKECOMMANDINFO)&info);
        if (FAILED_UNEXPECTEDLY(hr)) { /* Diagnostic message */ }
    }
 
    if (pUnk)
        IUnknown_SetSite(pCM, NULL);
    if (hMenu)
        DestroyMenu(hMenu);
 
    return hr;
}

Referenced by IContextMenu_Invoke(), and SHInvokeCommandOnContextMenuEx().

SHInvokeCommandWithFlagsAndSite()

EXTERN_C HRESULT WINAPI SHInvokeCommandWithFlagsAndSite	(	_In_opt_ HWND	hWnd,
		_In_opt_ IUnknown *	pUnk,
		_In_ IShellFolder *	pShellFolder,
		_In_ LPCITEMIDLIST	pidl,
		_In_ UINT	fCMIC,
		_In_opt_ LPCSTR	pszVerb
	)

Definition at line 163 of file utils.cpp.

{
    HRESULT hr = E_INVALIDARG;
    if (pShellFolder)
    {
        IContextMenu *pCM;
        hr = pShellFolder->GetUIObjectOf(hWnd, 1, &pidl, IID_IContextMenu, NULL, (void**)&pCM);
        if (SUCCEEDED(hr))
        {
            fCMIC |= CMIC_MASK_FLAG_LOG_USAGE;
            hr = SHInvokeCommandOnContextMenuEx(hWnd, pUnk, pCM, fCMIC, 0, pszVerb, NULL);
            pCM->Release();
        }
    }
    return hr;
}

SHLWAPI_IsBogusHRESULT()

static BOOL SHLWAPI_IsBogusHRESULT ( HRESULT  hr )

inlinestatic

Definition at line 245 of file utils.cpp.

{
    return (hr == E_FAIL || hr == E_INVALIDARG || hr == E_NOTIMPL);
}

Referenced by IShellFolder_GetDisplayNameOf().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)

Variable Documentation

g_RetryData

const RETRY_DATA g_RetryData[]

static

Initial value:

=
{
    { SHGDN_FOREDITING,    SHGDN_NORMAL,     SFGDNO_RETRYALWAYS         },
    { SHGDN_FORADDRESSBAR, SHGDN_NORMAL,     SFGDNO_RETRYALWAYS         },
    { SHGDN_NORMAL,        SHGDN_FORPARSING, SFGDNO_RETRYALWAYS         },
    { SHGDN_FORPARSING,    SHGDN_NORMAL,     SFGDNO_RETRYWITHFORPARSING },
    { SHGDN_INFOLDER,      SHGDN_NORMAL,     SFGDNO_RETRYALWAYS         },
}

Definition at line 257 of file utils.cpp.

Referenced by IShellFolder_GetDisplayNameOf().