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.
2074 lines
67 KiB
2074 lines
67 KiB
/*****************************************************************************
|
|
*
|
|
* ftpobj.cpp - IDataObject interface
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include "priv.h"
|
|
#include "ftpobj.h"
|
|
#include "ftpurl.h"
|
|
#include <shlwapi.h>
|
|
|
|
|
|
// CLSIDs
|
|
// {299D0193-6DAA-11d2-B679-006097DF5BD4}
|
|
const GUID CLSID_FtpDataObject = { 0x299d0193, 0x6daa, 0x11d2, 0xb6, 0x79, 0x0, 0x60, 0x97, 0xdf, 0x5b, 0xd4 };
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* g_dropTypes conveniently mirrors our FORMATETCs.
|
|
*
|
|
* Hardly coincidence, of course. Enum_Fe did the real work.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Preinitialized global data.
|
|
*
|
|
*****************************************************************************/
|
|
FORMATETC g_formatEtcOffsets;
|
|
FORMATETC g_formatPasteSucceeded;
|
|
CLIPFORMAT g_cfTargetCLSID;
|
|
|
|
FORMATETC g_dropTypes[] =
|
|
{
|
|
{ 0, 0, DVASPECT_CONTENT, -1, TYMED_ISTREAM }, // DROP_FCont
|
|
{ 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, // DROP_FGDW
|
|
{ 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, // DROP_FGDA
|
|
{ 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, // DROP_IDList
|
|
{ 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, // DROP_URL
|
|
// { 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, // DROP_Offsets
|
|
{ 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, // DROP_PrefDe
|
|
{ 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, // DROP_PerfDe
|
|
{ 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, // DROP_FTP_PRIVATE
|
|
{ 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, // DROP_OLEPERSIST - see _RenderOlePersist() for desc.
|
|
{ CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, // DROP_Hdrop
|
|
{ 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, // DROP_FNMA
|
|
{ 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } // DROP_FNMW
|
|
};
|
|
|
|
|
|
|
|
/*****************************************************************************\
|
|
GLOBAL: c_stgInit
|
|
|
|
DESCRIPTION:
|
|
Mostly straightforward. The only major weirdness is that cfURL
|
|
is delay-rendered iff the m_pflHfpl contains only one object. Otherwise,
|
|
cfURL is not supported. (URLs can refer to only one object at a time.)
|
|
\*****************************************************************************/
|
|
STGMEDIUM c_stgInit[] =
|
|
{
|
|
{ 0, 0, 0 }, // DROP_FCont
|
|
{ TYMED_HGLOBAL, 0, 0 }, // DROP_FGDW - delay-rendered
|
|
{ TYMED_HGLOBAL, 0, 0 }, // DROP_FGDA - delay-rendered
|
|
{ TYMED_HGLOBAL, 0, 0 }, // DROP_IDList - delay-rendered
|
|
{ 0, 0, 0 }, // DROP_URL - opt delay-rendered
|
|
// { 0, 0, 0 }, // DROP_Offsets
|
|
{ TYMED_HGLOBAL, 0, 0 }, // DROP_PrefDe - delay-rendered
|
|
{ 0, 0, 0 }, // DROP_PerfDe
|
|
{ TYMED_HGLOBAL, 0, 0 }, // DROP_FTP_PRIVATE
|
|
{ TYMED_HGLOBAL, 0, 0 }, // DROP_OLEPERSIST - see _RenderOlePersist() for desc.
|
|
{ 0, 0, 0 }, // DROP_Hdrop
|
|
{ 0, 0, 0 }, // DROP_FNMA
|
|
{ 0, 0, 0 } // DROP_FNMW
|
|
};
|
|
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: TraceMsgWithFormatEtc
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
void TraceMsgWithFormat(DWORD dwFlags, LPCSTR pszBefore, LPFORMATETC pFormatEtc, LPCSTR pszAfter, HRESULT hr)
|
|
{
|
|
#ifdef DEBUG
|
|
TCHAR szFormatName[MAX_PATH];
|
|
TCHAR szMedium[MAX_PATH];
|
|
|
|
szFormatName[0] = 0;
|
|
szMedium[0] = 0;
|
|
if (pFormatEtc)
|
|
{
|
|
// This may fail if it's a basic format.
|
|
if (!GetClipboardFormatName(pFormatEtc->cfFormat, szFormatName, ARRAYSIZE(szFormatName)))
|
|
wnsprintf(szFormatName, ARRAYSIZE(szFormatName), TEXT("Pre-defined=%d"), pFormatEtc->cfFormat);
|
|
|
|
switch (pFormatEtc->tymed)
|
|
{
|
|
case TYMED_HGLOBAL: StrCpyN(szMedium, TEXT("HGLOBAL"), ARRAYSIZE(szMedium)); break;
|
|
case TYMED_FILE: StrCpyN(szMedium, TEXT("File"), ARRAYSIZE(szMedium)); break;
|
|
case TYMED_GDI: StrCpyN(szMedium, TEXT("GDI"), ARRAYSIZE(szMedium)); break;
|
|
case TYMED_MFPICT: StrCpyN(szMedium, TEXT("MFPICT"), ARRAYSIZE(szMedium)); break;
|
|
case TYMED_ENHMF: StrCpyN(szMedium, TEXT("ENHMF"), ARRAYSIZE(szMedium)); break;
|
|
case TYMED_ISTORAGE: StrCpyN(szMedium, TEXT("ISTORAGE"), ARRAYSIZE(szMedium)); break;
|
|
case TYMED_ISTREAM: StrCpyN(szMedium, TEXT("ISTREAM"), ARRAYSIZE(szMedium)); break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
szMedium[0] = 0;
|
|
}
|
|
|
|
TraceMsg(dwFlags, "%hs [FRMTETC: %ls, lndx: %d, %ls] hr=%#08lx, %hs", pszBefore, szFormatName, pFormatEtc->lindex, szMedium, hr, pszAfter);
|
|
#endif // DEBUG
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _IsLindexOkay
|
|
|
|
DESCRIPTION:
|
|
If ife != DROP_FCont, then pfeWant->lindex must be -1.
|
|
|
|
If ife == DROP_FCont, then pfeWant->lindex must be in the range
|
|
0 ... m_pflHfpl->GetCount() - 1
|
|
\*****************************************************************************/
|
|
BOOL CFtpObj::_IsLindexOkay(int ife, FORMATETC *pfeWant)
|
|
{
|
|
BOOL fResult;
|
|
|
|
if (ife != DROP_FCont)
|
|
fResult = pfeWant->lindex == -1;
|
|
else
|
|
fResult = (LONG)pfeWant->lindex < m_pflHfpl->GetCount();
|
|
|
|
return fResult;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _FindData
|
|
|
|
DESCRIPTION:
|
|
Locate our FORMATETC/STGMEDIUM given a FORMATETC from somebody else.
|
|
On success, stores the index found into *piOut.
|
|
|
|
We do not allow clients to change the TYMED of a FORMATETC, so
|
|
in fact checking the TYMED is what we want, even on a SetData.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::_FindData(FORMATETC *pfe, PINT piOut)
|
|
{
|
|
int nIndex;
|
|
HRESULT hres = DV_E_FORMATETC;
|
|
|
|
*piOut = 0;
|
|
for (nIndex = DROP_FCont; nIndex < DROP_OFFERMAX; nIndex++)
|
|
{
|
|
ASSERT(0 == (g_dropTypes[nIndex]).ptd);
|
|
ASSERT(g_dropTypes[nIndex].dwAspect == DVASPECT_CONTENT);
|
|
|
|
if ((pfe->cfFormat == g_dropTypes[nIndex].cfFormat) && !ShouldSkipDropFormat(nIndex))
|
|
{
|
|
if (EVAL(g_dropTypes[nIndex].ptd == NULL))
|
|
{
|
|
if (EVAL(pfe->dwAspect == DVASPECT_CONTENT))
|
|
{
|
|
if (EVAL(g_dropTypes[nIndex].tymed & pfe->tymed))
|
|
{
|
|
if (EVAL(_IsLindexOkay(nIndex, pfe)))
|
|
{
|
|
*piOut = nIndex;
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
hres = DV_E_LINDEX;
|
|
}
|
|
else
|
|
hres = DV_E_TYMED;
|
|
}
|
|
else
|
|
hres = DV_E_DVASPECT;
|
|
}
|
|
else
|
|
hres = DV_E_DVTARGETDEVICE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _FindDataForGet
|
|
|
|
DESCRIPTION:
|
|
Locate our FORMATETC/STGMEDIUM given a FORMATETC from somebody else.
|
|
On success, stores the index found into *piOut. Unlike _FindData, we will
|
|
fail the call if the data object doesn't currently have the clipboard format.
|
|
(Delayed render counts as "currently having it". What we are filtering out
|
|
are formats for which GetData will necessarily fail.)
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::_FindDataForGet(FORMATETC *pfe, PINT piOut)
|
|
{
|
|
HRESULT hr = _FindData(pfe, piOut);
|
|
|
|
// TODO: g_cfHIDA should return an array of pidls for each folder.
|
|
// If we do this, the caller will support creating Shortcuts
|
|
// (LNK files) that point to these pidls. We may want to do
|
|
// that later.
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (*piOut != DROP_FCont)
|
|
{
|
|
if (m_stgCache[*piOut].tymed)
|
|
{
|
|
// Do we have data at all?
|
|
// (possibly delay-rendered)
|
|
}
|
|
else
|
|
hr = DV_E_FORMATETC; // I guess not
|
|
}
|
|
else
|
|
{
|
|
// File contents always okay
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (FAILED(hr))
|
|
{
|
|
//TraceMsg(TF_FTPDRAGDROP, "CFtpObj::_FindDataForGet(FORMATETC.cfFormat=%d) Failed.", pfe->cfFormat);
|
|
*piOut = 0xBAADF00D;
|
|
}
|
|
#endif
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// The following are used to enumerate sub directories when creating a list of pidls for
|
|
// a directory download (Ftp->FileSys).
|
|
typedef struct tagGENPIDLLIST
|
|
{
|
|
CFtpPidlList * ppidlList;
|
|
IMalloc * pm;
|
|
IProgressDialog * ppd;
|
|
CWireEncoding * pwe;
|
|
} GENPIDLLIST;
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: ProcessItemCB
|
|
|
|
DESCRIPTION:
|
|
This function will add the specified pidl to the list. It will then
|
|
detect if it's a folder and if so, will call EnumFolder() to recursively
|
|
enum it's contents and call ProcessItemCB() for each one.
|
|
|
|
PARAMETERS:
|
|
\*****************************************************************************/
|
|
HRESULT ProcessItemCB(LPVOID pvFuncCB, HINTERNET hint, LPCITEMIDLIST pidlFull, BOOL * pfValidhinst, LPVOID pvData)
|
|
{
|
|
GENPIDLLIST * pGenPidlList = (GENPIDLLIST *) pvData;
|
|
HRESULT hr = S_OK;
|
|
|
|
// Does the user want to cancel?
|
|
if (pGenPidlList->ppd && pGenPidlList->ppd->HasUserCancelled())
|
|
{
|
|
EVAL(SUCCEEDED(pGenPidlList->ppd->StopProgressDialog()));
|
|
hr = HRESULT_FROM_WIN32(ERROR_CANCELLED);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// No, don't cancel so continue...
|
|
|
|
// Add everything except SoftLinks.
|
|
// This is because dir SoftLinks may cause infinite recurion.
|
|
// Someday, we may want to upload a shortcut but
|
|
// that's too much work for now.
|
|
if (0 != FtpPidl_GetAttributes(pidlFull))
|
|
{
|
|
// We exist to do this:
|
|
pGenPidlList->ppidlList->InsertSorted(pidlFull);
|
|
}
|
|
|
|
// Is this a dir/folder that we need to recurse into?
|
|
if (SUCCEEDED(hr) && (FILE_ATTRIBUTE_DIRECTORY & FtpPidl_GetAttributes(pidlFull)))
|
|
{
|
|
hr = EnumFolder((LPFNPROCESSITEMCB) pvFuncCB, hint, pidlFull, pGenPidlList->pwe, pfValidhinst, pvData);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _ExpandPidlListRecursively
|
|
|
|
DESCRIPTION:
|
|
This function will take the pidl list (ppidlListSrc) and call into it
|
|
to enumerate. It will provide ProcessItemCB as the callback function.
|
|
This function will help it create a new CFtpPidlList which will not only
|
|
contain the pidls in a base folder, but also all the pidls in any subfolders
|
|
that are in the original list.
|
|
|
|
Delay-render a file group descriptor.
|
|
\*****************************************************************************/
|
|
CFtpPidlList * CFtpObj::_ExpandPidlListRecursively(CFtpPidlList * ppidlListSrc)
|
|
{
|
|
GENPIDLLIST pep = {0};
|
|
|
|
pep.ppidlList = NULL;
|
|
pep.ppd = m_ppd;
|
|
pep.pwe = m_pff->GetCWireEncoding();
|
|
if (SUCCEEDED(CFtpPidlList_Create(0, NULL, &pep.ppidlList)))
|
|
{
|
|
m_pff->GetItemAllocator(&pep.pm);
|
|
|
|
if (EVAL(m_pfd) && EVAL(pep.pm))
|
|
{
|
|
HINTERNET hint;
|
|
|
|
if (SUCCEEDED(m_pfd->GetHint(NULL, NULL, &hint, NULL, m_pff)))
|
|
{
|
|
LPITEMIDLIST pidlRoot = ILClone(m_pfd->GetPidlReference());
|
|
|
|
if (pidlRoot)
|
|
{
|
|
HRESULT hr = ppidlListSrc->RecursiveEnum(pidlRoot, ProcessItemCB, hint, (LPVOID) &pep);
|
|
|
|
if (m_ppd)
|
|
EVAL(SUCCEEDED(m_ppd->StopProgressDialog()));
|
|
|
|
if (FAILED(hr) && (HRESULT_FROM_WIN32(ERROR_CANCELLED) != hr) && !m_fErrAlreadyDisplayed)
|
|
{
|
|
pep.ppidlList->Release();
|
|
pep.ppidlList = NULL;
|
|
|
|
// Oh, I want a real hwnd, but where or where can I get one?
|
|
DisplayWininetErrorEx(NULL, TRUE, HRESULT_CODE(hr), IDS_FTPERR_TITLE_ERROR, IDS_FTPERR_DROPFAIL, IDS_FTPERR_WININET, MB_OK, NULL, NULL);
|
|
hr = HRESULT_FROM_WIN32(ERROR_CANCELLED); // Wrong permissions
|
|
|
|
// We need to suppress subsequent error dlgs from this location
|
|
// because callers like to ask for FILEGROUPDESCRIPTORA and
|
|
// if that fails, ask for FILEGROUPDESCRIPTORW and we don't
|
|
// want an error dialog for each.
|
|
m_fErrAlreadyDisplayed = TRUE;
|
|
}
|
|
|
|
ILFree(pidlRoot);
|
|
}
|
|
|
|
m_pfd->ReleaseHint(hint);
|
|
pep.pm->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
return pep.ppidlList;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _DelayRender_FGD
|
|
|
|
DESCRIPTION:
|
|
Delay-render a file group descriptor
|
|
\*****************************************************************************/
|
|
HGLOBAL CFtpObj::_DelayRender_FGD(BOOL fUnicode)
|
|
{
|
|
HGLOBAL hGlobal = NULL;
|
|
|
|
if (m_fCheckSecurity &&
|
|
ZoneCheckPidlAction(SAFECAST(this, IInternetSecurityMgrSite *), URLACTION_SHELL_FILE_DOWNLOAD, m_pff->GetPrivatePidlReference(), (PUAF_DEFAULT | PUAF_WARN_IF_DENIED)))
|
|
{
|
|
m_pflHfpl->TraceDump(m_pff->GetPrivatePidlReference(), TEXT("_DelayRender_FGD() TraceDump before"));
|
|
CFtpPidlList * pPidlList;
|
|
|
|
if (!m_fFGDRendered)
|
|
{
|
|
pPidlList = _ExpandPidlListRecursively(m_pflHfpl);
|
|
if (pPidlList)
|
|
{
|
|
// We succeeded so now it's expanded.
|
|
m_fFGDRendered = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_pflHfpl->AddRef();
|
|
pPidlList = m_pflHfpl;
|
|
}
|
|
|
|
if (pPidlList)
|
|
{
|
|
hGlobal = Misc_HFGD_Create(pPidlList, m_pff->GetPrivatePidlReference(), fUnicode);
|
|
IUnknown_Set(&m_pflHfpl, pPidlList);
|
|
m_pflHfpl->TraceDump(m_pff->GetPrivatePidlReference(), TEXT("_DelayRender_FGD() TraceDump after"));
|
|
pPidlList->Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Suppress future UI. We don't need to check any more
|
|
// because our pidl won't change. We could not pass PUAF_WARN_IF_DENIED
|
|
// but that won't suppress the UI in the prompt case. (Only admins can
|
|
// turn on the prompt case).
|
|
m_fCheckSecurity = FALSE;
|
|
}
|
|
|
|
return hGlobal;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _DelayRender_IDList
|
|
|
|
DESCRIPTION:
|
|
Delay-render an ID List Array (HIDA)
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::_DelayRender_IDList(STGMEDIUM * pStgMedium)
|
|
{
|
|
pStgMedium->hGlobal = Misc_HIDA_Create(m_pff->GetPublicRootPidlReference(), m_pflHfpl);
|
|
|
|
ASSERT(pStgMedium->hGlobal);
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _DelayRender_URL
|
|
|
|
DESCRIPTION:
|
|
The caller wants an URL in an Ansi String
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::_DelayRender_URL(STGMEDIUM * pStgMedium)
|
|
{
|
|
LPSTR pszUrl = NULL;
|
|
LPITEMIDLIST pidlFull = NULL;
|
|
LPITEMIDLIST pidl = m_pflHfpl->GetPidl(0);
|
|
|
|
ASSERT(pidl); // We need this
|
|
// Sometimes m_pflHfpl->GetPidl(0) is fully qualified and
|
|
// sometimes it's not.
|
|
if (!FtpID_IsServerItemID(pidl))
|
|
{
|
|
pidlFull = ILCombine(m_pfd->GetPidlReference(), pidl);
|
|
pidl = pidlFull;
|
|
}
|
|
|
|
ASSERT(m_pflHfpl->GetCount() == 1); // How do we give them more than 1 URL?
|
|
if (pidl)
|
|
{
|
|
TCHAR szUrl[MAX_URL_STRING];
|
|
|
|
if (EVAL(SUCCEEDED(UrlCreateFromPidl(pidl, SHGDN_FORADDRESSBAR, szUrl, ARRAYSIZE(szUrl), (ICU_ESCAPE | ICU_USERNAME), TRUE))))
|
|
{
|
|
DWORD cchSize = (lstrlen(szUrl) + 1);
|
|
|
|
pszUrl = (LPSTR) LocalAlloc(LPTR, (cchSize * sizeof(CHAR)));
|
|
if (pszUrl)
|
|
SHTCharToAnsi(szUrl, pszUrl, cchSize);
|
|
}
|
|
|
|
ILFree(pidlFull);
|
|
}
|
|
|
|
pStgMedium->hGlobal = (HGLOBAL) pszUrl;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
#pragma BEGIN_CONST_DATA
|
|
|
|
DROPEFFECT c_deCopyLink = DROPEFFECT_COPY | DROPEFFECT_LINK;
|
|
DROPEFFECT c_deLink = DROPEFFECT_LINK;
|
|
|
|
#pragma END_CONST_DATA
|
|
/*****************************************************************************\
|
|
FUNCTION: _DelayRender_PrefDe
|
|
|
|
DESCRIPTION:
|
|
Delay-render a preferred drop effect.
|
|
|
|
The preferred drop effect is DROPEFFECT_COPY (with DROPEFFECT_LINK as fallback),
|
|
unless you are dragging an FTP site, in which case it's just DROPEFFECT_LINK.
|
|
|
|
DROPEFFECT_MOVE is never preferred. We can do it; it just isn't preferred.
|
|
|
|
NOTES: About DROPEFFECT_MOVE
|
|
We cannot support Move on platforms before NT5 because of a Recycle Bin bug
|
|
were it would clain to have succeeded with the copy but it actually didn't
|
|
copy anything. On NT5, the Recycle Bin drop target will call pDataObject->SetData()
|
|
with a data type of "Dropped On" and the data being the CLSID of the drop
|
|
target in addition to really copying the files to the recycle bin. This will
|
|
let us delete the files knowing they are in the recycle bin.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::_DelayRender_PrefDe(STGMEDIUM * pStgMedium)
|
|
{
|
|
DROPEFFECT * pde;
|
|
|
|
if (!m_pfd->IsRoot())
|
|
pde = &c_deCopyLink;
|
|
else
|
|
pde = &c_deLink;
|
|
|
|
return Misc_CreateHglob(sizeof(*pde), pde, &pStgMedium->hGlobal);
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _RenderOlePersist
|
|
|
|
DESCRIPTION:
|
|
When the copy source goes away (the process shuts down), it calls
|
|
OleFlushClipboard. OLE will then copy our data, release us, and then
|
|
give out our data later. This works for most things except for:
|
|
1. When lindex needs to very. This doesn't work because ole doesn't know
|
|
how to ask us how may lindexs they need to copy.
|
|
2. If this object has a private interface OLE doesn't know about. For us,
|
|
it's IAsyncOperation.
|
|
|
|
To get around this problem, we want OLE to recreate us when some possible
|
|
paste target calls OleGetClipboard. We want OLE to call OleLoadFromStream()
|
|
to have us CoCreated and reload our persisted data via IPersistStream.
|
|
OLE doesn't want to do this by default or they may have backward compat
|
|
problems so they want a sign from the heavens, or at least from us, that
|
|
we will work. They ping our "OleClipboardPersistOnFlush" clipboard format
|
|
to ask this.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::_RenderOlePersist(STGMEDIUM * pStgMedium)
|
|
{
|
|
// The actual cookie value is opaque to the outside world. Since
|
|
// we don't use it either, we just leave it at zero in case we use
|
|
// it in the future. It's mere existence will cause OLE to do the
|
|
// use our IPersistStream, which is what we want.
|
|
DWORD dwCookie = 0;
|
|
return Misc_CreateHglob(sizeof(dwCookie), &dwCookie, &pStgMedium->hGlobal);
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _RenderFGD
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::_RenderFGD(int nIndex, STGMEDIUM * pStgMedium)
|
|
{
|
|
HRESULT hr = _DoProgressForLegacySystemsPre();
|
|
|
|
if (SUCCEEDED(hr))
|
|
pStgMedium->hGlobal = _DelayRender_FGD((DROP_FGDW == nIndex) ? TRUE : FALSE);
|
|
|
|
if (!pStgMedium->hGlobal)
|
|
hr = HRESULT_FROM_WIN32(ERROR_CANCELLED); // Probably failed because of Zones check.
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _ForceRender
|
|
|
|
DESCRIPTION:
|
|
We previously delayed rendering the data for perf reasons. This function
|
|
was called, so we now need to render the data.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::_ForceRender(int nIndex)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// We only support HGLOBALs here, but the caller may be valid
|
|
// to ask for something we don't support or an extended data.
|
|
// ASSERT((m_stgCache[nIndex].tymed) == TYMED_HGLOBAL);
|
|
|
|
if (!m_stgCache[nIndex].hGlobal)
|
|
{
|
|
STGMEDIUM medium = {TYMED_HGLOBAL, 0, NULL};
|
|
|
|
switch (nIndex)
|
|
{
|
|
case DROP_FCont:
|
|
ASSERT(0);
|
|
break;
|
|
case DROP_FGDW:
|
|
case DROP_FGDA:
|
|
hr = _RenderFGD(nIndex, &medium);
|
|
break;
|
|
case DROP_IDList:
|
|
hr = _DelayRender_IDList(&medium);
|
|
break;
|
|
/* Nuke
|
|
case DROP_Offsets:
|
|
ASSERT(0);
|
|
// hglob = _DelayRender_Offsets();
|
|
break;
|
|
*/
|
|
case DROP_PrefDe:
|
|
hr = _DelayRender_PrefDe(&medium);
|
|
break;
|
|
case DROP_PerfDe:
|
|
ASSERT(0);
|
|
// hglob = _DelayRender_PerfDe();
|
|
break;
|
|
case DROP_FTP_PRIVATE:
|
|
hr = DV_E_FORMATETC;
|
|
break;
|
|
case DROP_OLEPERSIST:
|
|
hr = _RenderOlePersist(&medium);
|
|
break;
|
|
case DROP_Hdrop:
|
|
ASSERT(0);
|
|
// hglob = _DelayRender_Hdrop();
|
|
break;
|
|
case DROP_FNMA:
|
|
ASSERT(0);
|
|
// hglob = _DelayRender_FNM();
|
|
break;
|
|
case DROP_FNMW:
|
|
ASSERT(0);
|
|
// hglob = _DelayRender_FNM();
|
|
break;
|
|
case DROP_URL:
|
|
hr = _DelayRender_URL(&medium);
|
|
break;
|
|
default:
|
|
ASSERT(0); // Should never hit.
|
|
break;
|
|
}
|
|
|
|
if (medium.hGlobal) // Will fail if the Zones Security Check Fails.
|
|
{
|
|
m_stgCache[nIndex].pUnkForRelease = NULL;
|
|
m_stgCache[nIndex].hGlobal = medium.hGlobal;
|
|
}
|
|
else
|
|
{
|
|
if (S_OK == hr)
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
TraceMsg(TF_FTPDRAGDROP, "CFtpObj::_ForceRender() FAILED. hres=%#08lx", hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _DoProgressForLegacySystemsPre
|
|
|
|
DESCRIPTION:
|
|
Shell's pre-NT5 didn't do progress on the File Contents drop, so we
|
|
will do it here. This function will display a progress dialog while we
|
|
walk the server and expand the pidls that are needed to be copied.
|
|
Later,
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::_DoProgressForLegacySystemsPre(void)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (DEBUG_LEGACY_PROGRESS || (SHELL_VERSION_NT5 > GetShellVersion()))
|
|
{
|
|
TraceMsg(TF_ALWAYS, "CFtpObj::_DoProgressForLegacySystemsPre() going to do the Legacy dialogs.");
|
|
|
|
// Do we need to initialize the list?
|
|
if (!m_ppd && (-1 == m_nStartIndex))
|
|
{
|
|
// Yes, so create the create the dialog and find the sizes of the list.
|
|
if (m_ppd)
|
|
_CloseProgressDialog();
|
|
|
|
m_uliCompleted.QuadPart = 0;
|
|
m_uliTotal.QuadPart = 0;
|
|
m_ppd = CProgressDialog_CreateInstance(IDS_COPY_TITLE, IDA_FTPDOWNLOAD);
|
|
if (m_ppd)
|
|
{
|
|
WCHAR wzProgressDialogStr[MAX_PATH];
|
|
|
|
// Tell the user we are calculating how long it will take.
|
|
if (EVAL(LoadStringW(HINST_THISDLL, IDS_PROGRESS_DOWNLOADTIMECALC, wzProgressDialogStr, ARRAYSIZE(wzProgressDialogStr))))
|
|
EVAL(SUCCEEDED(m_ppd->SetLine(2, wzProgressDialogStr, FALSE, NULL)));
|
|
|
|
// We give a NULL punkEnableModless because we don't want to go modal.
|
|
EVAL(SUCCEEDED(m_ppd->StartProgressDialog(NULL, NULL, PROGDLG_AUTOTIME, NULL)));
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _DoProgressForLegacySystemsStart
|
|
|
|
DESCRIPTION:
|
|
Shell's pre-NT5 didn't do progress on the File Contents drop, so we
|
|
will do it here. Only return FAILED(hr) if IProgressDialog::HasUserCancelled().
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::_DoProgressForLegacySystemsStart(LPCITEMIDLIST pidl, int nIndex)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (DEBUG_LEGACY_PROGRESS || (SHELL_VERSION_NT5 > GetShellVersion()))
|
|
{
|
|
TraceMsg(TF_ALWAYS, "CFtpObj::_DoProgressForLegacySystemsStart() going to do the Legacy dialogs.");
|
|
|
|
// Do we need to initialize the list?
|
|
if (-1 == m_nStartIndex)
|
|
hr = _SetProgressDialogValues(nIndex); // Yes, so do so.
|
|
|
|
if (EVAL(m_ppd))
|
|
{
|
|
WCHAR wzTemplate[MAX_PATH];
|
|
WCHAR wzPath[MAX_PATH];
|
|
WCHAR wzStatusText[MAX_PATH];
|
|
WCHAR wzTemp[MAX_PATH];
|
|
LPITEMIDLIST pidlBase = (LPITEMIDLIST) pidl;
|
|
|
|
EVAL(SUCCEEDED(m_ppd->StartProgressDialog(NULL, NULL, PROGDLG_AUTOTIME, NULL)));
|
|
|
|
// Generate the string "Downloading <FileName>..." status string
|
|
EVAL(LoadStringW(HINST_THISDLL, IDS_DOWNLOADING, wzTemplate, ARRAYSIZE(wzTemplate)));
|
|
FtpPidl_GetLastItemDisplayName(pidl, wzTemp, ARRAYSIZE(wzTemp));
|
|
wnsprintfW(wzStatusText, ARRAYSIZE(wzStatusText), wzTemplate, wzTemp);
|
|
EVAL(SUCCEEDED(m_ppd->SetLine(1, wzStatusText, FALSE, NULL)));
|
|
|
|
if (FtpPidl_IsDirectory(pidl, FALSE))
|
|
{
|
|
pidlBase = ILClone(pidl);
|
|
ILRemoveLastID(pidlBase);
|
|
}
|
|
|
|
// Generate the string "From <SrcFileDir>" status string
|
|
GetDisplayPathFromPidl(pidlBase, wzPath, ARRAYSIZE(wzPath), TRUE);
|
|
EVAL(LoadStringW(HINST_THISDLL, IDS_DL_SRC_DIR, wzTemplate, ARRAYSIZE(wzTemplate)));
|
|
wnsprintfW(wzStatusText, ARRAYSIZE(wzStatusText), wzTemplate, wzPath);
|
|
EVAL(SUCCEEDED(m_ppd->SetLine(2, wzStatusText, FALSE, NULL)));
|
|
|
|
EVAL(SUCCEEDED(m_ppd->SetProgress64(m_uliCompleted.QuadPart, m_uliTotal.QuadPart)));
|
|
TraceMsg(TF_ALWAYS, "CFtpObj::_DoProgressForLegacySystemsStart() SetProgress64(%#08lx, %#08lx)", m_uliCompleted.LowPart, m_uliTotal.LowPart);
|
|
if (m_ppd->HasUserCancelled())
|
|
hr = HRESULT_FROM_WIN32(ERROR_CANCELLED);
|
|
|
|
if (pidlBase != pidl) // Did we allocated it?
|
|
ILFree(pidlBase);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _DoProgressForLegacySystemsPost
|
|
|
|
DESCRIPTION:
|
|
Shell's pre-NT5 didn't do progress on the File Contents drop, so we
|
|
will do it here. Only return FAILED(hr) if IProgressDialog::HasUserCancelled().
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::_DoProgressForLegacySystemsPost(LPCITEMIDLIST pidl, BOOL fLast)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if ((DEBUG_LEGACY_PROGRESS || (SHELL_VERSION_NT5 > GetShellVersion())) && EVAL(m_ppd))
|
|
{
|
|
if (pidl)
|
|
{
|
|
// Add the file size to the Completed.
|
|
m_uliCompleted.QuadPart += FtpPidl_GetFileSize(pidl);
|
|
}
|
|
|
|
TraceMsg(TF_ALWAYS, "CFtpObj::_DoProgressForLegacySystemsPost() Closing DLG");
|
|
|
|
if (fLast)
|
|
IUnknown_Set((IUnknown **)&m_ppd, NULL); // The stream will close the dialog and release it.
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CFtpObj::_SetProgressDialogValues(int nIndex)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
m_nStartIndex = nIndex;
|
|
if (EVAL(m_ppd))
|
|
{
|
|
// Calculate m_nEndIndex
|
|
while (nIndex < m_pflHfpl->GetCount())
|
|
{
|
|
if (!FtpPidl_IsDirectory(m_pflHfpl->GetPidl(nIndex), FALSE))
|
|
m_nEndIndex = nIndex;
|
|
nIndex++;
|
|
}
|
|
|
|
for (nIndex = 0; nIndex < m_pflHfpl->GetCount(); nIndex++)
|
|
{
|
|
LPCITEMIDLIST pidl = m_pflHfpl->GetPidl(nIndex);
|
|
m_uliTotal.QuadPart += FtpPidl_GetFileSize(pidl);
|
|
}
|
|
|
|
// Reset because the above for loop can take a long time and the estimated time
|
|
// is based on the time between ::StartProgressDialog() and the first
|
|
// ::SetProgress() call.
|
|
EVAL(SUCCEEDED(m_ppd->Timer(PDTIMER_RESET, NULL)));
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CFtpObj::_CloseProgressDialog(void)
|
|
{
|
|
m_nStartIndex = -1; // Indicate we haven't inited yet.
|
|
if (m_ppd)
|
|
{
|
|
EVAL(SUCCEEDED(m_ppd->StopProgressDialog()));
|
|
IUnknown_Set((IUnknown **)&m_ppd, NULL);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT CFtpObj::_RefThread(void)
|
|
{
|
|
if (NULL == m_punkThreadRef)
|
|
{
|
|
// This is valid to fail from some hosts who won't go away,
|
|
// so they don't need to support ref counting threads.
|
|
SHGetThreadRef(&m_punkThreadRef);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT CFtpObj::_RenderFileContents(LPFORMATETC pfe, LPSTGMEDIUM pstg)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
// callers have a bad habit of asking for lindex == -1 because
|
|
// that means 'all' data. But how can you hand out one IStream* for
|
|
// all files?
|
|
if (-1 != pfe->lindex)
|
|
{
|
|
LPITEMIDLIST pidl = m_pflHfpl->GetPidl(pfe->lindex);
|
|
// FileContents are always regenerated afresh.
|
|
pstg->pUnkForRelease = 0;
|
|
pstg->tymed = TYMED_ISTREAM;
|
|
|
|
if (pidl)
|
|
{
|
|
hr = _DoProgressForLegacySystemsStart(pidl, pfe->lindex);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Is it a directory?
|
|
if (FtpPidl_IsDirectory(pidl, FALSE))
|
|
{
|
|
// Yes, so pack the name and attributes
|
|
hr = DV_E_LINDEX;
|
|
AssertMsg(0, TEXT("Someone is asking for a FILECONTENTs for a directory item."));
|
|
}
|
|
else
|
|
{
|
|
// No, so give them the stream.
|
|
|
|
// shell32 v5 will display progress dialogs, but we need to
|
|
// display progress dialogs for shell32 v3 or v4. We do this
|
|
// by creating the progress dialog when the caller asks for the
|
|
// first stream. We then need to find out when they call for
|
|
// the last stream and then hand off the IProgressDialog to the
|
|
// CFtpStm. The CFtpStm will then close down the dialog when the
|
|
// caller closes it.
|
|
hr = CFtpStm_Create(m_pfd, pidl, GENERIC_READ, &pstg->pstm, m_uliCompleted, m_uliTotal, m_ppd, (pfe->lindex == m_nEndIndex));
|
|
EVAL(SUCCEEDED(_DoProgressForLegacySystemsPost(pidl, (pfe->lindex == m_nEndIndex))));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The user may have cancelled
|
|
ASSERT(HRESULT_FROM_WIN32(ERROR_CANCELLED) == hr);
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
_CloseProgressDialog();
|
|
}
|
|
|
|
//TraceMsg(TF_FTPDRAGDROP, "CFtpObj::GetData() CFtpStm_Create() returned hr=%#08lx", hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IsEqualFORMATETC
|
|
|
|
DESCRIPTION:
|
|
The two fields of a FORMATETC that need to match to be equivalent are:
|
|
cfFormat and lindex.
|
|
\*****************************************************************************/
|
|
BOOL IsEqualFORMATETC(FORMATETC * pfe1, FORMATETC * pfe2)
|
|
{
|
|
BOOL fIsEqual = FALSE;
|
|
|
|
if ((pfe1->cfFormat == pfe2->cfFormat) && (pfe1->lindex == pfe2->lindex))
|
|
{
|
|
fIsEqual = TRUE;
|
|
}
|
|
|
|
return fIsEqual;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _FreeExtraData
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
int CFtpObj::_DSA_FreeCB(LPVOID pvItem, LPVOID pvlparam)
|
|
{
|
|
FORMATETC_STGMEDIUM * pfs = (FORMATETC_STGMEDIUM *) pvItem;
|
|
|
|
if (EVAL(pfs))
|
|
ReleaseStgMedium(&(pfs->medium));
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _FindSetDataIndex
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
int CFtpObj::_FindExtraDataIndex(FORMATETC *pfe)
|
|
{
|
|
int nIndex;
|
|
|
|
for (nIndex = (DSA_GetItemCount(m_hdsaSetData) - 1); nIndex >= 0; nIndex--)
|
|
{
|
|
FORMATETC_STGMEDIUM * pfs = (FORMATETC_STGMEDIUM *) DSA_GetItemPtr(m_hdsaSetData, nIndex);
|
|
|
|
if (IsEqualFORMATETC(pfe, &pfs->formatEtc))
|
|
{
|
|
return nIndex;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: _SetExtraData
|
|
|
|
DESCRIPTION:
|
|
We don't render the data, but we will carry it because someone may need
|
|
or want it. This is the case with the drag source's defview pushing in
|
|
the icon points via CFSTR_SHELLIDLISTOFFSET for the drop target.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::_SetExtraData(FORMATETC *pfe, STGMEDIUM *pstg, BOOL fRelease)
|
|
{
|
|
HRESULT hr;
|
|
int nIndex = _FindExtraDataIndex(pfe);
|
|
|
|
// Do we already have someone's copy?
|
|
if (-1 == nIndex)
|
|
{
|
|
FORMATETC_STGMEDIUM fs;
|
|
|
|
fs.formatEtc = *pfe;
|
|
|
|
// If there is a pointer, copy the data because we can't maintain the lifetime
|
|
// of the pointer.
|
|
if (fs.formatEtc.ptd)
|
|
{
|
|
fs.dvTargetDevice = *(pfe->ptd);
|
|
fs.formatEtc.ptd = &fs.dvTargetDevice;
|
|
}
|
|
|
|
hr = CopyStgMediumWrap(pstg, &fs.medium);
|
|
if (EVAL(SUCCEEDED(hr)))
|
|
{
|
|
// No, so just append it to the end.
|
|
DSA_AppendItem(m_hdsaSetData, &fs);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FORMATETC_STGMEDIUM fs;
|
|
|
|
DSA_GetItem(m_hdsaSetData, nIndex, &fs);
|
|
// Free the previous guy.
|
|
ReleaseStgMedium(&fs.medium);
|
|
|
|
// Yes, so Replace it.
|
|
hr = CopyStgMediumWrap(pstg, &fs.medium);
|
|
if (EVAL(SUCCEEDED(hr)))
|
|
{
|
|
// Replace the data.
|
|
DSA_SetItem(m_hdsaSetData, nIndex, &fs);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwVersion;
|
|
DWORD dwExtraSize; // After pidl list
|
|
BOOL fFGDRendered;
|
|
DWORD dwReserved1;
|
|
DWORD dwReserved2;
|
|
} FTPDATAOBJ_PERSISTSTRUCT;
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: FormatEtcSaveToStream
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT FormatEtcSaveToStream(IStream *pStm, FORMATETC * pFormatEtc)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (pStm)
|
|
{
|
|
// We don't support ptd because where would the allocation be
|
|
// on the load?
|
|
if (EVAL(NULL == pFormatEtc->ptd))
|
|
{
|
|
WCHAR szFormatName[MAX_PATH];
|
|
|
|
if (EVAL(GetClipboardFormatNameW(pFormatEtc->cfFormat, szFormatName, ARRAYSIZE(szFormatName))))
|
|
{
|
|
DWORD cbFormatNameSize = ((lstrlenW(szFormatName) + 1) * sizeof(szFormatName[0]));
|
|
|
|
hr = pStm->Write(pFormatEtc, SIZEOF(*pFormatEtc), NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pStm->Write(&cbFormatNameSize, SIZEOF(cbFormatNameSize), NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pStm->Write(szFormatName, cbFormatNameSize, NULL);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: FormatEtcLoadFromStream
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT FormatEtcLoadFromStream(IStream *pStm, FORMATETC * pFormatEtc)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (pStm)
|
|
{
|
|
hr = pStm->Read(pFormatEtc, SIZEOF(*pFormatEtc), NULL);
|
|
ASSERT(NULL == pFormatEtc->ptd); // We don't support this.
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
DWORD cbFormatNameSize;
|
|
|
|
hr = pStm->Read(&cbFormatNameSize, SIZEOF(cbFormatNameSize), NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WCHAR szFormatName[MAX_PATH];
|
|
|
|
hr = pStm->Read(szFormatName, cbFormatNameSize, NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pFormatEtc->cfFormat = (CLIPFORMAT)RegisterClipboardFormatW(szFormatName);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwVersion;
|
|
DWORD dwExtraSize; // After this struct
|
|
DWORD dwTymed; // What type of data is stored?
|
|
BOOL fUnkForRelease; // Did we save the object after this?
|
|
DWORD dwReserved1; //
|
|
DWORD dwReserved2; //
|
|
} STGMEDIUM_PERSISTSTRUCT;
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: StgMediumSaveToStream
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT StgMediumSaveToStream(IStream *pStm, STGMEDIUM * pMedium)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (pStm)
|
|
{
|
|
STGMEDIUM_PERSISTSTRUCT smps = {0};
|
|
|
|
smps.dwVersion = 1;
|
|
smps.dwTymed = pMedium->tymed;
|
|
|
|
switch (pMedium->tymed)
|
|
{
|
|
case TYMED_HGLOBAL:
|
|
{
|
|
IStream * pstmHGlobal;
|
|
|
|
hr = CreateStreamOnHGlobal(pMedium->hGlobal, FALSE, &pstmHGlobal);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
STATSTG statStg;
|
|
|
|
hr = pstmHGlobal->Stat(&statStg, STATFLAG_NONAME);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ASSERT(!statStg.cbSize.HighPart);
|
|
smps.dwExtraSize = statStg.cbSize.LowPart;
|
|
hr = pStm->Write(&smps, SIZEOF(smps), NULL);
|
|
if (SUCCEEDED(hr))
|
|
hr = pstmHGlobal->CopyTo(pStm, statStg.cbSize, NULL, NULL);
|
|
}
|
|
|
|
pstmHGlobal->Release();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TYMED_FILE:
|
|
smps.dwExtraSize = ((lstrlenW(pMedium->lpszFileName) + 1) * sizeof(WCHAR));
|
|
|
|
hr = pStm->Write(&smps, SIZEOF(smps), NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pStm->Write(pMedium->lpszFileName, smps.dwExtraSize, NULL);
|
|
ASSERT(SUCCEEDED(hr));
|
|
}
|
|
break;
|
|
|
|
case TYMED_GDI:
|
|
case TYMED_MFPICT:
|
|
case TYMED_ENHMF:
|
|
case TYMED_ISTORAGE:
|
|
case TYMED_ISTREAM:
|
|
default:
|
|
ASSERT(0); // What are you doing? Impl this if you need it.
|
|
hr = E_NOTIMPL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
LPWSTR OLESTRAlloc(DWORD cchSize)
|
|
{
|
|
return (LPWSTR) new WCHAR [cchSize + 1];
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: StgMediumLoadFromStream
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT StgMediumLoadFromStream(IStream *pStm, STGMEDIUM * pMedium)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (pStm && pMedium)
|
|
{
|
|
STGMEDIUM_PERSISTSTRUCT smps;
|
|
|
|
pMedium->pUnkForRelease = NULL;
|
|
hr = pStm->Read(&smps, SIZEOF(smps), NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pMedium->tymed = smps.dwTymed;
|
|
ASSERT(!pMedium->pUnkForRelease);
|
|
|
|
switch (pMedium->tymed)
|
|
{
|
|
case TYMED_HGLOBAL:
|
|
{
|
|
IStream * pstmTemp;
|
|
hr = CreateStreamOnHGlobal(NULL, FALSE, &pstmTemp);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ULARGE_INTEGER uli = {0};
|
|
|
|
uli.LowPart = smps.dwExtraSize;
|
|
hr = pStm->CopyTo(pstmTemp, uli, NULL, NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = GetHGlobalFromStream(pstmTemp, &pMedium->hGlobal);
|
|
}
|
|
|
|
pstmTemp->Release();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TYMED_FILE:
|
|
pMedium->lpszFileName = OLESTRAlloc(smps.dwExtraSize / sizeof(WCHAR));
|
|
if (pMedium->lpszFileName)
|
|
hr = pStm->Read(pMedium->lpszFileName, smps.dwExtraSize, NULL);
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
|
|
case TYMED_GDI:
|
|
case TYMED_MFPICT:
|
|
case TYMED_ENHMF:
|
|
case TYMED_ISTORAGE:
|
|
case TYMED_ISTREAM:
|
|
default:
|
|
ASSERT(0); // What are you doing? Impl this if you need it.
|
|
// Some future version must have done the save, so skip the
|
|
// data so we don't leave unread data.
|
|
if (0 != smps.dwExtraSize)
|
|
{
|
|
LARGE_INTEGER li = {0};
|
|
|
|
li.LowPart = smps.dwExtraSize;
|
|
EVAL(SUCCEEDED(pStm->Seek(li, STREAM_SEEK_CUR, NULL)));
|
|
}
|
|
hr = E_NOTIMPL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: FORMATETC_STGMEDIUMSaveToStream
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT FORMATETC_STGMEDIUMSaveToStream(IStream *pStm, FORMATETC_STGMEDIUM * pfdops)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (pStm)
|
|
{
|
|
hr = FormatEtcSaveToStream(pStm, &pfdops->formatEtc);
|
|
if (SUCCEEDED(hr))
|
|
hr = StgMediumSaveToStream(pStm, &pfdops->medium);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: FORMATETC_STGMEDIUMLoadFromStream
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT FORMATETC_STGMEDIUMLoadFromStream(IStream *pStm, FORMATETC_STGMEDIUM * pfdops)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (pStm)
|
|
{
|
|
hr = FormatEtcLoadFromStream(pStm, &pfdops->formatEtc);
|
|
if (SUCCEEDED(hr))
|
|
hr = StgMediumLoadFromStream(pStm, &pfdops->medium);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////
|
|
////// IAsynchDataObject Impl
|
|
/////////////////////////////////
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IAsyncOperation::GetAsyncMode
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::GetAsyncMode(BOOL * pfIsOpAsync)
|
|
{
|
|
*pfIsOpAsync = TRUE;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IAsyncOperation::StartOperation
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::StartOperation(IBindCtx * pbcReserved)
|
|
{
|
|
ASSERT(!pbcReserved);
|
|
m_fDidAsynchStart = TRUE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IAsyncOperation::InOperation
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::InOperation(BOOL * pfInAsyncOp)
|
|
{
|
|
if (m_fDidAsynchStart)
|
|
*pfInAsyncOp = TRUE;
|
|
else
|
|
*pfInAsyncOp = FALSE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IAsyncOperation::EndOperation
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::EndOperation(HRESULT hResult, IBindCtx * pbcReserved, DWORD dwEffects)
|
|
{
|
|
if (SUCCEEDED(hResult) &&
|
|
(DROPEFFECT_MOVE == dwEffects))
|
|
{
|
|
CFtpPidlList * pPidlListNew = CreateRelativePidlList(m_pff, m_pflHfpl);
|
|
|
|
if (pPidlListNew)
|
|
{
|
|
Misc_DeleteHfpl(m_pff, GetDesktopWindow(), pPidlListNew);
|
|
pPidlListNew->Release();
|
|
}
|
|
}
|
|
|
|
m_fDidAsynchStart = FALSE;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////
|
|
////// IPersistStream Impl
|
|
/////////////////////////////////
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IPersistStream::Load
|
|
|
|
DESCRIPTION:
|
|
See IPersistStream::Save() for the layout of the stream.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::Load(IStream *pStm)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (pStm)
|
|
{
|
|
FTPDATAOBJ_PERSISTSTRUCT fdoss;
|
|
DWORD dwNumPidls;
|
|
DWORD dwNumStgMedium;
|
|
|
|
hr = pStm->Read(&fdoss, SIZEOF(fdoss), NULL); // #1
|
|
// If we rev the version, read it now (fdoss.dwVersion)
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidl = NULL; // ILLoadFromStream frees the param
|
|
|
|
ASSERT(!m_pff);
|
|
m_fFGDRendered = fdoss.fFGDRendered;
|
|
|
|
hr = ILLoadFromStream(pStm, &pidl); // #2
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHBindToIDList(pidl, NULL, IID_CFtpFolder, (void **)&m_pff);
|
|
if (SUCCEEDED(hr))
|
|
m_pfd = m_pff->GetFtpDir();
|
|
|
|
ASSERT(m_pfd);
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pStm->Read(&dwNumPidls, SIZEOF(dwNumPidls), NULL); // #3
|
|
if (SUCCEEDED(hr))
|
|
hr = CFtpPidlList_Create(0, NULL, &m_pflHfpl);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
for (int nIndex = 0; (nIndex < (int)dwNumPidls) && SUCCEEDED(hr); nIndex++)
|
|
{
|
|
LPITEMIDLIST pidl = NULL; // ILLoadFromStream frees the param
|
|
|
|
hr = ILLoadFromStream(pStm, &pidl); // #4
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = m_pflHfpl->InsertSorted(pidl);
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = pStm->Read(&dwNumStgMedium, SIZEOF(dwNumStgMedium), NULL); // #5
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
for (int nIndex = 0; (nIndex < (int)dwNumStgMedium) && SUCCEEDED(hr); nIndex++)
|
|
{
|
|
FORMATETC_STGMEDIUM fs;
|
|
|
|
hr = FORMATETC_STGMEDIUMLoadFromStream(pStm, &fs); // #6
|
|
if (SUCCEEDED(hr))
|
|
DSA_AppendItem(m_hdsaSetData, &fs);
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// We may be reading a version newer than us, so skip their data.
|
|
if (0 != fdoss.dwExtraSize)
|
|
{
|
|
LARGE_INTEGER li = {0};
|
|
|
|
li.LowPart = fdoss.dwExtraSize;
|
|
hr = pStm->Seek(li, STREAM_SEEK_CUR, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IPersistStream::Save
|
|
|
|
DESCRIPTION:
|
|
The stream will be layed out in the following way:
|
|
|
|
Version 1:
|
|
1. FTPDATAOBJ_PERSISTSTRUCT - Constant sized data.
|
|
<PidlList BEGIN>
|
|
2. PIDL pidl - Pidl for m_pff. It will be a public pidl (fully qualified
|
|
from the shell root)
|
|
3. DWORD dwNumPidls - Number of pidls coming.
|
|
4. PIDL pidl(n) - Pidl in slot (n) of m_pflHfpl
|
|
<PidlList END>
|
|
5. DWORD dwNumStgMedium - Number of FORMATETC_STGMEDIUMs coming
|
|
6. FORMATETC_STGMEDIUM fmtstg(n) - dwNumStgMedium FORMATETC_STGMEDIUMs.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::Save(IStream *pStm, BOOL fClearDirty)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (pStm)
|
|
{
|
|
FTPDATAOBJ_PERSISTSTRUCT fdoss = {0};
|
|
DWORD dwNumPidls = m_pflHfpl->GetCount();
|
|
DWORD dwNumStgMedium = DSA_GetItemCount(m_hdsaSetData);
|
|
|
|
fdoss.dwVersion = 1;
|
|
fdoss.fFGDRendered = m_fFGDRendered;
|
|
hr = pStm->Write(&fdoss, SIZEOF(fdoss), NULL); // #1
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ASSERT(m_pff);
|
|
hr = ILSaveToStream(pStm, m_pff->GetPublicRootPidlReference()); // #2
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = pStm->Write(&dwNumPidls, SIZEOF(dwNumPidls), NULL); // #3
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
for (int nIndex = 0; (nIndex < (int)dwNumPidls) && SUCCEEDED(hr); nIndex++)
|
|
{
|
|
LPITEMIDLIST pidlCur = m_pflHfpl->GetPidl(nIndex);
|
|
|
|
ASSERT(pidlCur);
|
|
hr = ILSaveToStream(pStm, pidlCur); // #4
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = pStm->Write(&dwNumStgMedium, SIZEOF(dwNumStgMedium), NULL); // #5
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
for (int nIndex = 0; (nIndex < (int)dwNumStgMedium) && SUCCEEDED(hr); nIndex++)
|
|
{
|
|
FORMATETC_STGMEDIUM fs;
|
|
|
|
DSA_GetItem(m_hdsaSetData, nIndex, &fs);
|
|
|
|
hr = FORMATETC_STGMEDIUMSaveToStream(pStm, &fs); // #6
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
#define MAX_STREAM_SIZE (500 * 1024) // 500k
|
|
/*****************************************************************************\
|
|
FUNCTION: IPersistStream::GetSizeMax
|
|
|
|
DESCRIPTION:
|
|
Now this is tough. I can't calculate the real value because I don't know
|
|
how big the hglobals are going to be for the user provided data. I will
|
|
assume everything fits in
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::GetSizeMax(ULARGE_INTEGER * pcbSize)
|
|
{
|
|
if (pcbSize)
|
|
{
|
|
pcbSize->HighPart = 0;
|
|
pcbSize->LowPart = MAX_STREAM_SIZE;
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/////////////////////////////////
|
|
////// IDataObject Impl
|
|
/////////////////////////////////
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IDataObject::GetData
|
|
|
|
DESCRIPTION:
|
|
Render the data in the requested format and put it into the
|
|
STGMEDIUM structure.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::GetData(LPFORMATETC pfe, LPSTGMEDIUM pstg)
|
|
{
|
|
int ife;
|
|
HRESULT hr;
|
|
|
|
hr = _FindDataForGet(pfe, &ife);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (ife == DROP_FCont)
|
|
hr = _RenderFileContents(pfe, pstg);
|
|
else
|
|
{
|
|
hr = _ForceRender(ife);
|
|
if (SUCCEEDED(hr)) // May not succeed for security reasons.
|
|
{
|
|
ASSERT(m_stgCache[ife].hGlobal);
|
|
|
|
// It's possible to use the hacking STGMEDIUM.pUnkForRelease to give away
|
|
// pointers to our data, but we then need massive amounts of code to babysite
|
|
// the lifetime of those pointers. This becomes more work when ::SetData() can
|
|
// replace that data, so we just take the hit of the memcpy for less code.
|
|
hr = CopyStgMediumWrap(&m_stgCache[ife], pstg);
|
|
ASSERT(SUCCEEDED(hr));
|
|
ASSERT(NULL == pstg->pUnkForRelease);
|
|
//TraceMsg(TF_FTPDRAGDROP, "CFtpObj::GetData() pstg->hGlobal=%#08lx. pstg->pUnkForRelease=%#08lx.", pstg->hGlobal, pstg->pUnkForRelease);
|
|
}
|
|
}
|
|
|
|
TraceMsgWithFormat(TF_FTPDRAGDROP, "CFtpObj::GetData()", pfe, "Format in static list", hr);
|
|
}
|
|
else
|
|
{
|
|
int nIndex = _FindExtraDataIndex(pfe);
|
|
|
|
if (-1 == nIndex)
|
|
hr = E_FAIL;
|
|
else
|
|
{
|
|
FORMATETC_STGMEDIUM fs;
|
|
|
|
DSA_GetItem(m_hdsaSetData, nIndex, &fs);
|
|
hr = CopyStgMediumWrap(&fs.medium, pstg);
|
|
}
|
|
|
|
TraceMsgWithFormat(TF_FTPDRAGDROP, "CFtpObj::GetData()", pfe, "Looking in dyn list", hr);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
IDataObject::GetDataHere
|
|
|
|
Render the data in the requested format and put it into the
|
|
object provided by the caller.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::GetDataHere(FORMATETC *pfe, STGMEDIUM *pstg)
|
|
{
|
|
TraceMsg(TF_FTPDRAGDROP, "CFtpObj::GetDataHere() pfe->cfFormat=%d.", pfe->cfFormat);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IDataObject::QueryGetData
|
|
|
|
DESCRIPTION:
|
|
Indicate whether we could provide data in the requested format.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::QueryGetData(FORMATETC *pfe)
|
|
{
|
|
int ife;
|
|
HRESULT hr = _FindDataForGet(pfe, &ife);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
// If it wasn't one of the types we offer, see if it was given to us via
|
|
// IDataObject::SetData().
|
|
int nIndex = _FindExtraDataIndex(pfe);
|
|
|
|
if (-1 != nIndex)
|
|
hr = S_OK;
|
|
}
|
|
|
|
TraceMsgWithFormat(TF_FTPDRAGDROP, "CFtpObj::QueryGetData()", pfe, "", hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IDataObject::GetCanonicalFormatEtc
|
|
|
|
DESCRIPTION:
|
|
Our data are not sensitive to device-specific renderings,
|
|
so we do what the book tells us to do.
|
|
|
|
Or we *try* to do what the book tells us to do.
|
|
|
|
OLE random documentation of the day:
|
|
IDataObject::GetCanonicalFormatEtc.
|
|
|
|
Turns out that the man page contradicts itself within sentences:
|
|
|
|
DATA_S_SAMEFORMATETC - The FORMATETC structures are the same
|
|
and NULL is returned in pfeOut.
|
|
|
|
If the data object never provides device-specific renderings,
|
|
the implementation of IDataObject::GetCanonicalFormatEtc
|
|
simply copies the input FORMATETC to the output FORMATETC,
|
|
stores a null in the ptd field, and returns DATA_S_SAMEFORMATETC.
|
|
|
|
And it turns out that the shell doesn't do *either* of these things.
|
|
It just returns DATA_S_SAMEFORMATETC and doesn't touch pfeOut.
|
|
|
|
The book is even more confused. Under pfeOut, it says
|
|
|
|
The value is NULL if the method returns DATA_S_SAMEFORMATETC.
|
|
|
|
This makes no sense. The caller provides the value of pfeOut.
|
|
How can the caller possibly know that the method is going to return
|
|
DATA_S_SAMEFORMATETC before it calls it? If you expect the
|
|
method to write "pfeOut = 0" before returning, you're nuts. That
|
|
communicates nothing to the caller.
|
|
|
|
I'll just do what the shell does.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::GetCanonicalFormatEtc(FORMATETC *pfeIn, FORMATETC *pfeOut)
|
|
{
|
|
return DATA_S_SAMEFORMATETC;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IDataObject::SetData
|
|
|
|
DESCRIPTION:
|
|
We let people change TYMED_HGLOBAL gizmos, but nothing else.
|
|
|
|
We need to do a careful two-step when replacing the HGLOBAL.
|
|
If the user gave us a plain HGLOBAL without a pUnkForRelease,
|
|
we need to invent our own pUnkForRelease to track it. But we
|
|
don't want to release the old STGMEDIUM until we're sure we
|
|
can accept the new one.
|
|
|
|
fRelease == 0 makes life doubly interesting, because we also
|
|
have to clone the HGLOBAL (and remember to free the clone on the
|
|
error path).
|
|
|
|
_SOMEDAY_/TODO -- Need to support PerformedDropEffect so we can
|
|
clean up stuff on a cut/paste.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::SetData(FORMATETC *pfe, STGMEDIUM *pstg, BOOL fRelease)
|
|
{
|
|
int ife;
|
|
HRESULT hr;
|
|
|
|
hr = _FindData(pfe, &ife);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (ife == DROP_FCont)
|
|
{
|
|
TraceMsg(TF_FTPDRAGDROP, "CFtpObj::SetData(FORMATETC.cfFormat=%d) ife == DROP_FCont", pfe->cfFormat);
|
|
hr = DV_E_FORMATETC;
|
|
}
|
|
else
|
|
{
|
|
ASSERT(g_dropTypes[ife].tymed == TYMED_HGLOBAL);
|
|
ASSERT(pstg->tymed == TYMED_HGLOBAL);
|
|
if (pstg->hGlobal)
|
|
{
|
|
STGMEDIUM stg = {0};
|
|
|
|
hr = CopyStgMediumWrap(pstg, &stg);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ReleaseStgMedium(&m_stgCache[ife]);
|
|
m_stgCache[ife] = stg;
|
|
}
|
|
}
|
|
else
|
|
{ // Tried to SetData a _DelayRender
|
|
hr = DV_E_STGMEDIUM;
|
|
}
|
|
}
|
|
|
|
TraceMsgWithFormat(TF_FTPDRAGDROP, "CFtpObj::SetData()", pfe, "in static list", hr);
|
|
}
|
|
else
|
|
{
|
|
hr = _SetExtraData(pfe, pstg, fRelease);
|
|
TraceMsgWithFormat(TF_FTPDRAGDROP, "CFtpObj::SetData()", pfe, "in dyn list", hr);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IDataObject::EnumFormatEtc
|
|
|
|
DESCRIPTION:
|
|
_UNDOCUMENTED_: If you drag something from a DefView, it will
|
|
check the data object to see if it has a hida. If so, then it
|
|
will cook up a CFSTR_SHELLIDLISTOFFSET *for you* and SetData
|
|
the information into the data object. So in order to get
|
|
position-aware drag/drop working, you must allow DefView to change
|
|
your CFSTR_SHELLIDLISTOFFSET.
|
|
|
|
We allow all FORMATETCs to be modified except for FileContents.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppenum)
|
|
{
|
|
HRESULT hres;
|
|
|
|
switch (dwDirection)
|
|
{
|
|
case DATADIR_GET:
|
|
hres = CFtpEfe_Create(DROP_OFFERMAX - DROP_FCont, &g_dropTypes[DROP_FCont],
|
|
&m_stgCache[DROP_FCont], this, ppenum);
|
|
TraceMsg(TF_FTPDRAGDROP, "CFtpObj::EnumFormatEtc(DATADIR_GET) CFtpEfe_Create() returned hres=%#08lx", hres);
|
|
break;
|
|
|
|
case DATADIR_SET:
|
|
hres = CFtpEfe_Create(DROP_OFFERMAX - DROP_OFFERMIN, &g_dropTypes[DROP_OFFERMIN],
|
|
&m_stgCache[DROP_OFFERMIN], NULL, ppenum);
|
|
TraceMsg(TF_FTPDRAGDROP, "CFtpObj::EnumFormatEtc(DATADIR_SET) CFtpEfe_Create() returned hres=%#08lx", hres);
|
|
break;
|
|
|
|
default:
|
|
ASSERT(0);
|
|
hres = E_NOTIMPL;
|
|
break;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IDataObject::DAdvise
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::DAdvise(FORMATETC *pfe, DWORD advfl, IAdviseSink *padv, DWORD *pdwConnection)
|
|
{
|
|
return OLE_E_ADVISENOTSUPPORTED;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IDataObject::DUnadvise
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::DUnadvise(DWORD dwConnection)
|
|
{
|
|
return OLE_E_ADVISENOTSUPPORTED;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: IDataObject::EnumDAdvise
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj::EnumDAdvise(IEnumSTATDATA **ppeadv)
|
|
{
|
|
return OLE_E_ADVISENOTSUPPORTED;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: CFtpObj_Create
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj_Create(CFtpFolder * pff, CFtpPidlList * pflHfpl, REFIID riid, LPVOID * ppvObj)
|
|
{
|
|
HRESULT hres;
|
|
CFtpObj * pfo;
|
|
|
|
*ppvObj = NULL;
|
|
|
|
hres = CFtpObj_Create(pff, pflHfpl, &pfo);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
pfo->QueryInterface(riid, ppvObj);
|
|
pfo->Release();
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: CFtpObj_Create
|
|
|
|
DESCRIPTION:
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj_Create(CFtpFolder * pff, CFtpPidlList * pflHfpl, CFtpObj ** ppfo)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
|
|
if (EVAL(pflHfpl->GetCount()))
|
|
{
|
|
*ppfo = new CFtpObj();
|
|
|
|
if (*ppfo)
|
|
{
|
|
CFtpObj * pfo = *ppfo;
|
|
pfo->m_pfd = pff->GetFtpDir();
|
|
|
|
if (pfo->m_pfd)
|
|
{
|
|
pfo->m_pff = pff;
|
|
if (pff)
|
|
pff->AddRef();
|
|
|
|
IUnknown_Set(&pfo->m_pflHfpl, pflHfpl);
|
|
|
|
if (pfo->m_pflHfpl->GetCount() == 1)
|
|
{
|
|
pfo->m_stgCache[DROP_URL].tymed = TYMED_HGLOBAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hres = E_FAIL;
|
|
(*ppfo)->Release();
|
|
*ppfo = NULL;
|
|
}
|
|
}
|
|
else
|
|
hres = E_OUTOFMEMORY;
|
|
|
|
}
|
|
else
|
|
{
|
|
*ppfo = NULL;
|
|
hres = E_INVALIDARG; /* Trying to get UI object of nil? */
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
FUNCTION: CFtpObj_Create
|
|
|
|
DESCRIPTION:
|
|
This will be called by the Class Factory when the IDataObject gets
|
|
persisted and then wants to be recreated in a new process. (Happens
|
|
after the original thread/process calls OleFlushClipboard.
|
|
\*****************************************************************************/
|
|
HRESULT CFtpObj_Create(REFIID riid, void ** ppvObj)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
CFtpObj * pfo = new CFtpObj();
|
|
|
|
*ppvObj = NULL;
|
|
if (pfo)
|
|
{
|
|
hr = pfo->QueryInterface(riid, ppvObj);
|
|
pfo->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
#define SETDATA_GROWSIZE 3
|
|
|
|
/****************************************************\
|
|
Constructor
|
|
\****************************************************/
|
|
CFtpObj::CFtpObj() : m_cRef(1)
|
|
{
|
|
DllAddRef();
|
|
|
|
// This needs to be allocated in Zero Inited Memory.
|
|
// Assert that all Member Variables are inited to Zero.
|
|
ASSERT(!m_pff);
|
|
ASSERT(!m_pfd);
|
|
ASSERT(!m_pflHfpl);
|
|
ASSERT(!m_fDidAsynchStart);
|
|
|
|
// NT #245306: If the user drags files from an FTP window (Thread 1)
|
|
// to a shell window (Thread 2), the shell window will do
|
|
// the drop on a background thread (thread 3). Since the
|
|
// UI thread is no longer blocked, the user can now close
|
|
// the window. The problem is that OLE is using Thread 2
|
|
// for marshalling. In order to solve this problem, we
|
|
// ref count the thread for items that rely on it.
|
|
// This include FTP, normal Download, and other things
|
|
// in the future.
|
|
// SHIncrementThreadModelessCount();
|
|
|
|
m_nStartIndex = -1; // -1 means we don't know the start.
|
|
m_fFGDRendered = FALSE;
|
|
m_fCheckSecurity = TRUE; // We need to keep checking.
|
|
|
|
m_hdsaSetData = DSA_Create(sizeof(FORMATETC_STGMEDIUM), SETDATA_GROWSIZE);
|
|
|
|
for (int nIndex = 0; nIndex < ARRAYSIZE(c_stgInit); nIndex++)
|
|
{
|
|
ASSERT(nIndex < ARRAYSIZE(m_stgCache));
|
|
m_stgCache[nIndex] = c_stgInit[nIndex];
|
|
}
|
|
|
|
_RefThread();
|
|
// The receiver may use us in the background, so make sure that our thread
|
|
// doesn't go away.
|
|
LEAK_ADDREF(LEAK_CFtpObj);
|
|
}
|
|
|
|
|
|
/****************************************************\
|
|
Destructor
|
|
\****************************************************/
|
|
CFtpObj::~CFtpObj()
|
|
{
|
|
int ife;
|
|
|
|
_CloseProgressDialog();
|
|
for (ife = DROP_OFFERMIN; ife < DROP_OFFERMAX; ife++)
|
|
{
|
|
ReleaseStgMedium(&m_stgCache[ife]);
|
|
}
|
|
|
|
if (m_ppd)
|
|
m_ppd->StopProgressDialog();
|
|
|
|
IUnknown_Set((IUnknown **)&m_ppd, NULL);
|
|
IUnknown_Set(&m_pff, NULL);
|
|
IUnknown_Set(&m_pfd, NULL);
|
|
IUnknown_Set(&m_pflHfpl, NULL);
|
|
|
|
DSA_DestroyCallback(m_hdsaSetData, &_DSA_FreeCB, NULL);
|
|
|
|
// NT #245306: If the user drags files from an FTP window (Thread 1)
|
|
// to a shell window (Thread 2), the shell window will do
|
|
// the drop on a background thread (thread 3). Since the
|
|
// UI thread is no longer blocked, the user can now close
|
|
// the window. The problem is that OLE is using Thread 2
|
|
// for marshalling. In order to solve this problem, we
|
|
// ref count the thread for items that rely on it.
|
|
// This include FTP, normal Download, and other things
|
|
// in the future.
|
|
ATOMICRELEASE(m_punkThreadRef);
|
|
|
|
DllRelease();
|
|
LEAK_DELREF(LEAK_CFtpObj);
|
|
}
|
|
|
|
|
|
//===========================
|
|
// *** IUnknown Interface ***
|
|
//===========================
|
|
|
|
ULONG CFtpObj::AddRef()
|
|
{
|
|
m_cRef++;
|
|
return m_cRef;
|
|
}
|
|
|
|
ULONG CFtpObj::Release()
|
|
{
|
|
ASSERT(m_cRef > 0);
|
|
m_cRef--;
|
|
|
|
if (m_cRef > 0)
|
|
return m_cRef;
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
|
|
HRESULT CFtpObj::QueryInterface(REFIID riid, void **ppvObj)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CFtpObj, IDataObject),
|
|
QITABENT(CFtpObj, IInternetSecurityMgrSite),
|
|
QITABENT(CFtpObj, IPersist),
|
|
QITABENT(CFtpObj, IPersistStream),
|
|
QITABENT(CFtpObj, IAsyncOperation),
|
|
{ 0 },
|
|
};
|
|
|
|
return QISearch(this, qit, riid, ppvObj);
|
|
}
|