String getURL(IDataObject* dataObject, bool& success, String* title)
{
STGMEDIUM store;
String url;
success = false;
if (getWebLocData(dataObject, url, title)) {
success = true;
return url;
} else if (SUCCEEDED(dataObject->GetData(urlWFormat(), &store))) {
//URL using unicode
UChar* data = (UChar*)GlobalLock(store.hGlobal);
url = extractURL(String(data), title);
GlobalUnlock(store.hGlobal);
ReleaseStgMedium(&store);
success = true;
} else if (SUCCEEDED(dataObject->GetData(urlFormat(), &store))) {
//URL using ascii
char* data = (char*)GlobalLock(store.hGlobal);
url = extractURL(String(data), title);
GlobalUnlock(store.hGlobal);
ReleaseStgMedium(&store);
success = true;
} else if (SUCCEEDED(dataObject->GetData(filenameWFormat(), &store))) {
//file using unicode
wchar_t* data = (wchar_t*)GlobalLock(store.hGlobal);
if (data && data[0] && (PathFileExists(data) || PathIsUNC(data))) {
RetainPtr<CFStringRef> pathAsCFString(AdoptCF, CFStringCreateWithCharacters(kCFAllocatorDefault, (const UniChar*)data, wcslen(data)));
if (urlFromPath(pathAsCFString.get(), url)) {
if (title)
*title = url;
success = true;
}
}
GlobalUnlock(store.hGlobal);
ReleaseStgMedium(&store);
} else if (SUCCEEDED(dataObject->GetData(filenameFormat(), &store))) {
//filename using ascii
char* data = (char*)GlobalLock(store.hGlobal);
if (data && data[0] && (PathFileExistsA(data) || PathIsUNCA(data))) {
RetainPtr<CFStringRef> pathAsCFString(AdoptCF, CFStringCreateWithCString(kCFAllocatorDefault, data, kCFStringEncodingASCII));
if (urlFromPath(pathAsCFString.get(), url)) {
if (title)
*title = url;
success = true;
}
}
GlobalUnlock(store.hGlobal);
ReleaseStgMedium(&store);
}
return url;
}
STDMETHODIMP CFdmUplSendToShlExt::DragEnter (IDataObject* pDataObj, DWORD grfKeyState,
POINTL pt, DWORD* pdwEffect)
{
*pdwEffect = DROPEFFECT_NONE;
FORMATETC fmt = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
STGMEDIUM stg = { TYMED_HGLOBAL };
HDROP hDrop;
if (FAILED (pDataObj->GetData (&fmt, &stg)))
return E_INVALIDARG;
hDrop = (HDROP) GlobalLock (stg.hGlobal);
if (hDrop == NULL)
return E_INVALIDARG;
int cFiles = DragQueryFile (hDrop, 0xFFFFFFFF, NULL, 0);
if (cFiles == 0)
{
GlobalUnlock (stg.hGlobal);
ReleaseStgMedium (&stg);
return E_INVALIDARG;
}
for (int i = 0; i < cFiles; i++)
{
char szFile [MAX_PATH];
if (0 == DragQueryFile (hDrop, i, szFile, MAX_PATH))
continue;
DWORD dwAttribs = GetFileAttributes (szFile);
if (dwAttribs == DWORD (-1))
continue;
m_vFiles.push_back (szFile);
}
GlobalUnlock (stg.hGlobal);
ReleaseStgMedium (&stg);
if (m_vFiles.size () == 0)
return E_INVALIDARG;
*pdwEffect = DROPEFFECT_COPY;
return S_OK;
}
// CSimpleShlExt
//我们要做的是取得被右击选择的文件名,再把该文件名显示在弹出消息框中。
//可能会有多个文件同时被选择右击, 你可以用pDataObj 接口指针获取所有的文件名, 但现在为简单起见, 我们只获取第一个文件名.
//add by ray 2014-05-15 17:45
HRESULT CSimpleShlExt::Initialize ( LPCITEMIDLIST pidlFolder, LPDATAOBJECT pDataObj, HKEY hProgID )
{
//文件名的存放格式与你拖放文件到带WS_EX_ACCEPTFILES风格的窗口时使用的文件名格式是一样的。
// 这就是说我们可以使用同样的API来获取文件名: DragQueryFile().
// 首先我们先获取包含在IdataObject中的数据句柄:
FORMATETC fmt = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
STGMEDIUM stg = { TYMED_HGLOBAL };
HDROP hDrop;
// 在数据对象内查找 CF_HDROP 型数据.
if ( FAILED( pDataObj->GetData ( &fmt, &stg )))
{
// Nope! Return an "invalid argument" error back to Explorer.
return E_INVALIDARG;
}
// 获得指向实际数据的指针
hDrop = (HDROP) GlobalLock ( stg.hGlobal );
// 检查非NULL.
if ( NULL == hDrop )
{
return E_INVALIDARG;
}
//请注意错误检查，特别是指针的检查。
// 由于我们的扩展运行在 Explorer 进程内, 要是我们的代码崩溃了, Explorer也会随之崩溃. 在Win 9x上, 这样的一个崩溃可能导致需要重启系统.
// 所以, 现在我们有了一个 HDROP 句柄, 我们就可以获取我们需要的文件名了：
// 有效性检查 – 保证最少有一个文件名.
UINT uNumFiles = DragQueryFile ( hDrop, 0xFFFFFFFF, NULL, 0 );
if ( 0 == uNumFiles )
{
GlobalUnlock ( stg.hGlobal );
ReleaseStgMedium ( &stg );
return E_INVALIDARG;
}
HRESULT hr = S_OK;
// 取得第一个文件名并把它保存在类成员m_szFile 中.
if ( 0 == DragQueryFile ( hDrop, 0, m_szFile, MAX_PATH ))
{
hr = E_INVALIDARG;
}
GlobalUnlock ( stg.hGlobal );
ReleaseStgMedium ( &stg );
return hr;
}
bool ClipboardUtil::GetUrl(IDataObject* data_object, std::wstring* url,
std::wstring* title, bool convert_filenames)
{
DCHECK(data_object && url && title);
if(!HasUrl(data_object))
{
return false;
}
// 尝试从|data_object|的多种格式中提取URL.
STGMEDIUM store;
if(GetUrlFromHDrop(data_object, url, title))
{
return true;
}
if(SUCCEEDED(data_object->GetData(GetMozUrlFormat(), &store)) ||
SUCCEEDED(data_object->GetData(GetUrlWFormat(), &store)))
{
{
// Mozilla URL格式或者unicode URL.
base::win::ScopedHGlobal<wchar_t> data(store.hGlobal);
SplitUrlAndTitle(data.get(), url, title);
}
ReleaseStgMedium(&store);
return true;
}
if(SUCCEEDED(data_object->GetData(GetUrlFormat(), &store)))
{
{
// URL使用ascii.
base::win::ScopedHGlobal<char> data(store.hGlobal);
SplitUrlAndTitle(UTF8ToWide(data.get()), url, title);
}
ReleaseStgMedium(&store);
return true;
}
if(convert_filenames)
{
return GetFileUrl(data_object, url, title);
}
else
{
return false;
}
}
STDMETHODIMP CShellPropSheetExt::Initialize(PCIDLIST_ABSOLUTE pidlFolder, IDataObject *pdtobj, HKEY hkeyProgID)
{
HRESULT hr;
FORMATETC formatetc;
STGMEDIUM medium;
LPTSTR lpszFilePath;
formatetc.cfFormat = RegisterClipboardFormat(CFSTR_FILENAME);
formatetc.ptd = NULL;
formatetc.dwAspect = DVASPECT_CONTENT;
formatetc.lindex = -1;
formatetc.tymed = TYMED_HGLOBAL;
hr = pdtobj->GetData(&formatetc, &medium);
if (FAILED(hr))
return E_FAIL;
lpszFilePath = (LPTSTR)GlobalLock(medium.hGlobal);
filepath = lpszFilePath;
GlobalUnlock(medium.hGlobal);
ReleaseStgMedium(&medium);
return S_OK;
}
HRESULT CDropTarget::GetDroppedFiles(IDataObject *lpDataObject,std::list<CString> &fileList)
{
FORMATETC fmt;
STGMEDIUM medium;
fmt.cfFormat = CF_HDROP;
fmt.ptd = NULL;
fmt.dwAspect = DVASPECT_CONTENT;
fmt.lindex = -1;
fmt.tymed = TYMED_HGLOBAL;
fileList.clear();
HRESULT hr=lpDataObject->GetData(&fmt, &medium);
if(S_OK==hr){
//ファイルがドロップされた
//---ファイル数を取得
UINT nFileCount = ::DragQueryFile((HDROP)medium.hGlobal, 0xFFFFFFFF, NULL, 0);
//ファイル取得
for(UINT i=0; i<nFileCount;i++){
TCHAR szBuffer[_MAX_PATH+2]={0};
::DragQueryFile((HDROP)medium.hGlobal, i, szBuffer, _MAX_PATH + 1);
fileList.push_back(szBuffer);
}
//解放
ReleaseStgMedium(&medium);
return S_OK;
}else{
return hr;
}
}
/***********************************************************************
* CopyBindInfo (URLMON.@)
*/
HRESULT WINAPI CopyBindInfo(const BINDINFO *pcbiSrc, BINDINFO *pcbiDest)
{
DWORD size;
HRESULT hres;
TRACE("(%p %p)\n", pcbiSrc, pcbiDest);
if(!pcbiSrc || !pcbiDest)
return E_POINTER;
if(!pcbiSrc->cbSize || !pcbiDest->cbSize)
return E_INVALIDARG;
size = pcbiDest->cbSize;
if(size > pcbiSrc->cbSize) {
memcpy(pcbiDest, pcbiSrc, pcbiSrc->cbSize);
memset((char*)pcbiDest+pcbiSrc->cbSize, 0, size-pcbiSrc->cbSize);
} else {
memcpy(pcbiDest, pcbiSrc, size);
}
pcbiDest->cbSize = size;
size = FIELD_OFFSET(BINDINFO, szExtraInfo)+sizeof(void*);
if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size && pcbiSrc->szExtraInfo) {
size = (strlenW(pcbiSrc->szExtraInfo)+1)*sizeof(WCHAR);
pcbiDest->szExtraInfo = CoTaskMemAlloc(size);
if(!pcbiDest->szExtraInfo)
return E_OUTOFMEMORY;
memcpy(pcbiDest->szExtraInfo, pcbiSrc->szExtraInfo, size);
}
size = FIELD_OFFSET(BINDINFO, stgmedData)+sizeof(STGMEDIUM);
if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size) {
hres = CopyStgMedium(&pcbiSrc->stgmedData, &pcbiDest->stgmedData);
if(FAILED(hres)) {
CoTaskMemFree(pcbiDest->szExtraInfo);
return hres;
}
}
size = FIELD_OFFSET(BINDINFO, szCustomVerb)+sizeof(void*);
if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size && pcbiSrc->szCustomVerb) {
size = (strlenW(pcbiSrc->szCustomVerb)+1)*sizeof(WCHAR);
pcbiDest->szCustomVerb = CoTaskMemAlloc(size);
if(!pcbiDest->szCustomVerb) {
CoTaskMemFree(pcbiDest->szExtraInfo);
ReleaseStgMedium(&pcbiDest->stgmedData);
return E_OUTOFMEMORY;
}
memcpy(pcbiDest->szCustomVerb, pcbiSrc->szCustomVerb, size);
}
size = FIELD_OFFSET(BINDINFO, securityAttributes)+sizeof(SECURITY_ATTRIBUTES);
if(pcbiDest->cbSize >= size)
memset(&pcbiDest->securityAttributes, 0, sizeof(SECURITY_ATTRIBUTES));
if(pcbiSrc->pUnk)
IUnknown_AddRef(pcbiDest->pUnk);
return S_OK;
}
HRESULT __stdcall CBookmarksToolbarDropHandler::DragEnter(IDataObject *pDataObject,
DWORD grfKeyState,POINTL pt,DWORD *pdwEffect)
{
UNREFERENCED_PARAMETER(grfKeyState);
bool m_bValid = false;
bool m_bAllFolders = true;
FORMATETC ftc = {CF_HDROP,0,DVASPECT_CONTENT,-1,TYMED_HGLOBAL};
STGMEDIUM stg;
HRESULT hr = pDataObject->GetData(&ftc,&stg);
if(hr == S_OK)
{
DROPFILES *pdf = reinterpret_cast<DROPFILES *>(GlobalLock(stg.hGlobal));
if(pdf != NULL)
{
m_bValid = true;
UINT nDroppedFiles = DragQueryFile(reinterpret_cast<HDROP>(pdf),0xFFFFFFFF,NULL,NULL);
for(UINT i = 0;i < nDroppedFiles;i++)
{
TCHAR szFullFileName[MAX_PATH];
DragQueryFile(reinterpret_cast<HDROP>(pdf),i,szFullFileName,
SIZEOF_ARRAY(szFullFileName));
if(!PathIsDirectory(szFullFileName))
{
m_bAllFolders = false;
break;
}
}
GlobalUnlock(stg.hGlobal);
}
ReleaseStgMedium(&stg);
}
if(m_bValid &&
m_bAllFolders)
{
*pdwEffect = DROPEFFECT_COPY;
m_bAcceptData = true;
}
else
{
*pdwEffect = DROPEFFECT_NONE;
m_bAcceptData = false;
}
m_pDropTargetHelper->DragEnter(m_hToolbar,pDataObject,reinterpret_cast<POINT *>(&pt),*pdwEffect);
return S_OK;
}
//IDropTarget methods
STDMETHODIMP CDropTarget::DragEnter(IDataObject* pDataObject, DWORD grfKeyState, POINTL pt, DWORD* pdwEffect)
{
#ifdef _DEBUG
printf("IDropTarget::DragEnter\n");
#endif //_DEBUG
pDataObj = pDataObject;
pDataObject->AddRef();
hdrop_present = false;
if (hexwnd.prefer_CF_HDROP)
{
FORMATETC fe = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, 0xffffffff };
STGMEDIUM stm;
if (S_OK == pDataObject->QueryGetData(&fe))
{
hdrop_present = true;
*pdwEffect = DROPEFFECT_COPY;
return S_OK;
}
else if (S_OK == pDataObject->GetData(&fe, &stm))
{
hdrop_present = true;
ReleaseStgMedium(&stm);
*pdwEffect = DROPEFFECT_COPY;
return S_OK;
}
}
hexwnd.pwnd->CreateCaret((HBITMAP)1, 2, hexwnd.cyChar);
return DragOver(grfKeyState, pt, pdwEffect);
}
void
getDropData(IDataObject* dataObject)
{
// construct a FORMATETC object
FORMATETC fmtEtc = { CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
STGMEDIUM stgMed;
// See if the dataobject contains any DROP stored as a HGLOBAL
if (dataObject->QueryGetData(&fmtEtc) == S_OK) {
if (dataObject->GetData(&fmtEtc, &stgMed) == S_OK) {
// get data here
PVOID data = GlobalLock(stgMed.hGlobal);
// data object global handler contains:
// DROPFILESfilename1 filename2 two spaces as the end
// TODO: get multiple filenames
wchar_t* wcData = (wchar_t*)((LPBYTE)data + sizeof(DROPFILES));
// convert wchar to char
char* filename = new char[wcslen(wcData) + 1];
filename[wcslen(wcData)] = '\0';
wcstombs(filename, wcData, wcslen(wcData));
MSWindowsDropTarget::instance().setDraggingFilename(filename);
GlobalUnlock(stgMed.hGlobal);
// release the data using the COM API
ReleaseStgMedium(&stgMed);
delete[] filename;
}
}
}
///////////////////////////////////////////////////////////////////////////////
// Schreiben/Lesen eines Variant
HRESULT SetVariantData (CComVariant &rv, IDataObject *pIDO, const FORMATETC *pcfe)
{
// Stream mit Variant generieren
WStream IStream;
HRESULT hr = CreateStreamOnHGlobal (NULL, true, IStream.ppi());
if (FAILED(hr)) return hr;
// Variant dort rein schreiben
hr = rv.WriteToStream (IStream);
if (FAILED(hr)) return hr;
LARGE_INTEGER li;
LISet32(li, 0L);
hr = IStream -> Seek (li, SEEK_SET, NULL);
if (FAILED(hr)) return hr;
// diesen Stream im DataObject setzen
STGMEDIUM stg;
stg.tymed = TYMED_ISTREAM;
stg.pstm = IStream.detach();
stg.pUnkForRelease = NULL;
hr = pIDO -> SetData ((FORMATETC *)pcfe, &stg, true);
if (FAILED(hr)) {
ReleaseStgMedium (&stg);
return hr;
}
return S_OK;
}
//
// IDataObject::SetData
//
HRESULT __stdcall CDataObject::SetData (FORMATETC *pFormatEtc, STGMEDIUM *pMedium, BOOL fRelease)
{
int res=LookupFormatEtc(pFormatEtc, pMedium, TRUE);
if(-1 == res)
{
return S_FALSE;
}
if (m_pStgMedium[res].tymed)
{
ReleaseStgMedium ( &m_pStgMedium[res] );
ZeroMemory (&m_pStgMedium[res], sizeof(STGMEDIUM) );
}
if(fRelease)
{
m_pStgMedium[res]=*pMedium;
}
else
{
CopyStgMedium(pMedium, &m_pStgMedium[res]);
}
m_pFormatEtc[res].tymed=m_pStgMedium[res].tymed;
if(m_pStgMedium[res].tymed==TYMED_HGLOBAL)
{
m_pStgMedium[res].hGlobal=DupMem(pMedium->hGlobal);//必须分配足够的内存空间和拷贝数据。
}
if(GetCanonicalIUnknown(m_pStgMedium[res].pUnkForRelease)==
GetCanonicalIUnknown(static_cast<IDataObject*>(this)))
{
m_pStgMedium[res].pUnkForRelease->Release();
m_pStgMedium[res].pUnkForRelease = NULL;
}
return S_OK;
}
STDMETHODIMP CToolBarCombo::Drop(LPDATAOBJECT pDataObj, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect){
*pdwEffect=DROPEFFECT_NONE;
if (m_pIDataObject == NULL)
return E_FAIL;
DragLeave();
FORMATETC formatDetails;
STGMEDIUM stmg;
// Let's get the text from the "clipboard"
formatDetails.cfFormat = CF_TEXT;
formatDetails.dwAspect = DVASPECT_CONTENT;
formatDetails.lindex = -1;
formatDetails.ptd = NULL;
formatDetails.tymed = TYMED_HGLOBAL;
if (SUCCEEDED(pDataObj->GetData(&formatDetails, &stmg)))
{
char* sClipboard = (char*)GlobalLock(stmg.hGlobal);
::SetWindowTextA(m_hWnd,sClipboard);
AddtoHistory(sClipboard);
GlobalUnlock(stmg.hGlobal);
if (stmg.hGlobal != NULL)
ReleaseStgMedium(&stmg);
}
*pdwEffect=DROPEFFECT_COPY;
//search immediately after dragging
::PostMessage(GetParent(),kWM_TBCOMBOSEARCH_WEB, 0, 0);
return NOERROR;
}
STDMETHODIMP CToolBarCombo::DragEnter(LPDATAOBJECT pDataObj , DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect){
m_pIDataObject=NULL;
ATL::CString sText;
FORMATETC formatDetails;
STGMEDIUM stmg;
// Let's get the text from the "clipboard"
formatDetails.cfFormat = CF_TEXT;
formatDetails.dwAspect = DVASPECT_CONTENT;
formatDetails.lindex = -1;
formatDetails.ptd = NULL;
formatDetails.tymed = TYMED_HGLOBAL;
if (SUCCEEDED(pDataObj->GetData(&formatDetails, &stmg)))
{
sText = (LPSTR)GlobalLock(stmg.hGlobal);
GlobalUnlock(stmg.hGlobal);
if (stmg.hGlobal != NULL)
ReleaseStgMedium(&stmg);
}
*pdwEffect=DROPEFFECT_COPY;
m_pIDataObject=pDataObj;
m_pIDataObject->AddRef();
return NOERROR;
}
ClipboardReader::~ClipboardReader()
{
if (stgmed.hGlobal)
ReleaseStgMedium(&stgmed);
if (pDataObj)
pDataObj->Release();
}
CShowActiveDirUsers::~CShowActiveDirUsers()
{
if (m_stg.hGlobal)
{
ReleaseStgMedium(&m_stg);
}
}
/** Gets a file list from data. Caller must ensure that the data actually contains a file list. */
Vector<Path>* Win32DropTarget::getFileListFromData(IDataObject* data)
{
FORMATETC fmtetc = { CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
STGMEDIUM stgmed;
Vector<Path>* files = bs_new<Vector<Path>>();
if(data->GetData(&fmtetc, &stgmed) == S_OK)
{
PVOID data = GlobalLock(stgmed.hGlobal);
HDROP hDrop = (HDROP)data;
UINT numFiles = DragQueryFileW(hDrop, 0xFFFFFFFF, nullptr, 0);
files->resize(numFiles);
for(UINT i = 0; i < numFiles; i++)
{
UINT numChars = DragQueryFileW(hDrop, i, nullptr, 0) + 1;
wchar_t* buffer = (wchar_t*)bs_alloc((UINT32)numChars * sizeof(wchar_t));
DragQueryFileW(hDrop, i, buffer, numChars);
(*files)[i] = UTF8::fromWide(WString(buffer));
bs_free(buffer);
}
GlobalUnlock(stgmed.hGlobal);
ReleaseStgMedium(&stgmed);
}
return files;
}
STDMETHODIMP
CShellExtension::Initialize(
LPCITEMIDLIST pidlFolder, LPDATAOBJECT pDataObj, HKEY hProgID)
{
FORMATETC fmt = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
STGMEDIUM stg = { TYMED_HGLOBAL };
HDROP hDrop;
// Look for CF_HDROP data in the data object.
if (FAILED(pDataObj->GetData(&fmt, &stg)))
{
// Nope! Return an "invalid argument" error back to Explorer.
return E_INVALIDARG;
}
// Get a pointer to the actual data.
hDrop = (HDROP)GlobalLock(stg.hGlobal);
// Make sure it worked.
if (NULL == hDrop)
return E_INVALIDARG;
// Sanity check - make sure there is at least one filename.
UINT uNumFiles = DragQueryFile(hDrop, 0xFFFFFFFF, NULL, 0);
HRESULT hr = S_OK;
if (0 == uNumFiles)
{
GlobalUnlock(stg.hGlobal);
ReleaseStgMedium(&stg);
return E_INVALIDARG;
}
m_numFiles = uNumFiles;
TCHAR opString[MAX_PATH];
_stprintf_s(opString, MAX_PATH, TEXT("Found %d files"), uNumFiles);
OutputDebugString(opString);
// Get the name of the first file and store it in our member variable m_szFile.
if (0 == DragQueryFile(hDrop, 0, m_szFile, MAX_PATH))
hr = E_INVALIDARG;
GlobalUnlock(stg.hGlobal);
ReleaseStgMedium(&stg);
return hr;
}
void PySTGMEDIUM::Close()
{
if (medium.tymed) {
ReleaseStgMedium(&medium);
memset(&medium, 0, sizeof(medium));
assert(!medium.tymed);
}
}
WCDataObject::~WCDataObject()
{
for(size_t i = 0; i < m_medium.size(); ++i) {
ReleaseStgMedium(m_medium[i]);
delete m_medium[i];
}
WTF::deleteAllValues(m_formats);
}
/***********************************************
QDropEvent
************************************************/
QByteArray QDropEvent::encodedData( const char * format ) const
{
#ifdef DEBUG_QDND_WIN
qDebug( "QDropEvent::encodedData ( %s )", format );
#endif
QByteArray ba;
/* Currently we only support TYMED_HGLOBAL ... */
FORMATETC fmtMemory = { 0,
NULL,
DVASPECT_CONTENT,
-1,
TYMED_HGLOBAL };
STGMEDIUM stm;
if ( !pIDataObject ) {
return ba;
}
QPtrList<QWindowsMime> all = QWindowsMime::all();
for ( QWindowsMime * c = all.first(); c ; c = all.next() ) {
int cf = c->cfFor( format );
if ( c->canConvert( format, cf ) ) {
fmtMemory.cfFormat = cf;
if ( pIDataObject->QueryGetData( &fmtMemory ) == S_OK ) {
HRESULT hr = pIDataObject->GetData( &fmtMemory, &stm );
if ( ( hr != S_OK ) || ( !stm.hGlobal ) )
continue;
QByteArray data;
QBuffer buf ( data );
buf.open( IO_WriteOnly );
buf.writeBlock ( ( char* ) GlobalLock( stm.hGlobal ), GlobalSize ( stm.hGlobal ) );
buf.close();
GlobalUnlock ( stm.hGlobal );
ReleaseStgMedium( &stm );
ba = c->convertToMime( data, format, cf );
ReleaseStgMedium( &stm );
return ba;
}
}
}
return ba;
}
static HRESULT
InvokeRemoteRegistryPickerDialog(IN IDsObjectPicker *pDsObjectPicker,
IN HWND hwndParent OPTIONAL,
OUT LPWSTR lpBuffer,
IN UINT uSize)
{
IDataObject *pdo = NULL;
HRESULT hRet;
hRet = pDsObjectPicker->lpVtbl->InvokeDialog(pDsObjectPicker,
hwndParent,
&pdo);
if (hRet == S_OK)
{
STGMEDIUM stm;
FORMATETC fe;
fe.cfFormat = (CLIPFORMAT) RegisterClipboardFormatW(CFSTR_DSOP_DS_SELECTION_LIST);
fe.ptd = NULL;
fe.dwAspect = DVASPECT_CONTENT;
fe.lindex = -1;
fe.tymed = TYMED_HGLOBAL;
hRet = pdo->lpVtbl->GetData(pdo,
&fe,
&stm);
if (SUCCEEDED(hRet))
{
PDS_SELECTION_LIST SelectionList = (PDS_SELECTION_LIST)GlobalLock(stm.hGlobal);
if (SelectionList != NULL)
{
if (SelectionList->cItems == 1)
{
size_t nlen = wcslen(SelectionList->aDsSelection[0].pwzName);
if (nlen >= uSize)
{
nlen = uSize - 1;
}
memcpy(lpBuffer,
SelectionList->aDsSelection[0].pwzName,
nlen * sizeof(WCHAR));
lpBuffer[nlen] = L'\0';
}
GlobalUnlock(stm.hGlobal);
}
ReleaseStgMedium(&stm);
}
pdo->lpVtbl->Release(pdo);
}
return hRet;
}
/**
* @brief Begin a DnD operation.
*
* @param data The name pf the Drag operation.
* @param size The size of the name.
* @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
*
* This function start a Drag operation with the name @p data. If
* @p data is @c NULL, @c EINA_FALSE is returned. if @p size is less than
* @c 0, it is set to the length (as strlen()) of @p data. On success the
* function returns @c EINA_TRUE, otherwise it returns @c EINA_FALSE.
*/
EAPI Eina_Bool
ecore_win32_dnd_begin(const char *data,
int size)
{
IDataObject *pDataObject = NULL;
IDropSource *pDropSource = NULL;
FORMATETC fmtetc = { CF_TEXT, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
STGMEDIUM stgmed = { TYMED_HGLOBAL, { 0 }, 0 };
Eina_Bool res = EINA_FALSE;
if (!data)
return EINA_FALSE;
if (size < 0)
size = strlen(data) + 1;
stgmed.hGlobal = DataToHandle(data, size);
// create the data object
pDataObject = (IDataObject *)_ecore_win32_dnd_data_object_new((void *)&fmtetc,
(void *)&stgmed,
1);
pDropSource = (IDropSource *)_ecore_win32_dnd_drop_source_new();
if (pDataObject && pDropSource)
{
DWORD dwResult;
DWORD dwEffect = DROPEFFECT_COPY;
// do the drag-drop!
dwResult = DoDragDrop(pDataObject, pDropSource, DROPEFFECT_COPY, &dwEffect);
// finished. Check the return values to see if we need to do anything else
if (dwResult == DRAGDROP_S_DROP)
{
//printf(">>> \"%s\" Dropped <<<\n", str);
if(dwEffect == DROPEFFECT_MOVE)
{
// remove the data we just dropped from active document
}
}
//else if (dwResult == DRAGDROP_S_CANCEL)
// printf("DND cancelled\n");
//else
// printf("DND error\n");
res = EINA_TRUE;
}
_ecore_win32_dnd_data_object_free(pDataObject);
_ecore_win32_dnd_drop_source_free(pDropSource);
// cleanup
ReleaseStgMedium(&stgmed);
return res;
}
STDMETHODIMP ExifShellExtension::Initialize(
LPCITEMIDLIST /*pidlFolder*/, LPDATAOBJECT pDataObj, HKEY /*hProgID*/)
{
FORMATETC fmt = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
STGMEDIUM stg = { TYMED_HGLOBAL };
// Look for CF_HDROP data in the data object.
if (FAILED(pDataObj->GetData(&fmt, &stg)))
{
// Nope! Return an "invalid argument" error back to Explorer.
return E_INVALIDARG;
}
// Get a pointer to the actual data.
HDROP hDrop = (HDROP) GlobalLock(stg.hGlobal);
// Make sure it worked.
if (NULL == hDrop)
return E_INVALIDARG;
// Sanity check - make sure there is at least one filename.
UINT uNumFiles = DragQueryFile(hDrop, 0xFFFFFFFF, NULL, 0);
HRESULT hr = S_OK;
if (1 != uNumFiles)
{
GlobalUnlock(stg.hGlobal);
ReleaseStgMedium(&stg);
return E_INVALIDARG;
}
// Get the name of the file and store it
TCHAR szFile[MAX_PATH];
UINT u = 0;
if (0 == DragQueryFile(hDrop, u, szFile, MAX_PATH))
hr = E_INVALIDARG;
else
m_cszFilename = szFile;
GlobalUnlock(stg.hGlobal);
ReleaseStgMedium(&stg);
return hr;
}
bool ng_playlist_view_t::do_drag_drop(WPARAM wp)
{
metadb_handle_list_t<pfc::alloc_fast_aggressive> data;
m_playlist_api->activeplaylist_get_selected_items(data);
if (data.get_count() > 0)
{
static_api_ptr_t<playlist_incoming_item_filter> incoming_api;
IDataObject * pDataObject = incoming_api->create_dataobject(data);
if (pDataObject)
{
//IDataObject * pDataObjectFixed = new CDataObject;
#if 0
mmh::comptr_t<IEnumFORMATETC> pEnumFORMATETC;
pDataObject->EnumFormatEtc(DATADIR_GET, pEnumFORMATETC.get_pp());
FORMATETC fe;
memset(&fe,0,sizeof(fe));
while (S_OK == pEnumFORMATETC->Next(1, &fe, NULL))
{
STGMEDIUM stgm;
memset(&stgm, 0, sizeof(0));
if (SUCCEEDED(pDataObject->GetData(&fe, &stgm)))
{
//if (stgm.tymed != TYMED_ISTREAM)
// pDataObjectFixed->SetData(&fe, &stgm, FALSE);
ReleaseStgMedium(&stgm);
}
memset(&fe,0,sizeof(fe));
}
pEnumFORMATETC.release();
#endif
//pfc::com_ptr_t<IAsyncOperation> pAsyncOperation;
//HRESULT hr = pDataObject->QueryInterface(IID_IAsyncOperation, (void**)pAsyncOperation.receive_ptr());
DWORD blah = DROPEFFECT_NONE;
{
m_dragging = true;
m_DataObject = pDataObject;
m_dragging_initial_playlist = m_playlist_api->get_active_playlist();
pfc::com_ptr_t<mmh::ole::IDropSource_Generic> p_IDropSource_playlist = new mmh::ole::IDropSource_Generic(get_wnd(), pDataObject, wp);
HRESULT hr = DoDragDrop(pDataObject,p_IDropSource_playlist.get_ptr(),DROPEFFECT_COPY|DROPEFFECT_MOVE,&blah);
//SHDoDragDrop(get_wnd(), pDataObject,NULL,DROPEFFECT_COPY|DROPEFFECT_MOVE,&blah);
m_dragging=false;
m_DataObject.release();
m_dragging_initial_playlist = pfc_infinite;
/*if (DRAGDROP_S_DROP == hr && blah == DROPEFFECT_MOVE)
m_playlist_api->playlist_remove_selection(playlist);*/
}
//pDataObjectFixed->Release();
pDataObject->Release();
}
}
return true;
}
CIDataObject::~CIDataObject()
{
for(int i = 0; i < m_StgMedium.GetSize(); ++i)
{
ReleaseStgMedium(m_StgMedium[i]);
delete m_StgMedium[i];
}
for(int j = 0; j < m_ArrFormatEtc.GetSize(); ++j)
delete m_ArrFormatEtc[j];
}
void CShowActiveDirUsers::Init(HWND hWnd, CADObjectPicker* pObjPicker)
{
if (m_stg.hGlobal)
{
ReleaseStgMedium(&m_stg);
}
m_stg.hGlobal = NULL;
m_hWnd = hWnd;
m_pObjPicker = pObjPicker;
}
nsresult Do_CheckOneFile()
{
nsresult rv;
nsCOMPtr<nsITransferable> transferable;
nsCOMPtr<nsISupportsArray> transferableArray;
nsCOMPtr<nsISupports> genericWrapper;
nsRefPtr<IDataObject> dataObj;
rv = NS_NewISupportsArray(getter_AddRefs(transferableArray));
if (NS_FAILED(rv)) {
fail("Could not create the necessary nsISupportsArray");
return rv;
}
rv = GetTransferableFile(transferable);
if (NS_FAILED(rv)) {
fail("Could not create the proper nsITransferable!");
return rv;
}
genericWrapper = do_QueryInterface(transferable);
rv = transferableArray->AppendElement(genericWrapper);
if (NS_FAILED(rv)) {
fail("Could not append element to transferable array");
return rv;
}
rv = MakeDataObject(transferableArray, dataObj);
if (NS_FAILED(rv)) {
fail("Could not create data object");
return rv;
}
FORMATETC fe;
SET_FORMATETC(fe, CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL);
if (dataObj->QueryGetData(&fe) != S_OK) {
fail("File data object does not support the file data type!");
return NS_ERROR_UNEXPECTED;
}
STGMEDIUM* stg;
stg = (STGMEDIUM*)CoTaskMemAlloc(sizeof(STGMEDIUM));
if (dataObj->GetData(&fe, stg) != S_OK) {
fail("File data object did not provide data on request");
return NS_ERROR_UNEXPECTED;
}
rv = CheckValidHDROP(stg);
if (NS_FAILED(rv)) {
fail("HDROP was invalid");
return rv;
}
ReleaseStgMedium(stg);
return NS_OK;
}
HRESULT SH_GetApidlFromDataObject(IDataObject *pDataObject, PIDLIST_ABSOLUTE* ppidlfolder, PUITEMID_CHILD **apidlItems, UINT *pcidl)
{
UINT cfShellIDList = RegisterClipboardFormatW(CFSTR_SHELLIDLIST);
if (!cfShellIDList)
return E_FAIL;
FORMATETC fmt;
InitFormatEtc (fmt, cfShellIDList, TYMED_HGLOBAL);
HRESULT hr = pDataObject->QueryGetData(&fmt);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
STGMEDIUM medium;
hr = pDataObject->GetData(&fmt, &medium);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
/* lock the handle */
LPIDA lpcida = (LPIDA)GlobalLock(medium.hGlobal);
if (!lpcida)
{
ReleaseStgMedium(&medium);
return E_FAIL;
}
/* convert the data into pidl */
LPITEMIDLIST pidl;
LPITEMIDLIST *apidl = _ILCopyCidaToaPidl(&pidl, lpcida);
if (!apidl)
{
ReleaseStgMedium(&medium);
return E_OUTOFMEMORY;
}
*ppidlfolder = pidl;
*apidlItems = apidl;
*pcidl = lpcida->cidl;
ReleaseStgMedium(&medium);
return S_OK;
}
std::vector<ComPtr<IShellItem>> get_shell_items(IDataObject* object) {
auto format = FORMATETC{CF_HDROP, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
STGMEDIUM stgm;
if (FAILED(object->GetData(&format, &stgm)))
return {};
auto hdrop = reinterpret_cast<HDROP>(stgm.hGlobal);
auto n_paths = DragQueryFile(hdrop, 0xffffffff, nullptr, 0);
std::vector<ComPtr<IShellItem>> items;
for (UINT i = 0; i < n_paths; i++) {
auto buffer_size = er = DragQueryFile(hdrop, i, nullptr, 0);
std::vector<wchar_t> buffer(buffer_size + 1);
buffer[buffer_size] = L'\0';
er = DragQueryFile(hdrop, i, buffer.data(), numeric_cast<UINT>(buffer.size()));
ComPtr<IShellItem> si;
er = SHCreateItemFromParsingName(
buffer.data(), nullptr, IID_IShellItem, reinterpret_cast<void**>(&si));
items.push_back(si);
}
ReleaseStgMedium(&stgm);
return items;
}
