utils.cpp File Reference

#include "precomp.h"
#include <winver.h>
#include <shellapi.h>
#include <shlwapi.h>
#include <shlobj_undoc.h>
#include <shlguid_undoc.h>
#include <userenv.h>
#include <atlstr.h>
#include "resource.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
struct	tagSHDIALOG

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 */

Typedefs
typedef struct tagSHDIALOG	SHDIALOG
typedef struct tagSHDIALOG *	PSHDIALOG

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
EXTERN_C LSTATUS WINAPI	RegGetValueW (HKEY, LPCWSTR, LPCWSTR, DWORD, LPDWORD, PVOID, LPDWORD)
static WORD	GetVersionMajorMinor ()
static BOOL	UnExpandEnvironmentStringForUserA (_In_ HANDLE hUserToken, _In_ PCSTR lpString, _In_ PCSTR lpSrc, _Out_ PSTR pszDest, _In_ INT cchDest)
static BOOL	UnExpandEnvironmentStringForUserW (_In_ HANDLE hUserToken, _In_ PCWSTR lpString, _In_ PCWSTR lpSrc, _Out_ PWSTR pszDest, _In_ INT cchDest)
EXTERN_C BOOL WINAPI	PathUnExpandEnvStringsForUserA (_In_ HANDLE hUserToken, _In_ PCSTR pszPath, _Out_writes_(cchBuff) PSTR pszBuff, _In_ INT cchBuff)
EXTERN_C BOOL WINAPI	PathUnExpandEnvStringsForUserW (_In_ HANDLE hUserToken, _In_ PCWSTR pwszPath, _Out_writes_(cchBuff) PWSTR pszBuff, _In_ INT cchBuff)
EXTERN_C HRESULT WINAPI	MapWin32ErrorToSTG (_In_ HRESULT hr)
static BOOL	CharLowerNoDBCSAWorker (PSTR lpString, INT cchMax, BOOL bUppercase)
static BOOL	CharLowerNoDBCSWWorker (PWSTR lpString, INT cchMax, BOOL bUppercase)
EXTERN_C PSTR WINAPI	CharLowerNoDBCSA (_Inout_ PSTR lpString)
EXTERN_C PWSTR WINAPI	CharLowerNoDBCSW (_Inout_ PWSTR lpString)
EXTERN_C PSTR WINAPI	CharUpperNoDBCSA (_Inout_ PSTR lpString)
EXTERN_C PWSTR WINAPI	CharUpperNoDBCSW (_Inout_ PWSTR lpString)
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)
static BOOL	IsTextAsciiOnly (PCSTR psz)
EXTERN_C HRESULT WINAPI	SHInvokeCommandsOnContextMenu (_In_opt_ HWND hwnd, _In_opt_ IUnknown *punkSite, _In_ IContextMenu *pCM, _In_ DWORD fMask, _In_reads_opt_(cVerbs) PCSTR *pVerbs, _In_ UINT cVerbs)
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)
static INT_PTR CALLBACK	SHDialogProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
EXTERN_C INT_PTR WINAPI	SHDialogBox (_In_opt_ HINSTANCE hInstance, _In_ PCSTR lpTemplateName, _In_opt_ HWND hWndParent, _In_opt_ SHDIALOGPROC fn, _In_opt_ PVOID pThis)
EXTERN_C PSTR WINAPI	NextPathA (_In_ PCSTR pszStart, _Out_writes_(cchDest) PSTR pszDest, _In_ UINT cchDest)
EXTERN_C PWSTR WINAPI	NextPathW (_In_ PCWSTR pszStart, _Out_writes_(cchDest) PWSTR pszDest, _In_ UINT cchDest)
static HRESULT	_AllocValueString (HKEY hkey, PCWSTR pszSubKey, PCWSTR pszValue, PWSTR *ppszOut)
EXTERN_C HRESULT WINAPI	IUnknown_ShowBrowserBar (_In_ IUnknown *punk, _In_ REFGUID rguid, _In_ BOOL bShow)
VOID WINAPI	PrettifyFileDescriptionW (_Inout_ PWSTR pszTarget, _In_opt_ PCWSTR pszCutList)
BOOL WINAPI	SHGetFileDescriptionW (_In_ PCWSTR pszPath, _In_opt_ PCWSTR pszVerKey, _In_opt_ PCWSTR pszDisplayName, _Out_opt_ PWSTR pszOut, _Inout_ PUINT pcchOut)
BOOL WINAPI	SHGetFileDescriptionA (_In_ PCSTR pszPath, _In_opt_ PCSTR pszVerKey, _In_opt_ PCSTR pszDisplayName, _Out_opt_ PSTR pszOut, _Inout_ PUINT pcchOut)
EXTERN_C INT WINAPI	SHRestrictedMessageBox (_In_ HWND hWnd)
EXTERN_C ULONG WINAPI	GetProcessOsVersion (void)

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 33 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.

Typedef Documentation

PSHDIALOG

typedef struct tagSHDIALOG * PSHDIALOG

SHDIALOG

typedef struct tagSHDIALOG SHDIALOG

Function Documentation

_AllocValueString()

static HRESULT _AllocValueString ( HKEY  hkey, PCWSTR  pszSubKey, PCWSTR  pszValue, PWSTR *  ppszOut  )

static

Definition at line 987 of file utils.cpp.

{
    *ppszOut = NULL;
 
    DWORD cbData;
    LSTATUS error = SHGetValueW(hkey, pszSubKey, pszValue, NULL, NULL, &cbData);
    if (error)
        return HRESULT_FROM_WIN32(error);
 
    PWSTR pszData = (PWSTR)LocalAlloc(LPTR, cbData);
    if (!pszData)
        return HRESULT_FROM_WIN32(ERROR_OUTOFMEMORY);
 
    error = SHGetValueW(hkey, pszSubKey, pszValue, NULL, pszData, &cbData);
    if (error)
    {
        LocalFree(pszData);
        return HRESULT_FROM_WIN32(error);
    }
 
    *ppszOut = pszData;
    return S_OK;
}

Referenced by PrettifyFileDescriptionW().

CharLowerNoDBCSA()

EXTERN_C PSTR WINAPI CharLowerNoDBCSA

(

_Inout_ PSTR

lpString

)

Definition at line 275 of file utils.cpp.

{
    return CharLowerNoDBCSAWorker(lpString, 0, FALSE) ? lpString : NULL;
}

CharLowerNoDBCSAWorker()

static BOOL CharLowerNoDBCSAWorker ( PSTR  lpString, INT  cchMax, BOOL  bUppercase  )

static

Definition at line 246 of file utils.cpp.

{
    CHAR szBuff[MAX_PATH];
    INT cch;
    if (!lpString)
        return FALSE;
    cch = cchMax ? cchMax : lstrlenA(lpString);
    if (FAILED(StringCchCopyA(szBuff, _countof(szBuff), lpString)))
        return FALSE;
    return LCMapStringA(LOCALE_SYSTEM_DEFAULT, (bUppercase ? LCMAP_UPPERCASE : LCMAP_LOWERCASE),
                        szBuff, cch, lpString, cch);
}

Referenced by CharLowerNoDBCSA(), and CharUpperNoDBCSA().

CharLowerNoDBCSW()

EXTERN_C PWSTR WINAPI CharLowerNoDBCSW

(

_Inout_ PWSTR

lpString

)

Definition at line 283 of file utils.cpp.

{
    return CharLowerNoDBCSWWorker(lpString, 0, FALSE) ? lpString : NULL;
}

CharLowerNoDBCSWWorker()

static BOOL CharLowerNoDBCSWWorker ( PWSTR  lpString, INT  cchMax, BOOL  bUppercase  )

static

Definition at line 259 of file utils.cpp.

{
    WCHAR szDest[MAX_PATH];
    INT cch;
    if (!lpString)
        return FALSE;
    cch = cchMax ? cchMax : lstrlenW(lpString);
    if (FAILED(StringCchCopyW(szDest, _countof(szDest), lpString)))
        return FALSE;
    return LCMapStringW(LOCALE_SYSTEM_DEFAULT, (bUppercase ? LCMAP_UPPERCASE : LCMAP_LOWERCASE),
                        szDest, cch, lpString, cch);
}

Referenced by CharLowerNoDBCSW(), and CharUpperNoDBCSW().

CharUpperNoDBCSA()

EXTERN_C PSTR WINAPI CharUpperNoDBCSA

(

_Inout_ PSTR

lpString

)

Definition at line 291 of file utils.cpp.

{
    return CharLowerNoDBCSAWorker(lpString, 0, TRUE) ? lpString : NULL;
}

CharUpperNoDBCSW()

EXTERN_C PWSTR WINAPI CharUpperNoDBCSW

(

_Inout_ PWSTR

lpString

)

Definition at line 299 of file utils.cpp.

{
    return CharLowerNoDBCSWWorker(lpString, 0, TRUE) ? lpString : NULL;
}

GetProcessOsVersion()

EXTERN_C ULONG WINAPI GetProcessOsVersion

(

void

)

Definition at line 1257 of file utils.cpp.

{
    PPEB Peb = NtCurrentTeb()->Peb;
    return (Peb->OSMajorVersion << 8) | Peb->OSMinorVersion;
}

Referenced by CBasePropertyBag::QueryInterface(), CMemPropertyBag::Read(), and CMemPropertyBag::Write().

GetVersionMajorMinor()

static WORD GetVersionMajorMinor ( )

inlinestatic

Definition at line 41 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 557 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 808 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 720 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 768 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);
}

IsTextAsciiOnly()

static BOOL IsTextAsciiOnly ( PCSTR  psz )

inlinestatic

Definition at line 421 of file utils.cpp.

{
    for (const signed char *pch = (const signed char *)psz; *pch; ++pch)
    {
        if (*pch < 0)
            return FALSE;
    }
    return TRUE;
}

Referenced by SHInvokeCommandsOnContextMenu().

IUnknown_ShowBrowserBar()

EXTERN_C HRESULT WINAPI IUnknown_ShowBrowserBar	(	_In_ IUnknown *	punk,
		_In_ REFGUID	rguid,
		_In_ BOOL	bShow
	)

Definition at line 1021 of file utils.cpp.

{
    CComPtr<IWebBrowser2> pWB2;
    HRESULT hr = IUnknown_QueryServiceForWebBrowserApp(punk, IID_IWebBrowser2, (PVOID*)&pWB2);
    if (FAILED(hr))
        return hr;
 
    WCHAR szGUID[40];
    StringFromGUID2(rguid, szGUID, _countof(szGUID));
 
    CComVariant varClsid(szGUID), varShow((bool)!!bShow), varSize;
    return pWB2->ShowBrowserBar(&varClsid, &varShow, &varSize);
}

MapWin32ErrorToSTG()

EXTERN_C HRESULT WINAPI MapWin32ErrorToSTG

(

_In_ HRESULT

hr

)

Definition at line 229 of file utils.cpp.

{
    switch (hr)
    {
        case HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED):
            return STG_E_ACCESSDENIED;
        case HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND):
        case HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND):
            return STG_E_FILENOTFOUND;
        case HRESULT_FROM_WIN32(ERROR_FILE_EXISTS):
        case HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS):
            return STG_E_FILEALREADYEXISTS;
        default:
            return hr;
    }
}

NextPathA()

EXTERN_C PSTR WINAPI NextPathA	(	_In_ PCSTR	pszStart,
		_Out_writes_(cchDest) PSTR	pszDest,
		_In_ UINT	cchDest
	)

Definition at line 913 of file utils.cpp.

{
    if (!pszStart)
        return NULL;
 
    PCSTR pchStart = pszStart;
    while (*pchStart == ';')
        ++pchStart;
 
    if (!*pchStart)
        return NULL;
 
    PSTR pchEnd = StrChrA(pchStart, ';');
    if (!pchEnd)
        pchEnd = (PSTR)(pchStart + lstrlenA(pchStart));
 
    const UINT cchSegment = (UINT)(pchEnd - pchStart);
    const UINT cchToCopy = min(cchSegment + 1, cchDest);
    lstrcpynA(pszDest, pchStart, cchToCopy);
    pszDest[cchSegment] = ANSI_NULL;
 
    PathRemoveBlanksA(pszDest);
    if (!*pszDest)
        return NULL;
 
    return (*pchEnd == ';') ? (pchEnd + 1) : pchEnd;
}

NextPathW()

EXTERN_C PWSTR WINAPI NextPathW	(	_In_ PCWSTR	pszStart,
		_Out_writes_(cchDest) PWSTR	pszDest,
		_In_ UINT	cchDest
	)

Definition at line 955 of file utils.cpp.

{
    if (!pszStart)
        return NULL;
 
    PCWSTR pchStart = pszStart;
    while (*pchStart == L';')
        ++pchStart;
 
    if (!*pchStart)
        return NULL;
 
    PWSTR pchEnd = StrChrW(pchStart, L';');
    if (!pchEnd)
        pchEnd = (PWSTR)(pchStart + lstrlenW(pchStart));
 
    const UINT cchSegment = (UINT)(pchEnd - pchStart);
    const UINT cchToCopy = min(cchSegment + 1, cchDest);
    lstrcpynW(pszDest, pchStart, cchToCopy);
    pszDest[cchSegment] = UNICODE_NULL;
 
    PathRemoveBlanksW(pszDest);
    if (!*pszDest)
        return NULL;
 
    return (*pchEnd == L';') ? (pchEnd + 1) : pchEnd;
}

PathFileExistsDefExtAndAttributesW()

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

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

PathUnExpandEnvStringsForUserA()

EXTERN_C BOOL WINAPI PathUnExpandEnvStringsForUserA	(	_In_ HANDLE	hUserToken,
		_In_ PCSTR	pszPath,
		_Out_writes_(cchBuff) PSTR	pszBuff,
		_In_ INT	cchBuff
	)

Definition at line 138 of file utils.cpp.

{
    static const PCSTR c_varsA[] =
    {
        "%APPDATA%",
        "%USERPROFILE%",
        "%ALLUSERSPROFILE%",
        "%ProgramFiles%",
        "%SystemRoot%",
        "%SystemDrive%",
    };
 
    if (!pszPath)
    {
        if (pszBuff && cchBuff)
            *pszBuff = ANSI_NULL;
 
        return FALSE;
    }
 
    if (!pszBuff)
        return FALSE;
 
    for (size_t iVar = 0; iVar < _countof(c_varsA); ++iVar)
    {
        if (UnExpandEnvironmentStringForUserA(hUserToken, pszPath, c_varsA[iVar],
                                              pszBuff, cchBuff))
        {
            return TRUE;
        }
    }
 
    return FALSE;
}

PathUnExpandEnvStringsForUserW()

EXTERN_C BOOL WINAPI PathUnExpandEnvStringsForUserW	(	_In_ HANDLE	hUserToken,
		_In_ PCWSTR	pwszPath,
		_Out_writes_(cchBuff) PWSTR	pszBuff,
		_In_ INT	cchBuff
	)

Definition at line 184 of file utils.cpp.

{
    static const PCWSTR c_varsW[] =
    {
        L"%APPDATA%",
        L"%USERPROFILE%",
        L"%ALLUSERSPROFILE%",
        L"%ProgramFiles%",
        L"%SystemRoot%",
        L"%SystemDrive%",
    };
 
    if (!pwszPath)
    {
        if (pszBuff && cchBuff)
            *pszBuff = UNICODE_NULL;
 
        return FALSE;
    }
 
    if (!pszBuff)
        return FALSE;
 
    for (size_t iVar = 0; iVar < _countof(c_varsW); ++iVar)
    {
        if (UnExpandEnvironmentStringForUserW(hUserToken, pwszPath, c_varsW[iVar],
                                              pszBuff, cchBuff))
        {
            return TRUE;
        }
    }
 
    return FALSE;
}

PrettifyFileDescriptionW()

VOID WINAPI PrettifyFileDescriptionW	(	_Inout_ PWSTR	pszTarget,
		_In_opt_ PCWSTR	pszCutList
	)

Definition at line 1044 of file utils.cpp.

{
    if (!pszTarget || !*pszTarget)
        return;
 
    PWSTR pszFreeList = NULL;
    PCWSTR pszList = pszCutList;
    PCWSTR pszAssoc = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FileAssociation";
    if (_AllocValueString(HKEY_LOCAL_MACHINE, pszAssoc, L"CutList", &pszFreeList) == S_OK)
        pszList = pszFreeList;
 
    if (pszList && *pszList)
    {
        for (PCWSTR pszEntry = pszList; *pszEntry; pszEntry += lstrlenW(pszEntry) + 1)
        {
            PWSTR pszMatch = StrRStrIW(pszTarget, NULL, pszEntry);
            if (!pszMatch)
                continue;
 
            if (pszMatch[lstrlenW(pszEntry)])
                continue;
 
            *pszMatch = UNICODE_NULL;
            while (pszMatch > pszTarget && pszMatch[-1] == L' ')
            {
                --pszMatch;
                *pszMatch = UNICODE_NULL;
            }
 
            break;
        }
    }
 
    if (pszFreeList)
        LocalFree(pszFreeList);
}

Referenced by SHGetFileDescriptionW().

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 CPolicyCache::_GetValue(), AddFSClassKeysToArray(), CRegFolderEnum::AddItemsFromKey(), CDefaultContextMenu::AddStaticEntriesForKey(), AssocGetPerceivedType(), CFSExtractIcon_CreateInstance(), 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_mono_path_registry(), get_patch_state(), get_stringvalue(), GetCLSIDForFileTypeFromExtension(), CNetConnectionPropertyUi::GetDeviceInstanceID(), GetInterfaceName(), GetRegCustomizedDriveIcon(), GetRegString(), CQueryAssociations::GetString(), HCR_GetClassNameW(), InitFunctionPtrs(), InitializeRecycleBinDlg(), InitIconOverlays(), CFileDefExt::InitOpensWithField(), COpenWithList::IsHidden(), keyboard_layout_has_altgr(), 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(), SetupDiBuildDriverInfoList(), SHELL32_AssocGetExtensionDescription(), SHELL_GetRegCLSID(), SHELL_GetShellExtensionRegCLSID(), SHELL_QueryCLSIDValue(), SHRunIndirectRegClientCommand(), SQLGetPrivateProfileStringW(), test_keyboard_layout_name(), 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 611 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 597 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().

SHDialogBox()

EXTERN_C INT_PTR WINAPI SHDialogBox	(	_In_opt_ HINSTANCE	hInstance,
		_In_ PCSTR	lpTemplateName,
		_In_opt_ HWND	hWndParent,
		_In_opt_ SHDIALOGPROC	fn,
		_In_opt_ PVOID	pThis
	)

Definition at line 896 of file utils.cpp.

{
    SHDIALOG data = { fn, pThis };
    return DialogBoxParamA(hInstance, lpTemplateName, hWndParent, SHDialogProc, (LPARAM)&data);
}

SHDialogProc()

static INT_PTR CALLBACK SHDialogProc ( HWND  hWnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 842 of file utils.cpp.

{
    PSHDIALOG pData;
    INT_PTR result;
    HWND hwndItem;
    LRESULT ret;
 
    if (uMsg == WM_INITDIALOG)
    {
        pData = (PSHDIALOG)lParam;
        SetWindowLongPtrA(hWnd, DWLP_USER, lParam);
        lParam = (LPARAM)pData->pThis;
    }
    else
    {
        pData = (PSHDIALOG)GetWindowLongPtrA(hWnd, DWLP_USER);
    }
 
    if (pData && pData->fn)
    {
        result = pData->fn(pData->pThis, hWnd, uMsg, wParam, lParam);
        if (result)
            return result;
    }
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
            return TRUE;
 
        case WM_COMMAND:
            if (LOWORD(wParam) == IDHELP)
                return FALSE;
 
            hwndItem = GetDlgItem(hWnd, LOWORD(wParam));
            if (!hwndItem)
                return FALSE;
 
            ret = SendMessageA(hwndItem, WM_GETDLGCODE, 0, 0);
            if (!(ret & (DLGC_DEFPUSHBUTTON | DLGC_UNDEFPUSHBUTTON)))
                return FALSE;
 
            EndDialog(hWnd, LOWORD(wParam));
            return TRUE;
 
        default:
            return FALSE;
    }
}

Referenced by SHDialogBox().

ShellExecuteCommand()

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

static

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

SHGetFileDescriptionA()

BOOL WINAPI SHGetFileDescriptionA	(	_In_ PCSTR	pszPath,
		_In_opt_ PCSTR	pszVerKey,
		_In_opt_ PCSTR	pszDisplayName,
		_Out_opt_ PSTR	pszOut,
		_Inout_ PUINT	pcchOut
	)

Definition at line 1199 of file utils.cpp.

{
    WCHAR szPathW[MAX_PATH], szVerKeyW[MAX_PATH], szDisplayNameW[MAX_PATH], szOutW[MAX_PATH];
    CHAR szOutA[MAX_PATH];
    BOOL ret;
    UINT cchOutW;
 
    SHAnsiToUnicode(pszPath, szPathW, _countof(szPathW));
    szPathW[_countof(szPathW) - 1] = UNICODE_NULL;
 
    if (pszVerKey)
    {
        SHAnsiToUnicode(pszVerKey, szVerKeyW, _countof(szVerKeyW));
        szVerKeyW[_countof(szVerKeyW) - 1] = UNICODE_NULL;
    }
 
    if (pszDisplayName)
    {
        SHAnsiToUnicode(pszDisplayName, szDisplayNameW, _countof(szDisplayNameW));
        szDisplayNameW[_countof(szDisplayNameW) - 1] = UNICODE_NULL;
    }
 
    cchOutW = (UINT)_countof(szOutW);
    ret = SHGetFileDescriptionW(szPathW, (pszVerKey ? szVerKeyW : NULL),
                                (pszDisplayName ? szDisplayNameW : NULL), szOutW, &cchOutW);
    if (ret)
    {
        szOutW[_countof(szOutW) - 1] = UNICODE_NULL;
 
        if (!pszOut)
            pszOut = szOutA;
 
        SHUnicodeToAnsi(szOutW, pszOut, *pcchOut);
        if (*pcchOut > 0)
            pszOut[*pcchOut - 1] = ANSI_NULL;
        *pcchOut = lstrlenA(pszOut) + 1;
    }
 
    return ret;
}

SHGetFileDescriptionW()

BOOL WINAPI SHGetFileDescriptionW	(	_In_ PCWSTR	pszPath,
		_In_opt_ PCWSTR	pszVerKey,
		_In_opt_ PCWSTR	pszDisplayName,
		_Out_opt_ PWSTR	pszOut,
		_Inout_ PUINT	pcchOut
	)

Definition at line 1087 of file utils.cpp.

{
    DWORD pdwAttrs = 0;
    if (!PathFileExistsAndAttributesW(pszPath, &pdwAttrs))
        return FALSE;
 
    WCHAR szPath[MAX_PATH];
    StringCchCopyW(szPath, _countof(szPath), pszPath);
 
    PVOID pvDescription  = NULL;
    UINT  cchDescription = 0;
    PVOID pvBlock = NULL;
 
    BOOL bIsFile = !(pdwAttrs & FILE_ATTRIBUTE_DIRECTORY) &&
                   !PathIsUNCServerW(pszPath) &&
                   !PathIsUNCServerShareW(pszPath);
    if (bIsFile)
    {
        DWORD dwHandle = 0;
        DWORD cbBlock  = GetFileVersionInfoSizeW(szPath, &dwHandle);
        if (cbBlock)
        {
            pvBlock = LocalAlloc(LPTR, cbBlock);
            if (pvBlock && GetFileVersionInfoW(szPath, dwHandle, cbBlock, pvBlock))
            {
                WCHAR szSubBlock[60];
                BOOL ret = FALSE;
                if (pszVerKey)
                {
                    StringCchCopyW(szSubBlock, _countof(szSubBlock), pszVerKey);
                    ret = VerQueryValueW(pvBlock, szSubBlock, &pvDescription, &cchDescription);
                }
 
                if (!ret)
                {
                    PVOID pTranslation = NULL;
                    UINT cbTranslation = 0;
                    if (VerQueryValueW(pvBlock, L"\\VarFileInfo\\Translation", &pTranslation,
                                       &cbTranslation) && cbTranslation)
                    {
                        UINT langId   = ((PWORD)pTranslation)[0];
                        UINT codePage = ((PWORD)pTranslation)[1];
                        StringCchPrintfW(szSubBlock, _countof(szSubBlock),
                                         L"\\StringFileInfo\\%04X%04X\\FileDescription",
                                         langId, codePage);
                        ret = VerQueryValueW(pvBlock, szSubBlock, &pvDescription, &cchDescription);
                    }
                }
 
                if (!ret)
                {
                    // 0x0409: English (United States), 0x04B0: UTF-16 codepage
                    StringCchCopyW(szSubBlock, _countof(szSubBlock),
                                   L"\\StringFileInfo\\040904B0\\FileDescription");
                    ret = VerQueryValueW(pvBlock, szSubBlock, &pvDescription, &cchDescription);
                }
                if (!ret)
                {
                    // 0x0409: English (United States), 0x04E4: Latin 1 codepage
                    StringCchCopyW(szSubBlock, _countof(szSubBlock),
                                   L"\\StringFileInfo\\040904E4\\FileDescription");
                    ret = VerQueryValueW(pvBlock, szSubBlock, &pvDescription, &cchDescription);
                }
                if (!ret)
                {
                    // 0x0409: English (United States), 0x0000: Neutral
                    StringCchCopyW(szSubBlock, _countof(szSubBlock),
                                   L"\\StringFileInfo\\04090000\\FileDescription");
                    ret = VerQueryValueW(pvBlock, szSubBlock, &pvDescription, &cchDescription);
                }
            }
        }
    }
 
    PWSTR pszDescription = (PWSTR)pvDescription;
    if (!pszDescription || !*pszDescription)
    {
        PathRemoveExtensionW(szPath);
        pszDescription = PathFindFileNameW(szPath);
        cchDescription = lstrlenW(pszDescription);
    }
 
    PrettifyFileDescriptionW(pszDescription, pszDisplayName);
 
    UINT cchResult = lstrlenW(pszDescription) + 1;
    if (pszOut)
    {
        UINT cchCopy = min(cchResult, *pcchOut);
        StringCchCopyW(pszOut, cchCopy, pszDescription);
        *pcchOut = cchCopy;
    }
    else
    {
        *pcchOut = cchResult;
    }
 
    if (pvBlock)
        LocalFree(pvBlock);
 
    return TRUE;
}

Referenced by SHGetFileDescriptionA().

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 410 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 393 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 305 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().

SHInvokeCommandsOnContextMenu()

EXTERN_C HRESULT WINAPI SHInvokeCommandsOnContextMenu	(	_In_opt_ HWND	hwnd,
		_In_opt_ IUnknown *	punkSite,
		_In_ IContextMenu *	pCM,
		_In_ DWORD	fMask,
		_In_reads_opt_(cVerbs) PCSTR *	pVerbs,
		_In_ UINT	cVerbs
	)

Definition at line 436 of file utils.cpp.

{
    HRESULT hr;
    CMINVOKECOMMANDINFOEX ici;
    WCHAR szVerbW[MAX_PATH];
    HMENU hMenu = NULL;
    UINT iVerb, idDefault = (UINT)-1;
    PCSTR pszVerbA = NULL;
 
    if (!pCM)
        return E_INVALIDARG;
 
    hMenu = CreatePopupMenu();
    if (!hMenu)
        return E_OUTOFMEMORY;
 
    if (punkSite)
        IUnknown_SetSite(pCM, punkSite);
 
    hr = pCM->QueryContextMenu(hMenu, 0, 1, MAXSHORT, (cVerbs ? 0 : CMF_DEFAULTONLY));
    if (FAILED(hr))
        goto Cleanup;
 
    if (!cVerbs)
    {
        idDefault = GetMenuDefaultItem(hMenu, FALSE, 0);
        if (idDefault != (UINT)-1)
            pszVerbA = MAKEINTRESOURCEA(idDefault - 1);
    }
 
    ZeroMemory(&ici, sizeof(ici));
    ici.cbSize = sizeof(ici);
    ici.hwnd   = hwnd;
    ici.nShow  = SW_SHOWNORMAL;
 
    iVerb = 0;
    do
    {
        if (cVerbs)
            pszVerbA = pVerbs[iVerb];
 
        if (!pszVerbA && idDefault == (UINT)-1)
        {
            hr = E_FAIL;
            break;
        }
 
        ici.fMask   = fMask;
        ici.lpVerb  = pszVerbA;
        ici.lpVerbW = NULL;
 
        if (idDefault == (UINT)-1 && !IS_INTRESOURCE(pszVerbA) && IsTextAsciiOnly(pszVerbA))
        {
            size_t ich;
            for (ich = 0; pszVerbA[ich] && ich + 1 < _countof(szVerbW); ++ich)
            {
                szVerbW[ich] = (BYTE)pszVerbA[ich];
            }
            szVerbW[ich] = UNICODE_NULL;
 
            ici.lpVerbW = szVerbW;
            ici.fMask |= CMIC_MASK_UNICODE;
        }
 
        hr = pCM->InvokeCommand((LPCMINVOKECOMMANDINFO)&ici);
 
        if (SUCCEEDED(hr) || hr == HRESULT_FROM_WIN32(ERROR_CANCELLED))
            break;
 
        ++iVerb;
    } while (iVerb < cVerbs);
 
Cleanup:
    if (punkSite)
        IUnknown_SetSite(pCM, NULL);
    DestroyMenu(hMenu);
    return hr;
}

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

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

Referenced by IShellFolder_GetDisplayNameOf().

SHRestrictedMessageBox()

EXTERN_C INT WINAPI SHRestrictedMessageBox

(

_In_ HWND

hWnd

)

Definition at line 1251 of file utils.cpp.

{
    return ShellMessageBoxW(shlwapi_hInstance, hWnd, MAKEINTRESOURCEW(IDS_RESTRICTED),
                            MAKEINTRESOURCEW(IDS_RESTRICTIONS), MB_ICONERROR);
}

Referenced by ShowFolderOptionsDialogThreadProc().

SHRunIndirectRegClientCommand()

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

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

UnExpandEnvironmentStringForUserA()

static BOOL UnExpandEnvironmentStringForUserA ( _In_ HANDLE  hUserToken, _In_ PCSTR  lpString, _In_ PCSTR  lpSrc, _Out_ PSTR  pszDest, _In_ INT  cchDest  )

static

Definition at line 48 of file utils.cpp.

{
    CHAR szBuff[MAX_PATH];
    INT cchExpanded;
 
    if (hUserToken)
    {
        if (ExpandEnvironmentStringsForUserA(hUserToken, lpSrc, szBuff, _countof(szBuff)))
            cchExpanded = lstrlenA(szBuff) + 1;
        else
            cchExpanded = 0;
    }
    else
    {
        cchExpanded = ExpandEnvironmentStringsA(lpSrc, szBuff, _countof(szBuff));
    }
 
    if (!cchExpanded || cchExpanded > cchDest)
        return FALSE;
 
    INT cchEnvPath = cchExpanded - 1;
    if (CompareStringA(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
                       szBuff, cchEnvPath, lpString, cchEnvPath) != CSTR_EQUAL)
    {
        return FALSE;
    }
 
    INT cchSuffix = lstrlenA(lpString) - cchEnvPath;
    if (lstrlenA(lpSrc) + cchSuffix >= cchDest)
        return FALSE;
 
    StringCchCopyA(pszDest, cchDest, lpSrc);
    StringCchCatA(pszDest, cchDest, &lpString[cchEnvPath]);
    return TRUE;
}

Referenced by PathUnExpandEnvStringsForUserA().

UnExpandEnvironmentStringForUserW()

static BOOL UnExpandEnvironmentStringForUserW ( _In_ HANDLE  hUserToken, _In_ PCWSTR  lpString, _In_ PCWSTR  lpSrc, _Out_ PWSTR  pszDest, _In_ INT  cchDest  )

static

Definition at line 90 of file utils.cpp.

{
    WCHAR szBuff[MAX_PATH];
    INT cchExpanded;
 
    if (hUserToken)
    {
        if (ExpandEnvironmentStringsForUserW(hUserToken, lpSrc, szBuff, _countof(szBuff)))
            cchExpanded = lstrlenW(szBuff) + 1;
        else
            cchExpanded = 0;
    }
    else
    {
        cchExpanded = ExpandEnvironmentStringsW(lpSrc, szBuff, _countof(szBuff));
    }
 
    if (!cchExpanded || cchExpanded > cchDest)
        return FALSE;
 
    INT cchEnvPath = cchExpanded - 1;
    if (CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
                       szBuff, cchEnvPath, lpString, cchEnvPath) != CSTR_EQUAL)
    {
        return FALSE;
    }
 
    INT cchSuffix = lstrlenW(lpString) - cchEnvPath;
    if (lstrlenW(lpSrc) + cchSuffix >= cchDest)
        return FALSE;
 
    StringCchCopyW(pszDest, cchDest, lpSrc);
    StringCchCatW(pszDest, cchDest, &lpString[cchEnvPath]);
    return TRUE;
}

Referenced by PathUnExpandEnvStringsForUserW().

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

Referenced by IShellFolder_GetDisplayNameOf().