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)
EXTERN_C LSTATUS WINAPI	RegGetValueW (HKEY, LPCWSTR, LPCWSTR, DWORD, LPDWORD, PVOID, LPDWORD)
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)
static HRESULT	ShellExecuteCommand (_In_opt_ HWND hWnd, _In_ PCWSTR Command, _In_opt_ UINT Flags)
EXTERN_C HRESULT WINAPI	RunRegCommand (_In_opt_ HWND hWnd, _In_ HKEY hKey, _In_opt_ PCWSTR pszSubKey)
EXTERN_C HRESULT WINAPI	RunIndirectRegCommand (_In_opt_ HWND hWnd, _In_ HKEY hKey, _In_opt_ PCWSTR pszSubKey, _In_ PCWSTR pszVerb)
EXTERN_C HRESULT WINAPI	SHRunIndirectRegClientCommand (_In_opt_ HWND hWnd, _In_ PCWSTR pszClientType)
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 38 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 196 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 447 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 359 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 407 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 300 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().

RegGetValueW()

EXTERN_C LSTATUS WINAPI RegGetValueW	(	HKEY	hKey,
		LPCWSTR	pszSubKey,
		LPCWSTR	pszValue,
		DWORD	dwFlags,
		LPDWORD	pdwType,
		PVOID	pvData,
		LPDWORD	pcbData
	)

Definition at line 1931 of file reg.c.

{
    DWORD dwType, cbData = pcbData ? *pcbData : 0;
    PVOID pvBuf = NULL;
    LONG ret;
 
    TRACE("(%p,%s,%s,%ld,%p,%p,%p=%ld)\n",
          hKey, debugstr_w(pszSubKey), debugstr_w(pszValue), dwFlags, pdwType,
          pvData, pcbData, cbData);
 
    if (pvData && !pcbData)
        return ERROR_INVALID_PARAMETER;
    if ((dwFlags & RRF_RT_REG_EXPAND_SZ) && !(dwFlags & RRF_NOEXPAND) &&
            ((dwFlags & RRF_RT_ANY) != RRF_RT_ANY))
        return ERROR_INVALID_PARAMETER;
 
    if (pszSubKey && pszSubKey[0])
    {
        ret = RegOpenKeyExW(hKey, pszSubKey, 0, KEY_QUERY_VALUE, &hKey);
        if (ret != ERROR_SUCCESS) return ret;
    }
 
    ret = RegQueryValueExW(hKey, pszValue, NULL, &dwType, pvData, &cbData);
 
    /* If we are going to expand we need to read in the whole the value even
     * if the passed buffer was too small as the expanded string might be
     * smaller than the unexpanded one and could fit into cbData bytes. */
    if ((ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) &&
        dwType == REG_EXPAND_SZ && !(dwFlags & RRF_NOEXPAND))
    {
        do
        {
            HeapFree(GetProcessHeap(), 0, pvBuf);
 
            pvBuf = HeapAlloc(GetProcessHeap(), 0, cbData);
            if (!pvBuf)
            {
                ret = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            if (ret == ERROR_MORE_DATA || !pvData)
                ret = RegQueryValueExW(hKey, pszValue, NULL,
                                       &dwType, pvBuf, &cbData);
            else
            {
                /* Even if cbData was large enough we have to copy the
                 * string since ExpandEnvironmentStrings can't handle
                 * overlapping buffers. */
                CopyMemory(pvBuf, pvData, cbData);
            }
 
            /* Both the type or the value itself could have been modified in
             * between so we have to keep retrying until the buffer is large
             * enough or we no longer have to expand the value. */
        }
        while (dwType == REG_EXPAND_SZ && ret == ERROR_MORE_DATA);
 
        if (ret == ERROR_SUCCESS)
        {
            /* Recheck dwType in case it changed since the first call */
            if (dwType == REG_EXPAND_SZ)
            {
                cbData = ExpandEnvironmentStringsW(pvBuf, pvData,
                                                   pcbData ? *pcbData : 0) * sizeof(WCHAR);
                dwType = REG_SZ;
                if (pvData && pcbData && cbData > *pcbData)
                    ret = ERROR_MORE_DATA;
            }
            else if (pvData)
                CopyMemory(pvData, pvBuf, *pcbData);
        }
 
        HeapFree(GetProcessHeap(), 0, pvBuf);
    }
 
    if (pszSubKey && pszSubKey[0])
        RegCloseKey(hKey);
 
    RegpApplyRestrictions(dwFlags, dwType, cbData, &ret);
 
    if (pvData && ret != ERROR_SUCCESS && (dwFlags & RRF_ZEROONFAILURE))
        ZeroMemory(pvData, *pcbData);
 
    if (pdwType)
        *pdwType = dwType;
 
    if (pcbData)
        *pcbData = cbData;
 
    return ret;
}

Referenced by AddFSClassKeysToArray(), CRegFolderEnum::AddItemsFromKey(), CDefaultContextMenu::AddStaticEntriesForKey(), AssocGetPerceivedType(), check_product_patches(), ComponentInfo_GetGUIDValue(), ComponentInfo_GetUINTValue(), create_monodata(), DoGetProductType(), CDefaultContextMenu::EnumerateDynamicContextHandlerForKey(), CDrvDefExt::ExtraPageProc(), FILEDLG95_MRU_get_slot(), FILEDLG95_MRU_save_filename(), FindExeCplClass(), CDrvDefExt::GeneralPageProc(), get_patch_state(), get_stringvalue(), GetCLSIDForFileTypeFromExtension(), CNetConnectionPropertyUi::GetDeviceInstanceID(), GetInterfaceName(), GetRegCustomizedDriveIcon(), GetRegString(), CQueryAssociations::GetString(), HCR_GetClassNameW(), InitializeRecycleBinDlg(), InitIconOverlays(), CFileDefExt::InitOpensWithField(), COpenWithList::IsHidden(), COpenWithList::Load(), load_config_driver(), load_settings(), COpenWithList::LoadFromProgIdKey(), CNewMenu::LoadItem(), LoadKeyboardLayoutW(), COpenWithList::LoadRecommendedFromHKCR(), COpenWithList::LoadRecommendedFromHKCU(), MMDevice_GetPropValue(), OpenKeyFromFileType(), PixelFormatInfo_GetChannelMask(), read_bitmap_patterns(), read_metadata_patterns(), RegQueryDword(), RunRegCommand(), COpenWithList::SetDefaultHandler(), SHELL32_AssocGetExtensionDescription(), SHELL32_IsShellFolderNamespaceItemHidden(), SHELL_GetRegCLSID(), SHELL_GetShellExtensionRegCLSID(), SHELL_QueryCLSIDValue(), SHRunIndirectRegClientCommand(), SQLGetPrivateProfileStringW(), and WshShell3_RegRead().

RunIndirectRegCommand()

EXTERN_C HRESULT WINAPI RunIndirectRegCommand	(	_In_opt_ HWND	hWnd,
		_In_ HKEY	hKey,
		_In_opt_ PCWSTR	pszSubKey,
		_In_ PCWSTR	pszVerb
	)

Definition at line 250 of file utils.cpp.

{
    WCHAR szKey[MAX_PATH];
    HRESULT hr;
    if (pszSubKey)
        hr = StringCchPrintfW(szKey, _countof(szKey), L"%s\\shell\\%s\\command", pszSubKey, pszVerb);
    else
        hr = StringCchPrintfW(szKey, _countof(szKey), L"shell\\%s\\command", pszVerb);
    return SUCCEEDED(hr) ? RunRegCommand(hWnd, hKey, szKey) : hr;
}

Referenced by SHRunIndirectRegClientCommand().

RunRegCommand()

EXTERN_C HRESULT WINAPI RunRegCommand	(	_In_opt_ HWND	hWnd,
		_In_ HKEY	hKey,
		_In_opt_ PCWSTR	pszSubKey
	)

Definition at line 236 of file utils.cpp.

{
    WCHAR szCmd[MAX_PATH * 2];
    DWORD cb = sizeof(szCmd);
    DWORD error = RegGetValueW(hKey, pszSubKey, NULL, RRF_RT_REG_SZ, NULL, szCmd, &cb);
    if (error)
        return HRESULT_FROM_WIN32(error);
    return ShellExecuteCommand(hWnd, szCmd, SEE_MASK_FLAG_LOG_USAGE);
}

Referenced by RunIndirectRegCommand().

ShellExecuteCommand()

static HRESULT ShellExecuteCommand ( _In_opt_ HWND  hWnd, _In_ PCWSTR  Command, _In_opt_ UINT  Flags  )

static

Definition at line 212 of file utils.cpp.

{
    WCHAR szCmd[MAX_PATH * 2];
    int len = PathProcessCommand(Command, szCmd, _countof(szCmd), PPCF_ADDARGUMENTS | PPCF_FORCEQUALIFY);
    if (len <= 0) // Could not resolve the command, just use the input
    {
        HRESULT hr = StringCchCopyW(szCmd, _countof(szCmd), Command);
        if (FAILED(hr))
            return hr;
    }
    PWSTR pszArgs = PathGetArgsW(szCmd);
    PathRemoveArgsW(szCmd);
    PathUnquoteSpacesW(szCmd);
 
    SHELLEXECUTEINFOW sei = { sizeof(sei), Flags, hWnd, NULL, szCmd, pszArgs };
    sei.nShow = SW_SHOW;
    UINT error = ShellExecuteExW(&sei) ? ERROR_SUCCESS : GetLastError();
    return HRESULT_FROM_WIN32(error);
}

Referenced by RunRegCommand().

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 150 of file utils.cpp.

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

Referenced by BrFolder_Delete().

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 133 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 45 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 165 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 330 of file utils.cpp.

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

Referenced by IShellFolder_GetDisplayNameOf().

SHRunIndirectRegClientCommand()

EXTERN_C HRESULT WINAPI SHRunIndirectRegClientCommand	(	_In_opt_ HWND	hWnd,
		_In_ PCWSTR	pszClientType
	)

Definition at line 265 of file utils.cpp.

{
    WCHAR szKey[MAX_PATH], szClient[MAX_PATH];
    HRESULT hr = StringCchPrintfW(szKey, _countof(szKey), L"Software\\Clients\\%s", pszClientType);
    if (FAILED(hr))
        return hr;
 
    // Find the default client
    DWORD error, cb;
    cb = sizeof(szClient);
    error = RegGetValueW(HKEY_CURRENT_USER, szKey, NULL, RRF_RT_REG_SZ, NULL, szClient, &cb);
    if (error)
    {
        cb = sizeof(szClient);
        if (error != ERROR_MORE_DATA && error != ERROR_BUFFER_OVERFLOW)
            error = RegGetValueW(HKEY_LOCAL_MACHINE, szKey, NULL, RRF_RT_REG_SZ, NULL, szClient, &cb);
        if (error)
            return HRESULT_FROM_WIN32(error);
    }
 
    hr = StringCchPrintfW(szKey, _countof(szKey), L"Software\\Clients\\%s\\%s", pszClientType, szClient);
    if (SUCCEEDED(hr))
        hr = RunIndirectRegCommand(hWnd, HKEY_LOCAL_MACHINE, szKey, L"open");
    return hr;
}

Referenced by CTaskSwitchWnd::InvokeRegistryAppKeyCommand().

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 342 of file utils.cpp.

Referenced by IShellFolder_GetDisplayNameOf().