You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
654 lines
16 KiB
654 lines
16 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1997 - 1999
|
|
//
|
|
// File: items.cpp
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
#pragma hdrstop
|
|
|
|
#include <shlwapip.h> // QITAB, QISearch
|
|
#include <shsemip.h> // ILFree(), etc
|
|
|
|
#include "folder.h"
|
|
#include "items.h"
|
|
#include "strings.h"
|
|
|
|
CLIPFORMAT COfflineItemsData::m_cfHDROP;
|
|
CLIPFORMAT COfflineItemsData::m_cfFileContents;
|
|
CLIPFORMAT COfflineItemsData::m_cfFileDesc;
|
|
CLIPFORMAT COfflineItemsData::m_cfPreferedEffect;
|
|
CLIPFORMAT COfflineItemsData::m_cfPerformedEffect;
|
|
CLIPFORMAT COfflineItemsData::m_cfLogicalPerformedEffect;
|
|
CLIPFORMAT COfflineItemsData::m_cfDataSrcClsid;
|
|
|
|
COfflineItemsData::COfflineItemsData(
|
|
LPCITEMIDLIST pidlFolder,
|
|
UINT cidl,
|
|
LPCITEMIDLIST *apidl,
|
|
HWND hwndParent,
|
|
IShellFolder *psfOwner, // Optional. Default is NULL.
|
|
IDataObject *pdtInner // Optional. Default is NULL.
|
|
) : CIDLData(pidlFolder,
|
|
cidl,
|
|
apidl,
|
|
psfOwner,
|
|
pdtInner),
|
|
m_hwndParent(hwndParent),
|
|
m_rgpolid(NULL),
|
|
m_hrCtor(NOERROR),
|
|
m_dwPreferredEffect(DROPEFFECT_COPY),
|
|
m_dwPerformedEffect(DROPEFFECT_NONE),
|
|
m_dwLogicalPerformedEffect(DROPEFFECT_NONE),
|
|
m_cItems(0)
|
|
{
|
|
if (0 == m_cfHDROP)
|
|
{
|
|
m_cfHDROP = CF_HDROP;
|
|
m_cfFileContents = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_FILECONTENTS);
|
|
m_cfFileDesc = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR);
|
|
m_cfPreferedEffect = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_PREFERREDDROPEFFECT);
|
|
m_cfPerformedEffect = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_PERFORMEDDROPEFFECT);
|
|
m_cfLogicalPerformedEffect = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_LOGICALPERFORMEDDROPEFFECT);
|
|
m_cfDataSrcClsid = (CLIPFORMAT)RegisterClipboardFormat(c_szCFDataSrcClsid);
|
|
}
|
|
|
|
m_hrCtor = CIDLData::CtorResult();
|
|
if (SUCCEEDED(m_hrCtor))
|
|
{
|
|
m_rgpolid = new LPCOLID[cidl];
|
|
if (m_rgpolid)
|
|
{
|
|
ZeroMemory(m_rgpolid, sizeof(LPCOLID) * cidl);
|
|
m_cItems = cidl;
|
|
for (UINT i = 0; i < cidl; i++)
|
|
{
|
|
m_rgpolid[i] = (LPCOLID)ILClone(apidl[i]);
|
|
if (!m_rgpolid[i])
|
|
{
|
|
m_hrCtor = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
m_hrCtor = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
COfflineItemsData::~COfflineItemsData(
|
|
void
|
|
)
|
|
{
|
|
delete[] m_rgpolid;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
COfflineItemsData::CreateInstance(
|
|
COfflineItemsData **ppOut,
|
|
LPCITEMIDLIST pidlFolder,
|
|
UINT cidl,
|
|
LPCITEMIDLIST *apidl,
|
|
HWND hwndParent,
|
|
IShellFolder *psfOwner,
|
|
IDataObject *pdtInner
|
|
)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
COfflineItemsData *pNew = new COfflineItemsData(pidlFolder,
|
|
cidl,
|
|
apidl,
|
|
hwndParent,
|
|
psfOwner,
|
|
pdtInner);
|
|
if (NULL != pNew)
|
|
{
|
|
hr = pNew->CtorResult();
|
|
if (SUCCEEDED(hr))
|
|
*ppOut = pNew;
|
|
else
|
|
delete pNew;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
COfflineItemsData::CreateInstance(
|
|
IDataObject **ppOut,
|
|
LPCITEMIDLIST pidlFolder,
|
|
UINT cidl,
|
|
LPCITEMIDLIST *apidl,
|
|
HWND hwndParent,
|
|
IShellFolder *psfOwner,
|
|
IDataObject *pdtInner
|
|
)
|
|
{
|
|
COfflineItemsData *poid;
|
|
HRESULT hr = CreateInstance(&poid,
|
|
pidlFolder,
|
|
cidl,
|
|
apidl,
|
|
hwndParent,
|
|
psfOwner,
|
|
pdtInner);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
poid->AddRef();
|
|
hr = poid->QueryInterface(IID_IDataObject, (void **)ppOut);
|
|
poid->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
COfflineItemsData::GetData(
|
|
FORMATETC *pFEIn,
|
|
STGMEDIUM *pstm
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
|
|
pstm->hGlobal = NULL;
|
|
pstm->pUnkForRelease = NULL;
|
|
|
|
if ((pFEIn->cfFormat == m_cfHDROP) && (pFEIn->tymed & TYMED_HGLOBAL))
|
|
hr = CreateHDROP(pstm);
|
|
else if ((pFEIn->cfFormat == m_cfFileDesc) && (pFEIn->tymed & TYMED_HGLOBAL))
|
|
hr = CreateFileDescriptor(pstm);
|
|
else if ((pFEIn->cfFormat == m_cfFileContents) && (pFEIn->tymed & TYMED_ISTREAM))
|
|
hr = CreateFileContents(pstm, pFEIn->lindex);
|
|
else if ((pFEIn->cfFormat == m_cfPreferedEffect) && (pFEIn->tymed & TYMED_HGLOBAL))
|
|
hr = CreatePrefDropEffect(pstm);
|
|
else if ((pFEIn->cfFormat == m_cfPerformedEffect) && (pFEIn->tymed & TYMED_HGLOBAL))
|
|
hr = CreatePerformedDropEffect(pstm);
|
|
else if ((pFEIn->cfFormat == m_cfLogicalPerformedEffect) && (pFEIn->tymed & TYMED_HGLOBAL))
|
|
hr = CreateLogicalPerformedDropEffect(pstm);
|
|
else if ((pFEIn->cfFormat == m_cfDataSrcClsid) && (pFEIn->tymed & TYMED_HGLOBAL))
|
|
hr = CreateDataSrcClsid(pstm);
|
|
else
|
|
hr = CIDLData::GetData(pFEIn, pstm);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
DWORD COfflineItemsData::GetDataDWORD(
|
|
FORMATETC *pfe,
|
|
STGMEDIUM *pstm,
|
|
DWORD *pdwOut
|
|
)
|
|
{
|
|
if (pfe->tymed == TYMED_HGLOBAL)
|
|
{
|
|
DWORD *pdw = (DWORD *)GlobalLock(pstm->hGlobal);
|
|
if (pdw)
|
|
{
|
|
*pdwOut = *pdw;
|
|
GlobalUnlock(pstm->hGlobal);
|
|
}
|
|
}
|
|
return *pdwOut;
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
COfflineItemsData::SetData(
|
|
FORMATETC *pFEIn,
|
|
STGMEDIUM *pstm,
|
|
BOOL fRelease
|
|
)
|
|
{
|
|
if (pFEIn->cfFormat == g_cfPerformedDropEffect)
|
|
{
|
|
GetDataDWORD(pFEIn, pstm, &m_dwPerformedEffect);
|
|
}
|
|
else if (pFEIn->cfFormat == g_cfLogicalPerformedDropEffect)
|
|
{
|
|
GetDataDWORD(pFEIn, pstm, &m_dwLogicalPerformedEffect);
|
|
}
|
|
else if (pFEIn->cfFormat == g_cfPreferredDropEffect)
|
|
{
|
|
GetDataDWORD(pFEIn, pstm, &m_dwPreferredEffect);
|
|
}
|
|
|
|
return CIDLData::SetData(pFEIn, pstm, fRelease);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
COfflineItemsData::QueryGetData(
|
|
FORMATETC *pFEIn
|
|
)
|
|
{
|
|
if (pFEIn->cfFormat == m_cfHDROP ||
|
|
pFEIn->cfFormat == m_cfFileDesc ||
|
|
pFEIn->cfFormat == m_cfFileContents ||
|
|
pFEIn->cfFormat == m_cfPreferedEffect ||
|
|
pFEIn->cfFormat == m_cfPerformedEffect ||
|
|
pFEIn->cfFormat == m_cfLogicalPerformedEffect ||
|
|
pFEIn->cfFormat == m_cfDataSrcClsid)
|
|
{
|
|
return S_OK;
|
|
}
|
|
return CIDLData::QueryGetData(pFEIn);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
COfflineItemsData::ProvideFormats(
|
|
CEnumFormatEtc *pEnumFmtEtc
|
|
)
|
|
{
|
|
FORMATETC rgFmtEtc[] = {
|
|
{ m_cfHDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ m_cfFileContents, NULL, DVASPECT_CONTENT, -1, TYMED_ISTREAM },
|
|
{ m_cfFileDesc, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ m_cfPreferedEffect, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ m_cfPerformedEffect, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ m_cfLogicalPerformedEffect, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ m_cfDataSrcClsid, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }
|
|
};
|
|
//
|
|
// Add our formats to the CIDLData format enumerator.
|
|
//
|
|
return pEnumFmtEtc->AddFormats(ARRAYSIZE(rgFmtEtc), rgFmtEtc);
|
|
}
|
|
|
|
HRESULT
|
|
COfflineItemsData::CreateFileDescriptor(
|
|
STGMEDIUM *pstm
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
pstm->tymed = TYMED_HGLOBAL;
|
|
pstm->pUnkForRelease = NULL;
|
|
|
|
// render the file descriptor
|
|
// we only allocate for m_cItems-1 file descriptors because the filegroup
|
|
// descriptor has already allocated space for 1.
|
|
FILEGROUPDESCRIPTOR *pfgd = (FILEGROUPDESCRIPTOR *)GlobalAlloc(GPTR, sizeof(FILEGROUPDESCRIPTOR) + (m_cItems - 1) * sizeof(FILEDESCRIPTOR));
|
|
if (pfgd)
|
|
{
|
|
pfgd->cItems = m_cItems; // set the number of items
|
|
pfgd->fgd[0].dwFlags = FD_PROGRESSUI; // turn on progress UI
|
|
|
|
for (int i = 0; i < m_cItems; i++)
|
|
{
|
|
FILEDESCRIPTOR *pfd = &(pfgd->fgd[i]);
|
|
COfflineFilesFolder::OLID_GetFileName(m_rgpolid[i], pfd->cFileName, ARRAYSIZE(pfd->cFileName));
|
|
}
|
|
|
|
pstm->hGlobal = pfgd;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
COfflineItemsData::CreatePrefDropEffect(
|
|
STGMEDIUM *pstm
|
|
)
|
|
{
|
|
return CreateDWORD(pstm, m_dwPreferredEffect);
|
|
}
|
|
|
|
HRESULT
|
|
COfflineItemsData::CreatePerformedDropEffect(
|
|
STGMEDIUM *pstm
|
|
)
|
|
{
|
|
return CreateDWORD(pstm, m_dwPerformedEffect);
|
|
}
|
|
|
|
HRESULT
|
|
COfflineItemsData::CreateLogicalPerformedDropEffect(
|
|
STGMEDIUM *pstm
|
|
)
|
|
{
|
|
return CreateDWORD(pstm, m_dwLogicalPerformedEffect);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
COfflineItemsData::CreateDWORD(
|
|
STGMEDIUM *pstm,
|
|
DWORD dwEffect
|
|
)
|
|
{
|
|
pstm->tymed = TYMED_HGLOBAL;
|
|
pstm->pUnkForRelease = NULL;
|
|
pstm->hGlobal = GlobalAlloc(GPTR, sizeof(DWORD));
|
|
if (pstm->hGlobal)
|
|
{
|
|
*((DWORD *)pstm->hGlobal) = dwEffect;
|
|
return S_OK;
|
|
}
|
|
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
HRESULT
|
|
COfflineItemsData::CreateFileContents(
|
|
STGMEDIUM *pstm,
|
|
LONG lindex
|
|
)
|
|
{
|
|
// here's a partial fix for when ole sometimes passes in -1 for lindex
|
|
if (lindex == -1)
|
|
{
|
|
if (m_cItems == 1)
|
|
lindex = 0;
|
|
else
|
|
return E_FAIL;
|
|
}
|
|
|
|
pstm->tymed = TYMED_ISTREAM;
|
|
pstm->pUnkForRelease = NULL;
|
|
|
|
TCHAR szPath[MAX_PATH];
|
|
HRESULT hr = COfflineFilesFolder::OLID_GetFullPath(m_rgpolid[lindex], szPath, ARRAYSIZE(szPath));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHCreateStreamOnFile(szPath, STGM_READ, &pstm->pstm);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
COfflineItemsData::CreateHDROP(
|
|
STGMEDIUM *pstm
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
|
|
int i;
|
|
//
|
|
// The extra MAX_PATH is so that the damned SHLWAPI functions (i.e.
|
|
// PathAppend) won't complain about a too-small buffer. They require
|
|
// that the destination buffer be AT LEAST MAX_PATH. So much for letting
|
|
// code being smart about buffer sizes.
|
|
//
|
|
int cbHdrop = sizeof(DROPFILES) + (MAX_PATH * sizeof(TCHAR)) + sizeof(TEXT('\0'));
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
pstm->tymed = TYMED_HGLOBAL;
|
|
pstm->pUnkForRelease = NULL;
|
|
|
|
//
|
|
// Calculate required buffer size.
|
|
//
|
|
for (i = 0; i < m_cItems; i++)
|
|
{
|
|
szPath[0] = TEXT('\0');
|
|
hr = COfflineFilesFolder::OLID_GetFullPath(m_rgpolid[i], szPath, ARRAYSIZE(szPath));
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
cbHdrop += (lstrlen(szPath) + 1) * sizeof(TCHAR);
|
|
}
|
|
pstm->hGlobal = GlobalAlloc(GPTR, cbHdrop);
|
|
if (NULL != pstm->hGlobal)
|
|
{
|
|
//
|
|
// Fill out the header and append the file paths in a
|
|
// double-nul term list.
|
|
//
|
|
LPDROPFILES pdfHdr = (LPDROPFILES)pstm->hGlobal;
|
|
pdfHdr->pFiles = sizeof(DROPFILES);
|
|
pdfHdr->fWide = TRUE;
|
|
|
|
LPTSTR pszWrite = (LPTSTR)((LPBYTE)pdfHdr + sizeof(DROPFILES));
|
|
LPTSTR pszEnd = (LPTSTR)((LPBYTE)pstm->hGlobal + cbHdrop - sizeof(TCHAR));
|
|
for (i = 0; i < m_cItems; i++)
|
|
{
|
|
// We allocated enough, so this should never fail
|
|
if (SUCCEEDED(COfflineFilesFolder::OLID_GetFullPath(m_rgpolid[i], pszWrite, (UINT)(pszEnd - pszWrite))))
|
|
{
|
|
pszWrite += lstrlen(pszWrite) + 1;
|
|
}
|
|
}
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
COfflineItemsData::CreateDataSrcClsid(
|
|
STGMEDIUM *pstm
|
|
)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
|
|
pstm->tymed = TYMED_HGLOBAL;
|
|
pstm->pUnkForRelease = NULL;
|
|
pstm->hGlobal = GlobalAlloc(GPTR, sizeof(CLSID));
|
|
if (pstm->hGlobal)
|
|
{
|
|
*((CLSID *)pstm->hGlobal) = CLSID_OfflineFilesFolder;
|
|
return S_OK;
|
|
}
|
|
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
|
|
COfflineItems::COfflineItems(
|
|
COfflineFilesFolder *pFolder,
|
|
HWND hwnd
|
|
) : m_cRef(1),
|
|
m_hwndBrowser(hwnd),
|
|
m_pFolder(pFolder),
|
|
m_ppolid(NULL),
|
|
m_cItems(0)
|
|
{
|
|
DllAddRef();
|
|
if (m_pFolder)
|
|
m_pFolder->AddRef();
|
|
}
|
|
|
|
COfflineItems::~COfflineItems()
|
|
{
|
|
if (m_pFolder)
|
|
m_pFolder->Release();
|
|
|
|
if (m_ppolid)
|
|
{
|
|
for (UINT i = 0; i < m_cItems; i++)
|
|
{
|
|
if (m_ppolid[i])
|
|
ILFree((LPITEMIDLIST)m_ppolid[i]);
|
|
}
|
|
LocalFree((HLOCAL)m_ppolid);
|
|
}
|
|
|
|
DllRelease();
|
|
}
|
|
|
|
|
|
HRESULT
|
|
COfflineItems::Initialize(
|
|
UINT cidl,
|
|
LPCITEMIDLIST *ppidl
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
m_ppolid = (LPCOLID *)LocalAlloc(LPTR, cidl * sizeof(LPCOLID));
|
|
if (m_ppolid)
|
|
{
|
|
m_cItems = cidl;
|
|
hr = S_OK;
|
|
for (UINT i = 0; i < cidl; i++)
|
|
{
|
|
m_ppolid[i] = (LPCOLID)ILClone(ppidl[i]);
|
|
if (!m_ppolid[i])
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
COfflineItems::CreateInstance(
|
|
COfflineFilesFolder *pfolder,
|
|
HWND hwnd,
|
|
UINT cidl,
|
|
LPCITEMIDLIST *ppidl,
|
|
REFIID riid,
|
|
void **ppv)
|
|
{
|
|
HRESULT hr;
|
|
|
|
*ppv = NULL; // null the out param
|
|
|
|
COfflineItems *pitems = new COfflineItems(pfolder, hwnd);
|
|
if (pitems)
|
|
{
|
|
hr = pitems->Initialize(cidl, ppidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pitems->QueryInterface(riid, ppv);
|
|
}
|
|
pitems->Release();
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
COfflineItems::QueryInterface(
|
|
REFIID iid,
|
|
void **ppv
|
|
)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(COfflineItems, IContextMenu),
|
|
QITABENT(COfflineItems, IQueryInfo),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, iid, ppv);
|
|
}
|
|
|
|
|
|
ULONG
|
|
COfflineItems::AddRef(
|
|
void
|
|
)
|
|
{
|
|
return InterlockedIncrement(&m_cRef);
|
|
}
|
|
|
|
|
|
ULONG
|
|
COfflineItems::Release(
|
|
void
|
|
)
|
|
{
|
|
ASSERT( 0 != m_cRef );
|
|
ULONG cRef = InterlockedDecrement(&m_cRef);
|
|
if ( 0 == cRef )
|
|
{
|
|
delete this;
|
|
}
|
|
return cRef;
|
|
}
|
|
|
|
//
|
|
// IQueryInfo Methods -------------------------------------------------------
|
|
//
|
|
HRESULT
|
|
COfflineItems::GetInfoTip(
|
|
DWORD dwFlags,
|
|
WCHAR **ppwszTip
|
|
)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
HRESULT hr = COfflineFilesFolder::OLID_GetFullPath(m_ppolid[0], szPath, ARRAYSIZE(szPath));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHStrDup(szPath, ppwszTip);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
COfflineItems::GetInfoFlags(
|
|
DWORD *pdwFlags
|
|
)
|
|
{
|
|
*pdwFlags = 0;
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// IContextMenu Methods -------------------------------------------------------
|
|
//
|
|
HRESULT
|
|
COfflineItems::QueryContextMenu(
|
|
HMENU hmenu,
|
|
UINT indexMenu,
|
|
UINT idCmdFirst,
|
|
UINT idCmdLast,
|
|
UINT uFlags
|
|
)
|
|
{
|
|
USHORT cItems = 0;
|
|
|
|
return ResultFromShort(cItems); // number of menu items
|
|
}
|
|
|
|
HRESULT
|
|
COfflineItems::InvokeCommand(
|
|
LPCMINVOKECOMMANDINFO pici
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
COfflineItems::GetCommandString(
|
|
UINT_PTR idCmd,
|
|
UINT uFlags,
|
|
UINT *pwReserved,
|
|
LPSTR pszName,
|
|
UINT cchMax
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
return hr;
|
|
}
|
|
|