VBoxDnDDataObject.cpp@ 95960

Last change on this file since 95960 was 95960, checked in by vboxsync, 3 years ago
Additions/VBoxTray: More logging cleanups: don't define default stuff which is already defined by default; include files reordering (IPRT/ first, VBox/ second).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.0 KB

Line
1	/* $Id: VBoxDnDDataObject.cpp 95960 2022-08-01 13:54:40Z vboxsync $ */
2	/** @file
3	* VBoxDnDDataObject.cpp - IDataObject implementation.
4	*/
5
6	/*
7	* Copyright (C) 2013-2022 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	#define LOG_GROUP LOG_GROUP_GUEST_DND
20	#include <VBox/log.h>
21
22	#include <iprt/win/windows.h>
23	#include <new> /* For bad_alloc. */
24	#include <iprt/win/shlobj.h>
25
26	#include <iprt/path.h>
27	#include <iprt/semaphore.h>
28	#include <iprt/uri.h>
29	#include <iprt/utf16.h>
30
31	#include "VBoxTray.h"
32	#include "VBoxHelpers.h"
33	#include "VBoxDnD.h"
34
35
36	/** @todo Implement IDataObjectAsyncCapability interface? */
37
38	VBoxDnDDataObject::VBoxDnDDataObject(LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats)
39	: m_enmStatus(Status_Uninitialized)
40	, m_cRefs(1)
41	, m_cFormats(0)
42	, m_paFormatEtc(0)
43	, m_paStgMedium(0)
44	, m_EvtDropped(NIL_RTSEMEVENT)
45	, m_pvData(NULL)
46	, m_cbData(0)
47	{
48	int rc2 = Init(pFormatEtc, pStgMed, cFormats);
49	AssertRC(rc2);
50	}
51
52	VBoxDnDDataObject::~VBoxDnDDataObject(void)
53	{
54	int rc2 = Destroy();
55	AssertRC(rc2);
56	}
57
58	/*
59	* IUnknown methods.
60	*/
61
62	STDMETHODIMP_(ULONG) VBoxDnDDataObject::AddRef(void)
63	{
64	AssertReturn(m_cRefs < 32, m_cRefs); /* Paranoia. */
65	return InterlockedIncrement(&m_cRefs);
66	}
67
68	STDMETHODIMP_(ULONG) VBoxDnDDataObject::Release(void)
69	{
70	AssertReturn(m_cRefs > 0, 0);
71	LONG lCount = InterlockedDecrement(&m_cRefs);
72	if (lCount == 0)
73	{
74	delete this;
75	return 0;
76	}
77
78	return lCount;
79	}
80
81	STDMETHODIMP VBoxDnDDataObject::QueryInterface(REFIID iid, void **ppvObject)
82	{
83	AssertPtrReturn(ppvObject, E_INVALIDARG);
84
85	if ( iid == IID_IDataObject
86	\|\| iid == IID_IUnknown)
87	{
88	AddRef();
89	*ppvObject = this;
90	return S_OK;
91	}
92
93	*ppvObject = 0;
94	return E_NOINTERFACE;
95	}
96
97	STDMETHODIMP VBoxDnDDataObject::GetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium)
98	{
99	AssertPtrReturn(pFormatEtc, DV_E_FORMATETC);
100	AssertPtrReturn(pMedium, DV_E_FORMATETC);
101
102	ULONG lIndex;
103	if (!LookupFormatEtc(pFormatEtc, &lIndex)) /* Format supported? */
104	return DV_E_FORMATETC;
105	if (lIndex >= m_cFormats) /* Paranoia. */
106	return DV_E_FORMATETC;
107
108	LPFORMATETC pThisFormat = &m_paFormatEtc[lIndex];
109	AssertPtr(pThisFormat);
110
111	LPSTGMEDIUM pThisMedium = &m_paStgMedium[lIndex];
112	AssertPtr(pThisMedium);
113
114	LogFlowFunc(("Using pThisFormat=%p, pThisMedium=%p\n", pThisFormat, pThisMedium));
115
116	HRESULT hr = DV_E_FORMATETC; /* Play safe. */
117
118	LogFlowFunc(("mStatus=%ld\n", m_enmStatus));
119	if (m_enmStatus == Status_Dropping)
120	{
121	LogRel2(("DnD: Waiting for drop event ...\n"));
122	int rc2 = RTSemEventWait(m_EvtDropped, RT_INDEFINITE_WAIT);
123	LogFlowFunc(("rc2=%Rrc, mStatus=%ld\n", rc2, m_enmStatus)); RT_NOREF(rc2);
124	}
125
126	if (m_enmStatus == Status_Dropped)
127	{
128	LogRel2(("DnD: Drop event received\n"));
129	LogRel3(("DnD: cfFormat=%RI16, sFormat=%s, tyMed=%RU32, dwAspect=%RU32\n",
130	pThisFormat->cfFormat, VBoxDnDDataObject::ClipboardFormatToString(pFormatEtc->cfFormat),
131	pThisFormat->tymed, pThisFormat->dwAspect));
132	LogRel3(("DnD: Got strFormat=%s, pvData=%p, cbData=%RU32\n",
133	m_strFormat.c_str(), m_pvData, m_cbData));
134
135	/*
136	* Initialize default values.
137	*/
138	pMedium->tymed = pThisFormat->tymed;
139	pMedium->pUnkForRelease = NULL;
140
141	/*
142	* URI list handling.
143	*/
144	if (DnDMIMEHasFileURLs(m_strFormat.c_str(), RTSTR_MAX))
145	{
146	char **papszFiles;
147	size_t cFiles;
148	int rc = RTStrSplit((const char *)m_pvData, m_cbData, DND_PATH_SEPARATOR_STR, &papszFiles, &cFiles);
149	if ( RT_SUCCESS(rc)
150	&& cFiles)
151	{
152	LogRel2(("DnD: Files (%zu)\n", cFiles));
153	for (size_t i = 0; i < cFiles; i++)
154	LogRel2(("\tDnD: File '%s'\n", papszFiles[i]));
155
156	#if 0
157	if ( (pFormatEtc->tymed & TYMED_ISTREAM)
158	&& (pFormatEtc->dwAspect == DVASPECT_CONTENT)
159	&& (pFormatEtc->cfFormat == CF_FILECONTENTS))
160	{
161
162	}
163	else if ( (pFormatEtc->tymed & TYMED_HGLOBAL)
164	&& (pFormatEtc->dwAspect == DVASPECT_CONTENT)
165	&& (pFormatEtc->cfFormat == CF_FILEDESCRIPTOR))
166	{
167
168	}
169	else if ( (pFormatEtc->tymed & TYMED_HGLOBAL)
170	&& (pFormatEtc->cfFormat == CF_PREFERREDDROPEFFECT))
171	{
172	HGLOBAL hData = GlobalAlloc(GMEM_MOVEABLE \| GMEM_SHARE \| GMEM_ZEROINIT, sizeof(DWORD));
173	DWORD pdwEffect = (DWORD )GlobalLock(hData);
174	AssertPtr(pdwEffect);
175	*pdwEffect = DROPEFFECT_COPY;
176	GlobalUnlock(hData);
177
178	pMedium->hGlobal = hData;
179	pMedium->tymed = TYMED_HGLOBAL;
180	}
181	else
182	#endif
183	if ( (pFormatEtc->tymed & TYMED_HGLOBAL)
184	&& (pFormatEtc->dwAspect == DVASPECT_CONTENT)
185	&& (pFormatEtc->cfFormat == CF_TEXT))
186	{
187	pMedium->hGlobal = GlobalAlloc(GHND, m_cbData + 1);
188	if (pMedium->hGlobal)
189	{
190	char pcDst = (char )GlobalLock(pMedium->hGlobal);
191	memcpy(pcDst, m_pvData, m_cbData);
192	pcDst[m_cbData] = '\0';
193	GlobalUnlock(pMedium->hGlobal);
194
195	hr = S_OK;
196	}
197	}
198	else if ( (pFormatEtc->tymed & TYMED_HGLOBAL)
199	&& (pFormatEtc->dwAspect == DVASPECT_CONTENT)
200	&& (pFormatEtc->cfFormat == CF_HDROP))
201	{
202	size_t cchFiles = 0; /* Number of ASCII characters. */
203	for (size_t i = 0; i < cFiles; i++)
204	{
205	cchFiles += strlen(papszFiles[i]);
206	cchFiles += 1; /* Terminating '\0'. */
207	}
208
209	size_t cbBuf = sizeof(DROPFILES) + ((cchFiles + 1) * sizeof(RTUTF16));
210	DROPFILES pBuf = (DROPFILES )RTMemAllocZ(cbBuf);
211	if (pBuf)
212	{
213	pBuf->pFiles = sizeof(DROPFILES);
214	pBuf->fWide = 1; /* We use unicode. Always. */
215
216	uint8_t pCurFile = (uint8_t )pBuf + pBuf->pFiles;
217	AssertPtr(pCurFile);
218
219	for (size_t i = 0; i < cFiles && RT_SUCCESS(rc); i++)
220	{
221	size_t cchCurFile;
222	PRTUTF16 pwszFile;
223	rc = RTStrToUtf16(papszFiles[i], &pwszFile);
224	if (RT_SUCCESS(rc))
225	{
226	cchCurFile = RTUtf16Len(pwszFile);
227	Assert(cchCurFile);
228	memcpy(pCurFile, pwszFile, cchCurFile * sizeof(RTUTF16));
229	RTUtf16Free(pwszFile);
230	}
231	else
232	break;
233
234	pCurFile += cchCurFile * sizeof(RTUTF16);
235
236	/* Terminate current file name. */
237	*pCurFile = L'\0';
238	pCurFile += sizeof(RTUTF16);
239	}
240
241	if (RT_SUCCESS(rc))
242	{
243	pCurFile = L'\0'; / Final list terminator. */
244
245	pMedium->tymed = TYMED_HGLOBAL;
246	pMedium->pUnkForRelease = NULL;
247	pMedium->hGlobal = GlobalAlloc( GMEM_ZEROINIT
248	\| GMEM_MOVEABLE
249	\| GMEM_DDESHARE, cbBuf);
250	if (pMedium->hGlobal)
251	{
252	LPVOID pMem = GlobalLock(pMedium->hGlobal);
253	if (pMem)
254	{
255	memcpy(pMem, pBuf, cbBuf);
256	GlobalUnlock(pMedium->hGlobal);
257
258	hr = S_OK;
259	}
260	}
261	}
262
263	RTMemFree(pBuf);
264	}
265	else
266	rc = VERR_NO_MEMORY;
267	}
268
269	for (size_t i = 0; i < cFiles; ++i)
270	RTStrFree(papszFiles[i]);
271	RTMemFree(papszFiles);
272	}
273
274	if (RT_FAILURE(rc))
275	hr = DV_E_FORMATETC;
276	}
277	/*
278	* Plain text handling.
279	*/
280	else if ( m_strFormat.equalsIgnoreCase("text/plain")
281	\|\| m_strFormat.equalsIgnoreCase("text/html")
282	\|\| m_strFormat.equalsIgnoreCase("text/plain;charset=utf-8")
283	\|\| m_strFormat.equalsIgnoreCase("text/plain;charset=utf-16")
284	\|\| m_strFormat.equalsIgnoreCase("text/richtext")
285	\|\| m_strFormat.equalsIgnoreCase("UTF8_STRING")
286	\|\| m_strFormat.equalsIgnoreCase("TEXT")
287	\|\| m_strFormat.equalsIgnoreCase("STRING"))
288	{
289	pMedium->hGlobal = GlobalAlloc(GHND, m_cbData + 1);
290	if (pMedium->hGlobal)
291	{
292	char pcDst = (char )GlobalLock(pMedium->hGlobal);
293	memcpy(pcDst, m_pvData, m_cbData);
294	pcDst[m_cbData] = '\0';
295	GlobalUnlock(pMedium->hGlobal);
296
297	hr = S_OK;
298	}
299	}
300	else
301	LogRel(("DnD: Error: Format '%s' not implemented\n", m_strFormat.c_str()));
302	}
303
304	/* Error handling; at least return some basic data. */
305	if (FAILED(hr))
306	{
307	LogFlowFunc(("Copying medium ...\n"));
308	switch (pThisMedium->tymed)
309	{
310
311	case TYMED_HGLOBAL:
312	pMedium->hGlobal = (HGLOBAL)OleDuplicateData(pThisMedium->hGlobal,
313	pThisFormat->cfFormat, NULL);
314	break;
315
316	default:
317	break;
318	}
319
320	pMedium->tymed = pThisFormat->tymed;
321	pMedium->pUnkForRelease = NULL;
322	}
323
324	if (hr == DV_E_FORMATETC)
325	LogRel(("DnD: Error handling format '%s' (%RU32 bytes)\n", m_strFormat.c_str(), m_cbData));
326
327	LogFlowFunc(("hr=%Rhrc\n", hr));
328	return hr;
329	}
330
331	STDMETHODIMP VBoxDnDDataObject::GetDataHere(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium)
332	{
333	RT_NOREF(pFormatEtc, pMedium);
334	LogFlowFunc(("\n"));
335	return DATA_E_FORMATETC;
336	}
337
338	STDMETHODIMP VBoxDnDDataObject::QueryGetData(LPFORMATETC pFormatEtc)
339	{
340	LogFlowFunc(("\n"));
341	return (LookupFormatEtc(pFormatEtc, NULL /* puIndex */)) ? S_OK : DV_E_FORMATETC;
342	}
343
344	STDMETHODIMP VBoxDnDDataObject::GetCanonicalFormatEtc(LPFORMATETC pFormatEtc, LPFORMATETC pFormatEtcOut)
345	{
346	RT_NOREF(pFormatEtc);
347	LogFlowFunc(("\n"));
348
349	/* Set this to NULL in any case. */
350	pFormatEtcOut->ptd = NULL;
351	return E_NOTIMPL;
352	}
353
354	STDMETHODIMP VBoxDnDDataObject::SetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium, BOOL fRelease)
355	{
356	RT_NOREF(pFormatEtc, pMedium, fRelease);
357	return E_NOTIMPL;
358	}
359
360	STDMETHODIMP VBoxDnDDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc)
361	{
362	LogFlowFunc(("dwDirection=%RI32, mcFormats=%RI32, mpFormatEtc=%p\n", dwDirection, m_cFormats, m_paFormatEtc));
363
364	HRESULT hr;
365	if (dwDirection == DATADIR_GET)
366	hr = VBoxDnDEnumFormatEtc::CreateEnumFormatEtc(m_cFormats, m_paFormatEtc, ppEnumFormatEtc);
367	else
368	hr = E_NOTIMPL;
369
370	LogFlowFunc(("hr=%Rhrc\n", hr));
371	return hr;
372	}
373
374	STDMETHODIMP VBoxDnDDataObject::DAdvise(LPFORMATETC pFormatEtc, DWORD fAdvise, IAdviseSink pAdvSink, DWORD pdwConnection)
375	{
376	RT_NOREF(pFormatEtc, fAdvise, pAdvSink, pdwConnection);
377	return OLE_E_ADVISENOTSUPPORTED;
378	}
379
380	STDMETHODIMP VBoxDnDDataObject::DUnadvise(DWORD dwConnection)
381	{
382	RT_NOREF(dwConnection);
383	return OLE_E_ADVISENOTSUPPORTED;
384	}
385
386	STDMETHODIMP VBoxDnDDataObject::EnumDAdvise(IEnumSTATDATA **ppEnumAdvise)
387	{
388	RT_NOREF(ppEnumAdvise);
389	return OLE_E_ADVISENOTSUPPORTED;
390	}
391
392	/*
393	* Own stuff.
394	*/
395
396	int VBoxDnDDataObject::Init(LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats)
397	{
398	AssertReturn(m_enmStatus == Status_Uninitialized, VERR_WRONG_ORDER);
399
400	int rc = RTSemEventCreate(&m_EvtDropped);
401	AssertRCReturn(rc, rc);
402
403	/*
404	* Allocate arrays for format related stuff.
405	*/
406	ULONG cFixedFormats = 1;
407	ULONG cAllFormats = cFormats + cFixedFormats;
408	m_paFormatEtc = (LPFORMATETC)RTMemAllocZ(sizeof(m_paFormatEtc[0]) * cAllFormats);
409	if (m_paFormatEtc)
410	{
411	m_paStgMedium = (LPSTGMEDIUM)RTMemAllocZ(sizeof(m_paStgMedium[0]) * cAllFormats);
412	if (m_EvtDropped)
413	{
414	/*
415	* Registration of dynamic formats needed?
416	*/
417	LogFlowFunc(("%RU32 dynamic formats\n", cFormats));
418	if (cFormats)
419	{
420	AssertPtr(pFormatEtc);
421	AssertPtr(pStgMed);
422
423	for (ULONG i = 0; i < cFormats; i++)
424	{
425	LogFlowFunc(("Format %RU32: cfFormat=%RI16, tyMed=%RU32, dwAspect=%RU32\n",
426	i, pFormatEtc[i].cfFormat, pFormatEtc[i].tymed, pFormatEtc[i].dwAspect));
427	m_paFormatEtc[i] = pFormatEtc[i];
428	m_paStgMedium[i] = pStgMed[i];
429	}
430	}
431
432	/*
433	* Register fixed formats.
434	*/
435	#if 0
436	/* CF_HDROP. */
437	RegisterFormat(&mpFormatEtc[cFormats], CF_HDROP);
438	mpStgMedium[cFormats++].tymed = TYMED_HGLOBAL;
439
440	/* IStream. */
441	RegisterFormat(&mpFormatEtc[cFormats++],
442	RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR));
443	RegisterFormat(&mpFormatEtc[cFormats++],
444	RegisterClipboardFormat(CFSTR_FILECONTENTS),
445	TYMED_ISTREAM, 0 /* lIndex */);
446
447	/* Required for e.g. Windows Media Player. */
448	RegisterFormat(&mpFormatEtc[cFormats++],
449	RegisterClipboardFormat(CFSTR_FILENAME));
450	RegisterFormat(&mpFormatEtc[cFormats++],
451	RegisterClipboardFormat(CFSTR_FILENAMEW));
452	RegisterFormat(&mpFormatEtc[cFormats++],
453	RegisterClipboardFormat(CFSTR_SHELLIDLIST));
454	RegisterFormat(&mpFormatEtc[cFormats++],
455	RegisterClipboardFormat(CFSTR_SHELLIDLISTOFFSET));
456	#endif
457	m_cFormats = cFormats;
458	m_enmStatus = Status_Initialized;
459	}
460	else
461	rc = VERR_NO_MEMORY;
462	}
463	else
464	rc = VERR_NO_MEMORY;
465
466	LogFlowFunc(("cFormats=%RU32 - %Rrc\n", cFormats, rc));
467	return rc;
468	}
469
470	int VBoxDnDDataObject::Destroy(void)
471	{
472	if (m_enmStatus == Status_Uninitialized)
473	return VINF_SUCCESS;
474
475	AssertReturn(m_cRefs == 0, VERR_WRONG_ORDER);
476
477	if (m_paFormatEtc)
478	{
479	RTMemFree(m_paFormatEtc);
480	m_paFormatEtc = NULL;
481	}
482
483	if (m_paStgMedium)
484	{
485	RTMemFree(m_paStgMedium);
486	m_paStgMedium = NULL;
487	}
488
489	if (m_pvData)
490	{
491	RTMemFree(m_pvData);
492	m_pvData = NULL;
493	}
494
495	int rc = RTSemEventDestroy(m_EvtDropped);
496	AssertRCReturn(rc, rc);
497	m_EvtDropped = NIL_RTSEMEVENT;
498
499	m_enmStatus = Status_Uninitialized;
500
501	return VINF_SUCCESS;
502	}
503
504	/**
505	* Aborts waiting for data being "dropped".
506	*
507	* @returns VBox status code.
508	*/
509	int VBoxDnDDataObject::Abort(void)
510	{
511	LogFlowFunc(("Aborting ...\n"));
512	if (m_enmStatus == Status_Dropping)
513	{
514	m_enmStatus = Status_Aborted;
515	return RTSemEventSignal(m_EvtDropped);
516	}
517
518	return VINF_SUCCESS;
519	}
520
521	/**
522	* Static helper function to convert a CLIPFORMAT to a string and return it.
523	*
524	* @returns Pointer to converted stringified CLIPFORMAT, or "unknown" if not found / invalid.
525	* @param fmt CLIPFORMAT to return string for.
526	*/
527	/* static */
528	const char* VBoxDnDDataObject::ClipboardFormatToString(CLIPFORMAT fmt)
529	{
530	#if 0
531	char szFormat[128];
532	if (GetClipboardFormatName(fmt, szFormat, sizeof(szFormat)))
533	LogFlowFunc(("wFormat=%RI16, szName=%s\n", fmt, szFormat));
534	#endif
535
536	switch (fmt)
537	{
538
539	case 1:
540	return "CF_TEXT";
541	case 2:
542	return "CF_BITMAP";
543	case 3:
544	return "CF_METAFILEPICT";
545	case 4:
546	return "CF_SYLK";
547	case 5:
548	return "CF_DIF";
549	case 6:
550	return "CF_TIFF";
551	case 7:
552	return "CF_OEMTEXT";
553	case 8:
554	return "CF_DIB";
555	case 9:
556	return "CF_PALETTE";
557	case 10:
558	return "CF_PENDATA";
559	case 11:
560	return "CF_RIFF";
561	case 12:
562	return "CF_WAVE";
563	case 13:
564	return "CF_UNICODETEXT";
565	case 14:
566	return "CF_ENHMETAFILE";
567	case 15:
568	return "CF_HDROP";
569	case 16:
570	return "CF_LOCALE";
571	case 17:
572	return "CF_DIBV5";
573	case 18:
574	return "CF_MAX";
575	case 49158:
576	return "FileName";
577	case 49159:
578	return "FileNameW";
579	case 49161:
580	return "DATAOBJECT";
581	case 49171:
582	return "Ole Private Data";
583	case 49314:
584	return "Shell Object Offsets";
585	case 49316:
586	return "File Contents";
587	case 49317:
588	return "File Group Descriptor";
589	case 49323:
590	return "Preferred Drop Effect";
591	case 49380:
592	return "Shell Object Offsets";
593	case 49382:
594	return "FileContents";
595	case 49383:
596	return "FileGroupDescriptor";
597	case 49389:
598	return "Preferred DropEffect";
599	case 49268:
600	return "Shell IDList Array";
601	case 49619:
602	return "RenPrivateFileAttachments";
603	default:
604	break;
605	}
606
607	return "unknown";
608	}
609
610	/**
611	* Checks whether a given FORMATETC is supported by this data object and returns its index.
612	*
613	* @returns \c true if format is supported, \c false if not.
614	* @param pFormatEtc Pointer to FORMATETC to check for.
615	* @param puIndex Where to store the index if format is supported.
616	*/
617	bool VBoxDnDDataObject::LookupFormatEtc(LPFORMATETC pFormatEtc, ULONG *puIndex)
618	{
619	AssertReturn(pFormatEtc, false);
620	/* puIndex is optional. */
621
622	for (ULONG i = 0; i < m_cFormats; i++)
623	{
624	if( (pFormatEtc->tymed & m_paFormatEtc[i].tymed)
625	&& pFormatEtc->cfFormat == m_paFormatEtc[i].cfFormat
626	&& pFormatEtc->dwAspect == m_paFormatEtc[i].dwAspect)
627	{
628	LogRel3(("DnD: Format found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32, ulIndex=%RU32\n",
629	pFormatEtc->tymed, pFormatEtc->cfFormat, VBoxDnDDataObject::ClipboardFormatToString(m_paFormatEtc[i].cfFormat),
630	pFormatEtc->dwAspect, i));
631	if (puIndex)
632	*puIndex = i;
633	return true;
634	}
635	}
636
637	LogRel3(("DnD: Format NOT found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32\n",
638	pFormatEtc->tymed, pFormatEtc->cfFormat, VBoxDnDDataObject::ClipboardFormatToString(pFormatEtc->cfFormat),
639	pFormatEtc->dwAspect));
640
641	return false;
642	}
643
644	/**
645	* Registers a new format with this data object.
646	*
647	* @param pFormatEtc Where to store the new format into.
648	* @param clipFormat Clipboard format to register.
649	* @param tyMed Format medium type to register.
650	* @param lIndex Format index to register.
651	* @param dwAspect Format aspect to register.
652	* @param pTargetDevice Format target device to register.
653	*/
654	void VBoxDnDDataObject::RegisterFormat(LPFORMATETC pFormatEtc, CLIPFORMAT clipFormat,
655	TYMED tyMed, LONG lIndex, DWORD dwAspect,
656	DVTARGETDEVICE *pTargetDevice)
657	{
658	AssertPtr(pFormatEtc);
659
660	pFormatEtc->cfFormat = clipFormat;
661	pFormatEtc->tymed = tyMed;
662	pFormatEtc->lindex = lIndex;
663	pFormatEtc->dwAspect = dwAspect;
664	pFormatEtc->ptd = pTargetDevice;
665
666	LogFlowFunc(("Registered format=%ld, sFormat=%s\n",
667	pFormatEtc->cfFormat, VBoxDnDDataObject::ClipboardFormatToString(pFormatEtc->cfFormat)));
668	}
669
670	/**
671	* Sets the current status of this data object.
672	*
673	* @param status New status to set.
674	*/
675	void VBoxDnDDataObject::SetStatus(Status status)
676	{
677	LogFlowFunc(("Setting status to %ld\n", status));
678	m_enmStatus = status;
679	}
680
681	/**
682	* Signals that data has been "dropped".
683	*
684	* @returns VBox status code.
685	* @param strFormat Format of data (MIME string).
686	* @param pvData Pointer to data.
687	* @param cbData Size (in bytes) of data.
688	*/
689	int VBoxDnDDataObject::Signal(const RTCString &strFormat,
690	const void *pvData, size_t cbData)
691	{
692	int rc;
693
694	if (cbData)
695	{
696	m_pvData = RTMemAlloc(cbData);
697	if (m_pvData)
698	{
699	memcpy(m_pvData, pvData, cbData);
700	m_cbData = cbData;
701	rc = VINF_SUCCESS;
702	}
703	else
704	rc = VERR_NO_MEMORY;
705	}
706	else
707	rc = VINF_SUCCESS;
708
709	if (RT_SUCCESS(rc))
710	{
711	m_enmStatus = Status_Dropped;
712	m_strFormat = strFormat;
713	}
714	else
715	{
716	m_enmStatus = Status_Aborted;
717	}
718
719	/* Signal in any case. */
720	LogRel2(("DnD: Signalling drop event\n"));
721
722	int rc2 = RTSemEventSignal(m_EvtDropped);
723	if (RT_SUCCESS(rc))
724	rc = rc2;
725
726	LogFunc(("mStatus=%RU32, rc=%Rrc\n", m_enmStatus, rc));
727	return rc;
728	}
729

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnDDataObject.cpp@ 95960

Download in other formats: