VBoxDnDDataObject.cpp@ 100765

Last change on this file since 100765 was 98103, checked in by vboxsync, 2 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.3 KB

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

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

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

Download in other formats: