CQueryAssociations Class Reference

#include <CQueryAssociations.h>

Inheritance diagram for CQueryAssociations:

Collaboration diagram for CQueryAssociations:

Classes
struct	RegKeyRef

Public Member Functions
	CQueryAssociations ()
	~CQueryAssociations ()
STDMETHOD()	Init (ASSOCF flags, LPCWSTR pwszAssoc, HKEY hkProgid, HWND hwnd) override
STDMETHOD()	GetString (ASSOCF flags, ASSOCSTR str, LPCWSTR pwszExtra, LPWSTR pwszOut, DWORD *pcchOut) override
STDMETHOD()	GetKey (ASSOCF flags, ASSOCKEY key, LPCWSTR pwszExtra, HKEY *phkeyOut) override
STDMETHOD()	GetData (ASSOCF flags, ASSOCDATA data, LPCWSTR pwszExtra, void *pvOut, DWORD *pcbOut) override
STDMETHOD()	GetEnum (ASSOCF cfFlags, ASSOCENUM assocenum, LPCWSTR pszExtra, REFIID riid, LPVOID *ppvOut) override
Public Member Functions inherited from ATL::CComObjectRootEx< CComMultiThreadModelNoCS >
	~CComObjectRootEx ()
ULONG	InternalAddRef ()
ULONG	InternalRelease ()
void	Lock ()
void	Unlock ()
HRESULT	_AtlInitialConstruct ()
Public Member Functions inherited from ATL::CComObjectRootBase
	CComObjectRootBase ()
	~CComObjectRootBase ()
void	SetVoid (void *)
HRESULT	_AtlFinalConstruct ()
HRESULT	FinalConstruct ()
void	InternalFinalConstructAddRef ()
void	InternalFinalConstructRelease ()
void	FinalRelease ()

Private Member Functions
bool	EmulateWin2000 () const
bool	IsNT5 () const
void	Reset ()
HRESULT	DuplicateHKey (HKEY hKey, HKEY *phKey)
HKEY	GetClassHandle () const
CQueryAssociations *	TryBaseClass (ASSOCF flags)
HRESULT	OpenShellVerbKey (ASSOCF flags, LPCWSTR pszVerb, LPCWSTR pszSubKey, RegKeyRef &KeyRef)
HRESULT	OpenShellVerbKey (ASSOCF flags, LPCWSTR pszVerb, RegKeyRef &KeyRef)
HRESULT	OpenDdeKey (ASSOCF flags, LPCWSTR pszExtra, RegKeyRef &KeyRef)
HRESULT	GetValue (HKEY hkey, const WCHAR *name, void **data, DWORD *data_size)
HRESULT	GetCommand (const WCHAR *extra, WCHAR **command)
HRESULT	GetExecutable (LPCWSTR pszExtra, LPWSTR path, DWORD pathlen, DWORD *len)
HRESULT	ReturnData (void *out, DWORD *outlen, const void *data, DWORD datalen)
HRESULT	ReturnRegData (ASSOCF flags, HKEY hKey, PCWSTR pszName, void *pvOut, DWORD *pcbOut)
HRESULT	ReturnString (ASSOCF flags, LPWSTR out, DWORD *outlen, LPCWSTR data, DWORD datalen)
HRESULT	ReturnAndFreeString (ASSOCF flags, LPWSTR out, DWORD *outlen, LPWSTR data, DWORD datalen)
HRESULT	ReturnAndFreeString (ASSOCF flags, LPWSTR out, DWORD *outlen, LPWSTR data)

Private Attributes
HKEY	hkeySource
HKEY	hkeyProgID
CComPtr< CQueryAssociations >	m_pBaseClass
ASSOCF	m_InitFlags
BYTE	m_InitType
bool	m_SkipBaseClass = false

Additional Inherited Members
Static Public Member Functions inherited from ATL::CComObjectRootBase
static void WINAPI	ObjectMain (bool)
static const struct _ATL_CATMAP_ENTRY *	GetCategoryMap ()
static HRESULT WINAPI	InternalQueryInterface (void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)
Public Attributes inherited from ATL::CComObjectRootBase
LONG	m_dwRef

Detailed Description

Definition at line 3 of file CQueryAssociations.h.

Constructor & Destructor Documentation

CQueryAssociations()

CQueryAssociations::CQueryAssociations

(

)

Definition at line 287 of file CQueryAssociations.cpp.

                                       : hkeySource(0), hkeyProgID(0), m_InitFlags(0), m_InitType(0)
{
}

~CQueryAssociations()

CQueryAssociations::~CQueryAssociations

(

)

Definition at line 291 of file CQueryAssociations.cpp.

{
    Reset();
}

Member Function Documentation

DuplicateHKey()

HRESULT CQueryAssociations::DuplicateHKey ( HKEY  hKey, HKEY *  phKey  )

private

Definition at line 306 of file CQueryAssociations.cpp.

{
    if (!hKey)
        return HResultFromWin32(IsNT5() ? ERROR_FILE_NOT_FOUND : ERROR_NO_ASSOCIATION);
    return SHRegDuplicateHKey(hKey, phKey);
}

Referenced by GetKey().

EmulateWin2000()

bool CQueryAssociations::EmulateWin2000 ( ) const

inlineprivate

Definition at line 51 of file CQueryAssociations.h.

{ return false; }

Referenced by Init(), and TryBaseClass().

GetClassHandle()

HKEY CQueryAssociations::GetClassHandle ( ) const

inlineprivate

Definition at line 55 of file CQueryAssociations.h.

{ return hkeyProgID ? hkeyProgID : hkeySource; }

Referenced by GetCommand(), GetData(), GetKey(), GetString(), Init(), OpenShellVerbKey(), and TryBaseClass().

GetCommand()

HRESULT CQueryAssociations::GetCommand ( const WCHAR *  extra, WCHAR **  command  )

private

Definition at line 889 of file CQueryAssociations.cpp.

{
    HKEY hClass = GetClassHandle();
    if (!hClass)
        return E_UNEXPECTED;
    return SH32_QueryAssocElementString(CLSID_AssocProgidElement, ASSOCQUERY_COMMAND, hClass, NULL, extra, command);
}

Referenced by GetExecutable(), and GetString().

GetData()

HRESULT STDMETHODCALLTYPE CQueryAssociations::GetData ( ASSOCF  flags, ASSOCDATA  data, LPCWSTR  pwszExtra, void *  pvOut, DWORD *  pcbOut  )

override

Definition at line 774 of file CQueryAssociations.cpp.

{
    TRACE("(%p,0x%8x,0x%8x,%s,%p,%p)\n", this, cfFlags, assocdata,
            debugstr_w(pszExtra), pvOut, pcbOut);
 
    enum { HANDLEDFLAGS = ASSOCF_IGNOREBASECLASS };
    HRESULT hr = HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
    HKEY hClass = GetClassHandle();
    RegKeyRef rkr;
 
    if (cfFlags & ~HANDLEDFLAGS)
        FIXME("Unsupported flags: %x\n", cfFlags & ~HANDLEDFLAGS);
 
    switch(assocdata)
    {
        case ASSOCDATA_NOACTIVATEHANDLER:
            if (SUCCEEDED(OpenDdeKey(cfFlags, pszExtra, rkr)))
                hr = ReturnRegData(cfFlags, rkr, L"NoActivateHandler", pvOut, pcbOut);
            break;
        case ASSOCDATA_QUERYCLASSSTORE:
            if (hClass)
                hr = ReturnRegData(cfFlags, hClass, L"QueryClassStore", pvOut, pcbOut);
            break;
        case ASSOCDATA_EDITFLAGS:
            if (hClass)
                hr = ReturnRegData(cfFlags, hClass, L"EditFlags", pvOut, pcbOut);
            break;
        case ASSOCDATA_VALUE:
            if (hClass)
                hr = ReturnRegData(cfFlags, hClass, pszExtra, pvOut, pcbOut);
            break;
        default:
        {
            FIXME("Unsupported ASSOCDATA value: %d\n", assocdata);
            return E_NOTIMPL;
        }
    }
    if (FAILED(hr) && TryBaseClass(cfFlags))
        hr = m_pBaseClass->GetData(cfFlags, assocdata, pszExtra, pvOut, pcbOut);
    return hr;
}

GetEnum()

HRESULT STDMETHODCALLTYPE CQueryAssociations::GetEnum ( ASSOCF  cfFlags, ASSOCENUM  assocenum, LPCWSTR  pszExtra, REFIID  riid, LPVOID *  ppvOut  )

override

Definition at line 850 of file CQueryAssociations.cpp.

{
    return E_NOTIMPL;
}

GetExecutable()

HRESULT CQueryAssociations::GetExecutable ( LPCWSTR  pszExtra, LPWSTR  path, DWORD  pathlen, DWORD *  len  )

private

Definition at line 897 of file CQueryAssociations.cpp.

{
    PWSTR pszCommand, pszStart, pszEnd, pszBuf, pszFree;
    HRESULT hr = this->GetCommand(pszExtra, &pszCommand);
    if (FAILED(hr))
        return hr;
 
    DWORD expLen = ExpandEnvironmentStringsW(pszCommand, NULL, 0);
    if (expLen > 0)
    {
        pszBuf = (PWSTR)SHAlloc(++expLen * sizeof(WCHAR));
        if (!pszBuf)
        {
            SHFree(pszCommand);
            return E_OUTOFMEMORY;
        }
        ExpandEnvironmentStringsW(pszCommand, pszBuf, expLen);
        SHFree(pszCommand);
        pszCommand = pszBuf;
    }
    pszFree = pszCommand;
 
    // ASSOCF_REMAPRUNDLL implied for ASSOCSTR_EXECUTABLE
    pszEnd = PathGetArgsW(pszCommand);
    WCHAR save = *pszEnd;
    *pszEnd = UNICODE_NULL;
    pszStart = PathFindFileNameW(pszCommand + (*pszCommand == '"'));
    *pszEnd = save;
    if (!StrCmpNIW(pszStart, L"rundll", _countof(L"rundll") - 1))
    {
        pszCommand = pszEnd;
        if ((pszEnd = StrChrW(pszCommand, ',')) != NULL)
            *pszEnd = UNICODE_NULL; // Remove comma and function name
    }
 
    /* cleanup pszCommand */
    if (pszCommand[0] == '"')
    {
        pszStart = pszCommand + 1;
        pszEnd = strchrW(pszStart, '"');
        if (pszEnd)
        {
            *pszEnd = 0;
        }
        *len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
    }
    else
    {
        pszStart = pszCommand;
        for (pszEnd = pszStart; (pszEnd = strchrW(pszEnd, ' ')); pszEnd++)
        {
            WCHAR c = *pszEnd;
            *pszEnd = 0;
            if ((*len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL)))
            {
                break;
            }
            *pszEnd = c;
        }
        if (!pszEnd)
        {
            *len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
        }
    }
 
    SHFree(pszFree);
    if (!*len)
    {
        return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
    }
    return S_OK;
}

Referenced by GetString().

GetKey()

HRESULT STDMETHODCALLTYPE CQueryAssociations::GetKey ( ASSOCF  flags, ASSOCKEY  key, LPCWSTR  pwszExtra, HKEY *  phkeyOut  )

override

Definition at line 691 of file CQueryAssociations.cpp.

{
    HRESULT hr = E_INVALIDARG;
    HKEY hClass = GetClassHandle();
    const CLSID *pAssocElement = NULL;
    ASSOCSTR strInit = (ASSOCSTR)0;
    WCHAR buf[MAX_PATH];
    PCWSTR pszSetString = NULL;
    *phkeyOut = NULL;  // Note: Windows does not check if the pointer is valid
 
    switch (assockey)
    {
        case ASSOCKEY_SHELLEXECCLASS:
            cfFlags |= ASSOCF_VERIFY;
            if (hClass && SUCCEEDED(hr = OpenClassWithShellExecKey(cfFlags, hClass, pszExtra, phkeyOut)))
                return hr;
            hr = HResultFromWin32(IsNT5() ? (hClass ? ERROR_FILE_NOT_FOUND : E_FAIL) : ERROR_NO_ASSOCIATION);
            break;
        case ASSOCKEY_APP:
            if (m_InitFlags & ASSOCF_INIT_BYEXENAME)
            {
                pszExtra = NULL; // Always ignored
                return DuplicateHKey(this->hkeySource, phkeyOut);
            }
            pAssocElement = &CLSID_AssocApplicationElement;
            strInit = ASSOCSTR_EXECUTABLE;
            hr = IsNT5() ? E_FAIL : HResultFromWin32(ERROR_NO_ASSOCIATION);
            break;
        case ASSOCKEY_CLASS: // "A ProgID or class key"
            if (hClass)
                return DuplicateHKey(hClass, phkeyOut);
            hr = IsNT5() ? E_FAIL : HResultFromWin32(ERROR_NOT_FOUND);
            break;
        case ASSOCKEY_BASECLASS:
            assockey = ASSOCKEY_CLASS;
            break;
        case ASSOCKEY_MAX:
            // fallthrough
        default:
            FIXME("(%p,0x%8x,0x%8x,%s,%p)\n", this, cfFlags, assockey, debugstr_w(pszExtra), phkeyOut);
    }
 
    if (strInit)
    {
        DWORD cch = _countof(buf);
        if (SUCCEEDED(GetString(ASSOCF_NOFIXUPS | ASSOCF_NOTRUNCATE | ASSOCF_INIT_IGNOREUNKNOWN, strInit, pszExtra, buf, &cch)))
            pszSetString = buf;
    }
    if (pAssocElement && pszSetString)
    {
        CComPtr<IPersistString2> pPS2;
        if (FAILED(SH32_AssocCreateElement(*pAssocElement, IID_PPV_ARG(IPersistString2, &pPS2))))
            return hr;
        if (FAILED(pPS2->SetString(pszSetString)))
            return hr;
        hr = GetKeyFromObjectWithQuerySource(*pPS2, phkeyOut);
    }
 
    if (FAILED(hr) && TryBaseClass(cfFlags))
        hr = m_pBaseClass->GetKey(cfFlags, assockey, pszExtra, phkeyOut);
    return hr;
}

GetString()

HRESULT STDMETHODCALLTYPE CQueryAssociations::GetString ( ASSOCF  flags, ASSOCSTR  str, LPCWSTR  pwszExtra, LPWSTR  pwszOut, DWORD *  pcchOut  )

override

Definition at line 478 of file CQueryAssociations.cpp.

{
    const ASSOCF unimplemented_flags = ~(ASSOCF_NOTRUNCATE | ASSOCF_IGNOREBASECLASS);
    DWORD len = 0;
    HRESULT hr = HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
    WCHAR path[MAX_PATH], *pszResult;
 
    TRACE("(%p)->(0x%08x, %u, %s, %p, %p)\n", this, flags, str, debugstr_w(pszExtra), pszOut, pcchOut);
    if (flags & unimplemented_flags)
    {
        FIXME("%08x: unimplemented flags\n", flags & unimplemented_flags);
    }
 
    if (!pcchOut)
        return E_UNEXPECTED;
 
    if (!GetClassHandle())
        goto trybase;
 
    switch (str)
    {
        case ASSOCSTR_COMMAND:
        {
            hr = this->GetCommand(pszExtra, &pszResult);
            if (SUCCEEDED(hr))
                return this->ReturnAndFreeString(flags, pszOut, pcchOut, pszResult);
            break;
        }
        case ASSOCSTR_EXECUTABLE:
        {
            hr = this->GetExecutable(pszExtra, path, MAX_PATH, &len);
            if (SUCCEEDED(hr))
                return this->ReturnString(flags, pszOut, pcchOut, path, ++len);
            break;
        }
        case ASSOCSTR_FRIENDLYDOCNAME:
        {
            WCHAR *pszFileType;
            // FIXME: Needs to check "FriendlyTypeName" first
            hr = this->GetValue(this->hkeySource, NULL, (void**)&pszFileType, NULL);
            if (FAILED(hr))
                goto trybase;
            DWORD size = 0;
            DWORD ret = RegGetValueW(HKEY_CLASSES_ROOT, pszFileType, NULL, RRF_RT_REG_SZ, NULL, NULL, &size);
            if (ret == ERROR_SUCCESS)
            {
                WCHAR *docName = static_cast<WCHAR *>(HeapAlloc(GetProcessHeap(), 0, size));
                if (docName)
                {
                    ret = RegGetValueW(HKEY_CLASSES_ROOT, pszFileType, NULL, RRF_RT_REG_SZ, NULL, docName, &size);
                    if (ret == ERROR_SUCCESS)
                    {
                        hr = this->ReturnString(flags, pszOut, pcchOut, docName, strlenW(docName) + 1);
                    }
                    else
                    {
                        hr = HRESULT_FROM_WIN32(ret);
                    }
                    HeapFree(GetProcessHeap(), 0, docName);
                }
                else
                {
                    hr = E_OUTOFMEMORY;
                }
            }
            else
            {
                hr = HRESULT_FROM_WIN32(ret);
            }
            HeapFree(GetProcessHeap(), 0, pszFileType);
            return hr;
        }
        case ASSOCSTR_FRIENDLYAPPNAME:
        {
            PVOID verinfoW = NULL;
            DWORD size, retval = 0;
            UINT flen;
            WCHAR *bufW;
            WCHAR fileDescW[41];
 
            hr = this->GetExecutable(pszExtra, path, MAX_PATH, &len);
            if (FAILED(hr))
            {
                return hr;
            }
            retval = GetFileVersionInfoSizeW(path, &size);
            if (!retval)
            {
                goto get_friendly_name_fail;
            }
            verinfoW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, retval);
            if (!verinfoW)
            {
                return E_OUTOFMEMORY;
            }
            if (!GetFileVersionInfoW(path, 0, retval, verinfoW))
            {
                goto get_friendly_name_fail;
            }
            if (VerQueryValueW(verinfoW, L"\\VarFileInfo\\Translation", (LPVOID *)&bufW, &flen))
            {
                UINT i;
                DWORD *langCodeDesc = (DWORD *)bufW;
                for (i = 0; i < flen / sizeof(DWORD); i++)
                {
                    sprintfW(fileDescW, L"\\StringFileInfo\\%04x%04x\\FileDescription",
                             LOWORD(langCodeDesc[i]), HIWORD(langCodeDesc[i]));
                    if (VerQueryValueW(verinfoW, fileDescW, (LPVOID *)&bufW, &flen))
                    {
                        /* Does strlenW(bufW) == 0 mean we use the filename? */
                        len = strlenW(bufW) + 1;
                        TRACE("found FileDescription: %s\n", debugstr_w(bufW));
                        hr = this->ReturnString(flags, pszOut, pcchOut, bufW, len);
                        HeapFree(GetProcessHeap(), 0, verinfoW);
                        return hr;
                    }
                }
            }
        get_friendly_name_fail:
            PathRemoveExtensionW(path);
            PathStripPathW(path);
            TRACE("using filename: %s\n", debugstr_w(path));
            hr = this->ReturnString(flags, pszOut, pcchOut, path, strlenW(path) + 1);
            HeapFree(GetProcessHeap(), 0, verinfoW);
            return hr;
        }
        case ASSOCSTR_CONTENTTYPE:
        {
            hr = SHELL_RegGetStringAlloc(this->hkeySource, NULL, L"Content Type", pszResult);
            if (SUCCEEDED(hr))
                return ReturnAndFreeString(flags, pszOut, pcchOut, pszResult, hr / sizeof(WCHAR));
            break;
        }
        case ASSOCSTR_DEFAULTICON:
        {
            for (HKEY hKey = GetClassHandle();; hKey = this->hkeySource)  // ProgId or .ext
            {
                hr = SHELL_RegGetStringAlloc(hKey, L"DefaultIcon", NULL, pszResult);
                if (SUCCEEDED(hr))
                    return ReturnAndFreeString(flags, pszOut, pcchOut, pszResult, hr / sizeof(WCHAR));
                else if (hKey == this->hkeySource)
                    break;
            }
            break;
        }
        case ASSOCSTR_INFOTIP:
        {
            hr = SHELL_RegGetStringAlloc(GetClassHandle(), NULL, L"InfoTip", pszResult);
            if (SUCCEEDED(hr))
                return ReturnAndFreeString(flags, pszOut, pcchOut, pszResult, hr / sizeof(WCHAR));
            // TODO: On Vista+, if not even the base class nor "*" provides a tip, it returns a default?
            break;
        }
        case ASSOCSTR_SHELLEXTENSION:
        {
            WCHAR keypath[ARRAY_SIZE(L"ShellEx\\") + 39], guid[39];
            CLSID clsid;
            HKEY hkey;
 
            hr = CLSIDFromString(pszExtra, &clsid);
            if (FAILED(hr))
            {
                return hr;
            }
            strcpyW(keypath, L"ShellEx\\");
            strcatW(keypath, pszExtra);
            LONG ret = RegOpenKeyExW(this->hkeySource, keypath, 0, KEY_READ, &hkey);
            if (ret)
            {
                return HRESULT_FROM_WIN32(ret);
            }
            DWORD size = sizeof(guid);
            ret = RegGetValueW(hkey, NULL, NULL, RRF_RT_REG_SZ, NULL, guid, &size);
            RegCloseKey(hkey);
            if (ret)
            {
                return HRESULT_FROM_WIN32(ret);
            }
            return this->ReturnString(flags, pszOut, pcchOut, guid, size / sizeof(WCHAR));
        }
 
        default:
        {
            FIXME("assocstr %d unimplemented!\n", str);
            return E_NOTIMPL;
        }
    }
trybase:
    if (FAILED(hr) && TryBaseClass(flags))
        hr = m_pBaseClass->GetString(flags, str, pszExtra, pszOut, pcchOut);
    return hr;
}

Referenced by GetKey().

GetValue()

HRESULT CQueryAssociations::GetValue ( HKEY  hkey, const WCHAR *  name, void **  data, DWORD *  data_size  )

private

Definition at line 860 of file CQueryAssociations.cpp.

{
    DWORD size;
    LONG ret;
 
    ret = SHQueryValueExW(hkey, name, 0, NULL, NULL, &size);
    if (ret != ERROR_SUCCESS)
        return HRESULT_FROM_WIN32(ret);
 
    if (!size)
        return E_FAIL;
 
    *data = HeapAlloc(GetProcessHeap(), 0, size);
    if (!*data)
        return E_OUTOFMEMORY;
 
    ret = SHQueryValueExW(hkey, name, 0, NULL, (LPBYTE)*data, &size);
    if (ret != ERROR_SUCCESS)
    {
        HeapFree(GetProcessHeap(), 0, *data);
        return HRESULT_FROM_WIN32(ret);
    }
 
    if (data_size)
        *data_size = size;
 
    return S_OK;
}

Referenced by GetString(), and ReturnRegData().

Init()

HRESULT STDMETHODCALLTYPE CQueryAssociations::Init ( ASSOCF  flags, LPCWSTR  pwszAssoc, HKEY  hkProgid, HWND  hwnd  )

override

Definition at line 381 of file CQueryAssociations.cpp.

{
    TRACE("(%p)->(%d,%s,%p,%p)\n", this,
                                    cfFlags,
                                    debugstr_w(pszAssoc),
                                    hkeyProgid,
                                    hWnd);
 
    enum { HANDLEDINITFLAGS = ASSOCF_INIT_BYEXENAME | ASSOCF_INIT_NOREMAPCLSID };
    HRESULT hr;
    Reset();
    m_InitFlags = cfFlags;
 
    if (hWnd != NULL)
        FIXME("hwnd != NULL not supported\n");
 
    if (cfFlags & ~HANDLEDINITFLAGS)
        FIXME("unsupported flags: %#x\n", cfFlags & ~HANDLEDINITFLAGS);
 
    if (pszAssoc != NULL)
    {
        WCHAR buf[sizeof("Applications") + MAX_PATH];
        m_InitType = *pszAssoc <= 0xff ? LOBYTE(*pszAssoc) : 'P';
 
        if (cfFlags & ASSOCF_INIT_BYEXENAME)
        {
            m_InitType = 'A';
            PCWSTR pszAppFile = PathFindFileNameW(pszAssoc);
            PCWSTR pszDotExt = *PathFindExtensionW(pszAppFile) ? L"" : L".exe";
            hr = StringCchPrintfW(buf, _countof(buf), L"%s\\%s%s", L"Applications", pszAppFile, pszDotExt);
            if (FAILED(hr))
                return hr;
            pszAssoc = buf;
        }
        else if (*pszAssoc == L'{')
        {
            if (!EmulateWin2000())
                cfFlags |= ASSOCF_INIT_NOREMAPCLSID;
        }
        else if (StrChrW(pszAssoc, L'\\'))
        {
            pszAssoc = PathFindExtensionW(pszAssoc);
            m_InitType = (BYTE)*pszAssoc;
        }
 
        if (!*pszAssoc)
            return E_INVALIDARG;
 
        if (m_InitType == '.')
        {
            if (RegOpenKeyExW(HKEY_CLASSES_ROOT, pszAssoc, 0, KEY_READ, &this->hkeySource))
                goto done;
        }
        else if (m_InitType != '{' && m_InitType != 'A')
        {
            m_InitType = 'P'; // ProgId
        }
 
        OpenClassKey(cfFlags, pszAssoc, &this->hkeyProgID);
        if (!this->hkeySource)
            this->hkeySource = this->hkeyProgID;
done:
        return (!GetClassHandle() && IsNT5()) ? S_FALSE : S_OK;
    }
    else if (hkeyProgid != NULL)
    {
        /* reopen the key so we don't end up closing a key owned by the caller */
        RegOpenKeyExW(hkeyProgid, NULL, 0, KEY_READ, &this->hkeyProgID);
        this->hkeySource = this->hkeyProgID;
        return S_OK;
    }
    else
    {
        return E_INVALIDARG;
    }
}

IsNT5()

bool CQueryAssociations::IsNT5 ( ) const

inlineprivate

Definition at line 52 of file CQueryAssociations.h.

{ return LOBYTE(GetVersion()) < 6; }

Referenced by DuplicateHKey(), GetKey(), Init(), ReturnData(), and ReturnString().

OpenDdeKey()

HRESULT CQueryAssociations::OpenDdeKey ( ASSOCF  flags, LPCWSTR  pszExtra, RegKeyRef &  KeyRef  )

inlineprivate

Definition at line 63 of file CQueryAssociations.h.

    {
        return OpenShellVerbKey(flags, pszExtra, L"ddeexec", KeyRef);
    }

Referenced by GetData().

OpenShellVerbKey() [1/2]

HRESULT CQueryAssociations::OpenShellVerbKey ( ASSOCF  flags, LPCWSTR  pszVerb, LPCWSTR  pszSubKey, RegKeyRef &  KeyRef  )

private

Definition at line 344 of file CQueryAssociations.cpp.

{
    HKEY hClass = GetClassHandle();
    if (!hClass)
        return HResultFromWin32(ERROR_NO_ASSOCIATION);
    HKEY hKey, hSubKey;
    HRESULT hr = ::OpenShellVerbKey(hClass, pszVerb, &hKey);
    if (FAILED(hr))
        return hr;
    
    if (pszSubKey)
    {
        hr = HResultFromWin32(RegOpenKeyExW(hKey, pszSubKey, 0, KEY_READ, &hSubKey));
        RegCloseKey(hKey);
        if (FAILED(hr))
            return hr;
        hKey = hSubKey;
    }
    KeyRef.Attach(hKey);
    return hr;
}

Referenced by OpenDdeKey(), and OpenShellVerbKey().

OpenShellVerbKey() [2/2]

HRESULT CQueryAssociations::OpenShellVerbKey ( ASSOCF  flags, LPCWSTR  pszVerb, RegKeyRef &  KeyRef  )

inlineprivate

Definition at line 59 of file CQueryAssociations.h.

    {
        return OpenShellVerbKey(flags, pszVerb, NULL, KeyRef);
    }

Reset()

void CQueryAssociations::Reset ( )

private

Definition at line 296 of file CQueryAssociations.cpp.

{
    if (hkeySource)
        RegCloseKey(hkeySource);
    if (hkeyProgID && hkeyProgID != hkeySource)
        RegCloseKey(hkeyProgID);
    hkeySource = hkeyProgID = NULL;
    m_InitType = 0;
}

Referenced by Init(), and ~CQueryAssociations().

ReturnAndFreeString() [1/2]

HRESULT CQueryAssociations::ReturnAndFreeString ( ASSOCF  flags, LPWSTR  out, DWORD *  outlen, LPWSTR  data  )

inlineprivate

Definition at line 80 of file CQueryAssociations.h.

    {
        return ReturnAndFreeString(flags, out, outlen, data, lstrlenW(data) + 1);
    }

ReturnAndFreeString() [2/2]

HRESULT CQueryAssociations::ReturnAndFreeString ( ASSOCF  flags, LPWSTR  out, DWORD *  outlen, LPWSTR  data, DWORD  datalen  )

inlineprivate

Definition at line 74 of file CQueryAssociations.h.

    {
        HRESULT hr = ReturnString(flags, out, outlen, data, datalen);
        SHFree(data);
        return hr;
    }

Referenced by GetString(), and ReturnAndFreeString().

ReturnData()

HRESULT CQueryAssociations::ReturnData ( void *  out, DWORD *  outlen, const void *  data, DWORD  datalen  )

private

Definition at line 970 of file CQueryAssociations.cpp.

{
    if (out)
    {
        DWORD lenNoReturn = PtrToUlong(outlen);
        if (IS_INTRESOURCE(outlen) && IsNT5())
            outlen = &lenNoReturn;
 
        if (*outlen < datalen)
        {
            *outlen = datalen;
            return E_POINTER;
        }
        *outlen = datalen;
        memcpy(out, data, datalen);
        return S_OK;
    }
    else
    {
        *outlen = datalen;
        return S_FALSE;
    }
}

Referenced by ReturnRegData().

ReturnRegData()

HRESULT CQueryAssociations::ReturnRegData ( ASSOCF  flags, HKEY  hKey, PCWSTR  pszName, void *  pvOut, DWORD *  pcbOut  )

private

Definition at line 816 of file CQueryAssociations.cpp.

{
    if (!pcbOut) // Asking if the data exists without returning it
        return RegValueExists(hKey, pszName) ? S_OK : S_FALSE;
 
    void *pData;
    DWORD cbData;
    HRESULT hr = this->GetValue(hKey, pszName, &pData, &cbData);
    if (FAILED(hr))
        return hr;
    hr = this->ReturnData(pvOut, pcbOut, pData, cbData);
    HeapFree(GetProcessHeap(), 0, pData);
    return hr;
}

Referenced by GetData().

ReturnString()

HRESULT CQueryAssociations::ReturnString ( ASSOCF  flags, LPWSTR  out, DWORD *  outlen, LPCWSTR  data, DWORD  datalen  )

private

Definition at line 994 of file CQueryAssociations.cpp.

{
    HRESULT hr = S_OK;
    DWORD len;
 
    TRACE("flags=0x%08x, data=%s\n", flags, debugstr_w(data));
 
    if (!out)
    {
        *outlen = datalen;
        return S_FALSE;
    }
 
    DWORD lenNoReturn = PtrToUlong(outlen);
    if (IS_INTRESOURCE(outlen) && IsNT5())
        outlen = &lenNoReturn;
 
    if (*outlen < datalen)
    {
        if (flags & ASSOCF_NOTRUNCATE)
        {
            len = 0;
            if (*outlen > 0) out[0] = 0;
            hr = E_POINTER;
        }
        else
        {
            len = min(*outlen, datalen);
            hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
        }
        *outlen = datalen;
    }
    else
    {
        *outlen = len = datalen;
    }
 
    if (len)
    {
        memcpy(out, data, len*sizeof(WCHAR));
    }
 
    return hr;
}

Referenced by GetString(), and ReturnAndFreeString().

TryBaseClass()

CQueryAssociations * CQueryAssociations::TryBaseClass ( ASSOCF  flags )

private

Definition at line 313 of file CQueryAssociations.cpp.

{
    if (m_SkipBaseClass || (flags & ASSOCF_IGNOREBASECLASS))
        return NULL;
    else if (m_pBaseClass)
        return m_pBaseClass;
 
    CComPtr<CQueryAssociations> pQA;
    if (FAILED(ShellObjectCreator(pQA)))
        return NULL;
 
    ASSOCF initflags = m_InitFlags & (ASSOCF_INIT_DEFAULTTOFOLDER | ASSOCF_INIT_DEFAULTTOSTAR);
    PWSTR classes[3] = { }; // Note: Without dynamic array support we can only emulate Windows 2000 here
    if (EmulateWin2000()) // BaseClass is present in the registry but it does not seem to act like a base class on XP+
        SHELL_RegGetStringAlloc(GetClassHandle(), NULL, L"BaseClass", classes[0]); // AudioCD/DVD etc.
    if (initflags & ASSOCF_INIT_DEFAULTTOFOLDER)
        classes[1] = const_cast<PWSTR>(L"Folder");
    if (initflags & ASSOCF_INIT_DEFAULTTOSTAR)
        classes[2] = const_cast<PWSTR>(L"*");
    for (UINT i = 0; i < _countof(classes); ++i, initflags = 0)
    {
        if (FAILED(pQA->Init(initflags, classes[i], 0, NULL)))
            continue;
        m_pBaseClass = pQA;
        break;
    }
    SHFree(classes[0]);
    m_SkipBaseClass = !m_pBaseClass;
    return m_pBaseClass;
}

Referenced by GetData(), GetKey(), and GetString().

Member Data Documentation

hkeyProgID

HKEY CQueryAssociations::hkeyProgID

private

Definition at line 45 of file CQueryAssociations.h.

Referenced by GetClassHandle(), Init(), and Reset().

hkeySource

HKEY CQueryAssociations::hkeySource

private

Definition at line 44 of file CQueryAssociations.h.

Referenced by GetClassHandle(), GetKey(), GetString(), Init(), and Reset().

m_InitFlags

ASSOCF CQueryAssociations::m_InitFlags

private

Definition at line 47 of file CQueryAssociations.h.

Referenced by GetKey(), Init(), and TryBaseClass().

m_InitType

BYTE CQueryAssociations::m_InitType

private

Definition at line 48 of file CQueryAssociations.h.

Referenced by Init(), and Reset().

m_pBaseClass

CComPtr<CQueryAssociations> CQueryAssociations::m_pBaseClass

private

Definition at line 46 of file CQueryAssociations.h.

Referenced by GetData(), GetKey(), GetString(), and TryBaseClass().

m_SkipBaseClass

bool CQueryAssociations::m_SkipBaseClass = false

private

Definition at line 49 of file CQueryAssociations.h.

Referenced by TryBaseClass().

---

The documentation for this class was generated from the following files:

• dll/win32/shell32/CQueryAssociations.h
• dll/win32/shell32/CQueryAssociations.cpp