CQueryAssociations Class Reference

#include <CQueryAssociations.h>

Inheritance diagram for CQueryAssociations:

Collaboration diagram for CQueryAssociations:

Public Member Functions
	CQueryAssociations ()
	~CQueryAssociations ()
virtual HRESULT STDMETHODCALLTYPE	Init (ASSOCF flags, LPCWSTR pwszAssoc, HKEY hkProgid, HWND hwnd)
virtual HRESULT STDMETHODCALLTYPE	GetString (ASSOCF flags, ASSOCSTR str, LPCWSTR pwszExtra, LPWSTR pwszOut, DWORD *pcchOut)
virtual HRESULT STDMETHODCALLTYPE	GetKey (ASSOCF flags, ASSOCKEY key, LPCWSTR pwszExtra, HKEY *phkeyOut)
virtual HRESULT STDMETHODCALLTYPE	GetData (ASSOCF flags, ASSOCDATA data, LPCWSTR pwszExtra, void *pvOut, DWORD *pcbOut)
virtual HRESULT STDMETHODCALLTYPE	GetEnum (ASSOCF cfFlags, ASSOCENUM assocenum, LPCWSTR pszExtra, REFIID riid, LPVOID *ppvOut)
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
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	ReturnString (ASSOCF flags, LPWSTR out, DWORD *outlen, LPCWSTR data, DWORD datalen)

Private Attributes
HKEY	hkeySource
HKEY	hkeyProgID

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 47 of file CQueryAssociations.cpp.

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

~CQueryAssociations()

CQueryAssociations::~CQueryAssociations

(

)

Definition at line 51 of file CQueryAssociations.cpp.

{
}

Member Function Documentation

GetCommand()

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

private

Definition at line 563 of file CQueryAssociations.cpp.

{
    HKEY hkeyCommand;
    HKEY hkeyShell;
    HKEY hkeyVerb;
    HRESULT hr;
    LONG ret;
    WCHAR *extra_from_reg = NULL;
    WCHAR *filetype;
 
    /* When looking for file extension it's possible to have a default value
     that points to another key that contains 'shell/<verb>/command' subtree. */
    hr = this->GetValue(this->hkeySource, NULL, (void**)&filetype, NULL);
    if (hr == S_OK)
    {
        HKEY hkeyFile;
 
        ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, filetype, 0, KEY_READ, &hkeyFile);
        HeapFree(GetProcessHeap(), 0, filetype);
 
        if (ret == ERROR_SUCCESS)
        {
            ret = RegOpenKeyExW(hkeyFile, L"shell", 0, KEY_READ, &hkeyShell);
            RegCloseKey(hkeyFile);
        }
        else
        {
            ret = RegOpenKeyExW(this->hkeySource, L"shell", 0, KEY_READ, &hkeyShell);
        }
    }
    else
    {
        ret = RegOpenKeyExW(this->hkeySource, L"shell", 0, KEY_READ, &hkeyShell);
    }
 
    if (ret)
    {
        return HRESULT_FROM_WIN32(ret);
    }
 
    if (!extra)
    {
        /* check for default verb */
        hr = this->GetValue(hkeyShell, NULL, (void**)&extra_from_reg, NULL);
        if (FAILED(hr))
        {
            /* no default verb, try first subkey */
            DWORD max_subkey_len;
 
            ret = RegQueryInfoKeyW(hkeyShell, NULL, NULL, NULL, NULL, &max_subkey_len, NULL, NULL, NULL, NULL, NULL, NULL);
            if (ret)
            {
                RegCloseKey(hkeyShell);
                return HRESULT_FROM_WIN32(ret);
            }
 
            max_subkey_len++;
            extra_from_reg = static_cast<WCHAR*>(HeapAlloc(GetProcessHeap(), 0, max_subkey_len * sizeof(WCHAR)));
            if (!extra_from_reg)
            {
                RegCloseKey(hkeyShell);
                return E_OUTOFMEMORY;
            }
 
            ret = RegEnumKeyExW(hkeyShell, 0, extra_from_reg, &max_subkey_len, NULL, NULL, NULL, NULL);
            if (ret)
            {
                HeapFree(GetProcessHeap(), 0, extra_from_reg);
                RegCloseKey(hkeyShell);
                return HRESULT_FROM_WIN32(ret);
            }
        }
        extra = extra_from_reg;
    }
 
    /* open verb subkey */
    ret = RegOpenKeyExW(hkeyShell, extra, 0, KEY_READ, &hkeyVerb);
    HeapFree(GetProcessHeap(), 0, extra_from_reg);
    RegCloseKey(hkeyShell);
    if (ret)
    {
        return HRESULT_FROM_WIN32(ret);
    }
    /* open command subkey */
    ret = RegOpenKeyExW(hkeyVerb, L"command", 0, KEY_READ, &hkeyCommand);
    RegCloseKey(hkeyVerb);
    if (ret)
    {
        return HRESULT_FROM_WIN32(ret);
    }
    hr = this->GetValue(hkeyCommand, NULL, (void**)command, NULL);
    RegCloseKey(hkeyCommand);
    return hr;
}

Referenced by GetExecutable(), and GetString().

GetData()

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

virtual

Definition at line 457 of file CQueryAssociations.cpp.

{
    TRACE("(%p,0x%8x,0x%8x,%s,%p,%p)\n", this, cfFlags, assocdata,
            debugstr_w(pszExtra), pvOut, pcbOut);
 
    if(cfFlags)
    {
        FIXME("Unsupported flags: %x\n", cfFlags);
    }
 
    switch(assocdata)
    {
        case ASSOCDATA_EDITFLAGS:
        {
            if(!this->hkeyProgID)
            {
                return HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
            }
 
            void *data;
            DWORD size;
            HRESULT hres = this->GetValue(this->hkeyProgID, L"EditFlags", &data, &size);
            if(FAILED(hres))
            {
                return hres;
            }
 
            if (!pcbOut)
            {
                HeapFree(GetProcessHeap(), 0, data);
                return hres;
            }
 
            hres = this->ReturnData(pvOut, pcbOut, data, size);
            HeapFree(GetProcessHeap(), 0, data);
            return hres;
        }
        default:
        {
            FIXME("Unsupported ASSOCDATA value: %d\n", assocdata);
            return E_NOTIMPL;
        }
    }
}

GetEnum()

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

virtual

Definition at line 521 of file CQueryAssociations.cpp.

{
    return E_NOTIMPL;
}

GetExecutable()

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

private

Definition at line 658 of file CQueryAssociations.cpp.

{
    WCHAR *pszCommand;
    WCHAR *pszStart;
    WCHAR *pszEnd;
 
    HRESULT hr = this->GetCommand(pszExtra, &pszCommand);
    if (FAILED(hr))
    {
        return hr;
    }
 
    DWORD expLen = ExpandEnvironmentStringsW(pszCommand, NULL, 0);
    if (expLen > 0)
    {
        expLen++;
        WCHAR *buf = static_cast<WCHAR *>(HeapAlloc(GetProcessHeap(), 0, expLen * sizeof(WCHAR)));
        ExpandEnvironmentStringsW(pszCommand, buf, expLen);
        HeapFree(GetProcessHeap(), 0, pszCommand);
        pszCommand = buf;
    }
 
    /* 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);
        }
    }
 
    HeapFree(GetProcessHeap(), 0, pszCommand);
    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  )

virtual

Definition at line 430 of file CQueryAssociations.cpp.

{
    FIXME("(%p,0x%8x,0x%8x,%s,%p)-stub!\n", this, cfFlags, assockey,
            debugstr_w(pszExtra), phkeyOut);
    return E_NOTIMPL;
}

GetString()

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

virtual

Definition at line 175 of file CQueryAssociations.cpp.

{
    const ASSOCF unimplemented_flags = ~ASSOCF_NOTRUNCATE;
    DWORD len = 0;
    HRESULT hr;
    WCHAR path[MAX_PATH];
 
    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 (!this->hkeySource && !this->hkeyProgID)
    {
        return HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
    }
 
    switch (str)
    {
        case ASSOCSTR_COMMAND:
        {
            WCHAR *command;
            hr = this->GetCommand(pszExtra, &command);
            if (SUCCEEDED(hr))
            {
                hr = this->ReturnString(flags, pszOut, pcchOut, command, strlenW(command) + 1);
                HeapFree(GetProcessHeap(), 0, command);
            }
            return hr;
        }
        case ASSOCSTR_EXECUTABLE:
        {
            hr = this->GetExecutable(pszExtra, path, MAX_PATH, &len);
            if (FAILED(hr))
            {
                return hr;
            }
            len++;
            return this->ReturnString(flags, pszOut, pcchOut, path, len);
        }
        case ASSOCSTR_FRIENDLYDOCNAME:
        {
            WCHAR *pszFileType;
 
            hr = this->GetValue(this->hkeySource, NULL, (void**)&pszFileType, NULL);
            if (FAILED(hr))
            {
                return hr;
            }
            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:
        {
            DWORD size = 0;
            DWORD ret = RegGetValueW(this->hkeySource, NULL, L"Content Type", RRF_RT_REG_SZ, NULL, NULL, &size);
            if (ret != ERROR_SUCCESS)
            {
                return HRESULT_FROM_WIN32(ret);
            }
            WCHAR *contentType = static_cast<WCHAR *>(HeapAlloc(GetProcessHeap(), 0, size));
            if (contentType != NULL)
            {
                ret = RegGetValueW(this->hkeySource, NULL, L"Content Type", RRF_RT_REG_SZ, NULL, contentType, &size);
                if (ret == ERROR_SUCCESS)
                {
                    hr = this->ReturnString(flags, pszOut, pcchOut, contentType, strlenW(contentType) + 1);
                }
                else
                {
                    hr = HRESULT_FROM_WIN32(ret);
                }
                HeapFree(GetProcessHeap(), 0, contentType);
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
            return hr;
        }
        case ASSOCSTR_DEFAULTICON:
        {
            DWORD ret;
            DWORD size = 0;
            ret = RegGetValueW(this->hkeyProgID, L"DefaultIcon", NULL, RRF_RT_REG_SZ, NULL, NULL, &size);
            if (ret == ERROR_SUCCESS)
            {
                WCHAR *icon = static_cast<WCHAR *>(HeapAlloc(GetProcessHeap(), 0, size));
                if (icon)
                {
                    ret = RegGetValueW(this->hkeyProgID, L"DefaultIcon", NULL, RRF_RT_REG_SZ, NULL, icon, &size);
                    if (ret == ERROR_SUCCESS)
                    {
                        hr = this->ReturnString(flags, pszOut, pcchOut, icon, strlenW(icon) + 1);
                    }
                    else
                    {
                        hr = HRESULT_FROM_WIN32(ret);
                    }
                    HeapFree(GetProcessHeap(), 0, icon);
                }
                else
                {
                    hr = HRESULT_FROM_WIN32(ret);
                }
            }
            else
            {
                hr = HRESULT_FROM_WIN32(ret);
            }
            return hr;
        }
        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;
        }
    }
}

GetValue()

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

private

Definition at line 531 of file CQueryAssociations.cpp.

{
    DWORD size;
    LONG ret;
 
    ret = RegQueryValueExW(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 = RegQueryValueExW(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 GetCommand(), GetData(), GetString(), and Init().

Init()

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

virtual

Definition at line 70 of file CQueryAssociations.cpp.

{
    TRACE("(%p)->(%d,%s,%p,%p)\n", this,
                                    cfFlags,
                                    debugstr_w(pszAssoc),
                                    hkeyProgid,
                                    hWnd);
 
    if (hWnd != NULL)
    {
        FIXME("hwnd != NULL not supported\n");
    }
 
    if (cfFlags != 0)
    {
        FIXME("unsupported flags: %x\n", cfFlags);
    }
 
    RegCloseKey(this->hkeySource);
    RegCloseKey(this->hkeyProgID);
    this->hkeySource = this->hkeyProgID = NULL;
    if (pszAssoc != NULL)
    {
        WCHAR *progId;
        HRESULT hr;
 
        LONG ret = RegOpenKeyExW(HKEY_CLASSES_ROOT,
                            pszAssoc,
                            0,
                            KEY_READ,
                            &this->hkeySource);
        if (ret)
        {
            return S_OK;
        }
 
        /* if this is a progid */
        if (*pszAssoc != '.' && *pszAssoc != '{')
        {
            this->hkeyProgID = this->hkeySource;
            return S_OK;
        }
 
        /* if it's not a progid, it's a file extension or clsid */
        if (*pszAssoc == '.')
        {
            /* for a file extension, the progid is the default value */
            hr = this->GetValue(this->hkeySource, NULL, (void**)&progId, NULL);
            if (FAILED(hr))
                return S_OK;
        }
        else /* if (*pszAssoc == '{') */
        {
            HKEY progIdKey;
            /* for a clsid, the progid is the default value of the ProgID subkey */
            ret = RegOpenKeyExW(this->hkeySource, L"ProgID", 0, KEY_READ, &progIdKey);
            if (ret != ERROR_SUCCESS)
                return S_OK;
            hr = this->GetValue(progIdKey, NULL, (void**)&progId, NULL);
            if (FAILED(hr))
                return S_OK;
            RegCloseKey(progIdKey);
        }
 
        /* open the actual progid key, the one with the shell subkey */
        ret = RegOpenKeyExW(HKEY_CLASSES_ROOT,
                            progId,
                            0,
                            KEY_READ,
                            &this->hkeyProgID);
        HeapFree(GetProcessHeap(), 0, progId);
 
        return 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;
}

ReturnData()

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

private

Definition at line 718 of file CQueryAssociations.cpp.

{
    if (out)
    {
        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 GetData().

ReturnString()

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

private

Definition at line 738 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;
    }
 
    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
    {
        len = datalen;
    }
 
    if (len)
    {
        memcpy(out, data, len*sizeof(WCHAR));
    }
 
    return hr;
}

Referenced by GetString().

Member Data Documentation

hkeyProgID

HKEY CQueryAssociations::hkeyProgID

private

Definition at line 10 of file CQueryAssociations.h.

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

hkeySource

HKEY CQueryAssociations::hkeySource

private

Definition at line 9 of file CQueryAssociations.h.

Referenced by GetCommand(), GetString(), and Init().

---

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

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