GuestDnDTargetImpl.cpp@ 51620

Last change on this file since 51620 was 51620, checked in by vboxsync, 10 years ago
DnD: Autocallers, locking.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 14.5 KB

Line
1	/* $Id: GuestDnDTargetImpl.cpp 51620 2014-06-16 10:20:15Z vboxsync $ */
2	/** @file
3	* VBox Console COM Class implementation - Guest drag'n drop target.
4	*/
5
6	/*
7	* Copyright (C) 2014 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	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#include "GuestImpl.h"
23	#include "GuestDnDTargetImpl.h"
24
25	#include "Global.h"
26	#include "AutoCaller.h"
27
28	#include <algorithm> /* For std::find(). */
29	#include <iprt/cpp/utils.h> /* For unconst(). */
30
31	#include <VBox/com/array.h>
32	#include <VBox/HostServices/DragAndDropSvc.h>
33
34	#ifdef LOG_GROUP
35	#undef LOG_GROUP
36	#endif
37	#define LOG_GROUP LOG_GROUP_GUEST_DND
38	#include <VBox/log.h>
39
40
41	// constructor / destructor
42	/////////////////////////////////////////////////////////////////////////////
43
44	DEFINE_EMPTY_CTOR_DTOR(GuestDnDTarget)
45
46	HRESULT GuestDnDTarget::FinalConstruct(void)
47	{
48	LogFlowThisFunc(("\n"));
49	return BaseFinalConstruct();
50	}
51
52	void GuestDnDTarget::FinalRelease(void)
53	{
54	LogFlowThisFuncEnter();
55	uninit();
56	BaseFinalRelease();
57	LogFlowThisFuncLeave();
58	}
59
60	// public initializer/uninitializer for internal purposes only
61	/////////////////////////////////////////////////////////////////////////////
62
63	int GuestDnDTarget::init(const ComObjPtr<Guest>& pGuest)
64	{
65	LogFlowThisFuncEnter();
66
67	/* Enclose the state transition NotReady->InInit->Ready. */
68	AutoInitSpan autoInitSpan(this);
69	AssertReturn(autoInitSpan.isOk(), E_FAIL);
70
71	unconst(m_pGuest) = pGuest;
72
73	/* Confirm a successful initialization when it's the case. */
74	autoInitSpan.setSucceeded();
75
76	return VINF_SUCCESS;
77	}
78
79	/**
80	* Uninitializes the instance.
81	* Called from FinalRelease().
82	*/
83	void GuestDnDTarget::uninit(void)
84	{
85	LogFlowThisFunc(("\n"));
86
87	/* Enclose the state transition Ready->InUninit->NotReady. */
88	AutoUninitSpan autoUninitSpan(this);
89	if (autoUninitSpan.uninitDone())
90	return;
91	}
92
93	// implementation of wrapped IDnDBase methods.
94	/////////////////////////////////////////////////////////////////////////////
95
96	HRESULT GuestDnDTarget::isFormatSupported(const com::Utf8Str &aFormat,
97	BOOL *aSupported)
98	{
99	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
100	ReturnComNotImplemented();
101	#else /* VBOX_WITH_DRAG_AND_DROP */
102
103	AutoCaller autoCaller(this);
104	if (FAILED(autoCaller.rc())) return autoCaller.rc();
105
106	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
107
108	return GuestDnDBase::isFormatSupported(aFormat, aSupported);
109	#endif /* VBOX_WITH_DRAG_AND_DROP */
110	}
111
112	HRESULT GuestDnDTarget::getFormats(std::vector<com::Utf8Str> &aFormats)
113	{
114	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
115	ReturnComNotImplemented();
116	#else /* VBOX_WITH_DRAG_AND_DROP */
117
118	AutoCaller autoCaller(this);
119	if (FAILED(autoCaller.rc())) return autoCaller.rc();
120
121	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
122
123	return GuestDnDBase::getFormats(aFormats);
124	#endif /* VBOX_WITH_DRAG_AND_DROP */
125	}
126
127	HRESULT GuestDnDTarget::addFormats(const std::vector<com::Utf8Str> &aFormats)
128	{
129	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
130	ReturnComNotImplemented();
131	#else /* VBOX_WITH_DRAG_AND_DROP */
132
133	AutoCaller autoCaller(this);
134	if (FAILED(autoCaller.rc())) return autoCaller.rc();
135
136	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
137
138	return GuestDnDBase::addFormats(aFormats);
139	#endif /* VBOX_WITH_DRAG_AND_DROP */
140	}
141
142	HRESULT GuestDnDTarget::removeFormats(const std::vector<com::Utf8Str> &aFormats)
143	{
144	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
145	ReturnComNotImplemented();
146	#else /* VBOX_WITH_DRAG_AND_DROP */
147
148	AutoCaller autoCaller(this);
149	if (FAILED(autoCaller.rc())) return autoCaller.rc();
150
151	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
152
153	return GuestDnDBase::removeFormats(aFormats);
154	#endif /* VBOX_WITH_DRAG_AND_DROP */
155	}
156
157	// implementation of wrapped IDnDTarget methods.
158	/////////////////////////////////////////////////////////////////////////////
159
160	HRESULT GuestDnDTarget::enter(ULONG aScreenId, ULONG aX, ULONG aY,
161	DnDAction_T aDefaultAction,
162	const std::vector<DnDAction_T> &aAllowedActions,
163	const std::vector<com::Utf8Str> &aFormats,
164	DnDAction_T *aResultAction)
165	{
166	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
167	ReturnComNotImplemented();
168	#else /* VBOX_WITH_DRAG_AND_DROP */
169
170	/* Input validation. */
171	if (aDefaultAction == DnDAction_Ignore)
172	return setError(E_INVALIDARG, tr("No default action specified"));
173	if (!aAllowedActions.size())
174	return setError(E_INVALIDARG, tr("Number of allowed actions is empty"));
175	if (!aFormats.size())
176	return setError(E_INVALIDARG, tr("Number of supported formats is empty"));
177
178	AutoCaller autoCaller(this);
179	if (FAILED(autoCaller.rc())) return autoCaller.rc();
180
181	/* Default action is ignoring. */
182	DnDAction_T resAction = DnDAction_Ignore;
183
184	/* Check & convert the drag & drop actions */
185	uint32_t uDefAction = 0;
186	uint32_t uAllowedActions = 0;
187	GuestDnD::toHGCMActions(aDefaultAction, &uDefAction,
188	aAllowedActions, &uAllowedActions);
189	/* If there is no usable action, ignore this request. */
190	if (isDnDIgnoreAction(uDefAction))
191	return S_OK;
192
193	/* Make a flat data string out of the supported format list. */
194	Utf8Str strFormats = GuestDnD::toFormatString(m_strFormats, aFormats);
195	/* If there is no valid supported format, ignore this request. */
196	if (strFormats.isEmpty())
197	return S_OK;
198
199	HRESULT hr = S_OK;
200
201	/* Adjust the coordinates in a multi-monitor setup. */
202	int rc = GuestDnDInst()->adjustScreenCoordinates(aScreenId, &aX, &aY);
203	if (RT_SUCCESS(rc))
204	{
205	VBOXHGCMSVCPARM paParms[8];
206	int i = 0;
207	paParms[i++].setUInt32(aScreenId);
208	paParms[i++].setUInt32(aX);
209	paParms[i++].setUInt32(aY);
210	paParms[i++].setUInt32(uDefAction);
211	paParms[i++].setUInt32(uAllowedActions);
212	paParms[i++].setPointer((void*)strFormats.c_str(), strFormats.length() + 1);
213	paParms[i++].setUInt32(strFormats.length() + 1);
214
215	rc = GuestDnDInst()->hostCall(DragAndDropSvc::HOST_DND_HG_EVT_ENTER,
216	i, paParms);
217	if (RT_SUCCESS(rc))
218	{
219	GuestDnDResponse *pResp = GuestDnDInst()->response();
220	if (pResp && RT_SUCCESS(pResp->waitForGuestResponse()))
221	resAction = GuestDnD::toMainAction(pResp->defAction());
222	}
223	}
224
225	if (aResultAction)
226	*aResultAction = resAction;
227
228	LogFlowFunc(("hr=%Rhrc, resAction=%ld\n", hr, resAction));
229	return hr;
230	#endif /* VBOX_WITH_DRAG_AND_DROP */
231	}
232
233	HRESULT GuestDnDTarget::move(ULONG aScreenId, ULONG aX, ULONG aY,
234	DnDAction_T aDefaultAction,
235	const std::vector<DnDAction_T> &aAllowedActions,
236	const std::vector<com::Utf8Str> &aFormats,
237	DnDAction_T *aResultAction)
238	{
239	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
240	ReturnComNotImplemented();
241	#else /* VBOX_WITH_DRAG_AND_DROP */
242
243	/* Input validation. */
244
245	AutoCaller autoCaller(this);
246	if (FAILED(autoCaller.rc())) return autoCaller.rc();
247
248	/* Default action is ignoring. */
249	DnDAction_T resAction = DnDAction_Ignore;
250
251	/* Check & convert the drag & drop actions. */
252	uint32_t uDefAction = 0;
253	uint32_t uAllowedActions = 0;
254	GuestDnD::toHGCMActions(aDefaultAction, &uDefAction,
255	aAllowedActions, &uAllowedActions);
256	/* If there is no usable action, ignore this request. */
257	if (isDnDIgnoreAction(uDefAction))
258	return S_OK;
259
260	/* Make a flat data string out of the supported format list. */
261	RTCString strFormats = GuestDnD::toFormatString(m_strFormats, aFormats);
262	/* If there is no valid supported format, ignore this request. */
263	if (strFormats.isEmpty())
264	return S_OK;
265
266	HRESULT hr = S_OK;
267
268	int rc = GuestDnDInst()->adjustScreenCoordinates(aScreenId, &aX, &aY);
269	if (RT_SUCCESS(rc))
270	{
271	VBOXHGCMSVCPARM paParms[8];
272	int i = 0;
273	paParms[i++].setUInt32(aScreenId);
274	paParms[i++].setUInt32(aX);
275	paParms[i++].setUInt32(aY);
276	paParms[i++].setUInt32(uDefAction);
277	paParms[i++].setUInt32(uAllowedActions);
278	paParms[i++].setPointer((void*)strFormats.c_str(), strFormats.length() + 1);
279	paParms[i++].setUInt32(strFormats.length() + 1);
280
281	rc = GuestDnDInst()->hostCall(DragAndDropSvc::HOST_DND_HG_EVT_MOVE,
282	i, paParms);
283	if (RT_SUCCESS(rc))
284	{
285	GuestDnDResponse *pResp = GuestDnDInst()->response();
286	if (pResp && RT_SUCCESS(pResp->waitForGuestResponse()))
287	resAction = GuestDnD::toMainAction(pResp->defAction());
288	}
289	}
290
291	if (aResultAction)
292	*aResultAction = resAction;
293
294	LogFlowFunc(("hr=%Rhrc, *pResultAction=%ld\n", hr, resAction));
295	return hr;
296	#endif /* VBOX_WITH_DRAG_AND_DROP */
297	}
298
299	HRESULT GuestDnDTarget::leave(ULONG uScreenId)
300	{
301	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
302	ReturnComNotImplemented();
303	#else /* VBOX_WITH_DRAG_AND_DROP */
304
305	AutoCaller autoCaller(this);
306	if (FAILED(autoCaller.rc())) return autoCaller.rc();
307
308	HRESULT hr = S_OK;
309	int rc = GuestDnDInst()->hostCall(DragAndDropSvc::HOST_DND_HG_EVT_LEAVE,
310	0 /* cParms /, NULL / paParms */);
311	if (RT_SUCCESS(rc))
312	{
313	GuestDnDResponse *pResp = GuestDnDInst()->response();
314	if (pResp)
315	pResp->waitForGuestResponse();
316	}
317
318	LogFlowFunc(("hr=%Rhrc\n", hr));
319	return hr;
320	#endif /* VBOX_WITH_DRAG_AND_DROP */
321	}
322
323	HRESULT GuestDnDTarget::drop(ULONG aScreenId, ULONG aX, ULONG aY,
324	DnDAction_T aDefaultAction,
325	const std::vector<DnDAction_T> &aAllowedActions,
326	const std::vector<com::Utf8Str> &aFormats,
327	com::Utf8Str &aFormat, DnDAction_T *aResultAction)
328	{
329	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
330	ReturnComNotImplemented();
331	#else /* VBOX_WITH_DRAG_AND_DROP */
332
333	/* Input validation. */
334
335	/* Everything else is optional. */
336
337	AutoCaller autoCaller(this);
338	if (FAILED(autoCaller.rc())) return autoCaller.rc();
339
340	/* Default action is ignoring. */
341	DnDAction_T resAction = DnDAction_Ignore;
342
343	/* Check & convert the drag & drop actions. */
344	uint32_t uDefAction = 0;
345	uint32_t uAllowedActions = 0;
346	GuestDnD::toHGCMActions(aDefaultAction, &uDefAction,
347	aAllowedActions, &uAllowedActions);
348	/* If there is no usable action, ignore this request. */
349	if (isDnDIgnoreAction(uDefAction))
350	return S_OK;
351
352	/* Make a flat data string out of the supported format list. */
353	Utf8Str strFormats = GuestDnD::toFormatString(m_strFormats, aFormats);
354	/* If there is no valid supported format, ignore this request. */
355	if (strFormats.isEmpty())
356	return S_OK;
357
358	HRESULT hr = S_OK;
359
360	/* Adjust the coordinates in a multi-monitor setup. */
361	int rc = GuestDnDInst()->adjustScreenCoordinates(aScreenId, &aX, &aY);
362	if (RT_SUCCESS(rc))
363	{
364	VBOXHGCMSVCPARM paParms[8];
365	int i = 0;
366	paParms[i++].setUInt32(aScreenId);
367	paParms[i++].setUInt32(aX);
368	paParms[i++].setUInt32(aY);
369	paParms[i++].setUInt32(uDefAction);
370	paParms[i++].setUInt32(uAllowedActions);
371	paParms[i++].setPointer((void*)strFormats.c_str(), strFormats.length() + 1);
372	paParms[i++].setUInt32(strFormats.length() + 1);
373
374	rc = GuestDnDInst()->hostCall(DragAndDropSvc::HOST_DND_HG_EVT_DROPPED,
375	i, paParms);
376	if (RT_SUCCESS(rc))
377	{
378	GuestDnDResponse *pResp = GuestDnDInst()->response();
379	if (pResp && RT_SUCCESS(pResp->waitForGuestResponse()))
380	{
381	resAction = GuestDnD::toMainAction(pResp->defAction());
382	aFormat = pResp->format();
383
384	LogFlowFunc(("resFormat=%s, resAction=%RU32\n",
385	pResp->format().c_str(), pResp->defAction()));
386	}
387	}
388	}
389
390	if (aResultAction)
391	*aResultAction = resAction;
392
393	return hr;
394	#endif /* VBOX_WITH_DRAG_AND_DROP */
395	}
396
397	HRESULT GuestDnDTarget::sendData(ULONG aScreenId,
398	const com::Utf8Str &aFormat,
399	const std::vector<BYTE> &aData,
400	ComPtr<IProgress> &aProgress)
401	{
402	#if !defined(VBOX_WITH_DRAG_AND_DROP) \|\| !defined(VBOX_WITH_DRAG_AND_DROP_GH)
403	ReturnComNotImplemented();
404	#else /* VBOX_WITH_DRAG_AND_DROP */
405
406	/* Input validation */
407
408
409	AutoCaller autoCaller(this);
410	if (FAILED(autoCaller.rc())) return autoCaller.rc();
411
412	HRESULT hr = S_OK;
413
414	VBOXHGCMSVCPARM paParms[8];
415	int i = 0;
416	paParms[i++].setUInt32(aScreenId);
417	paParms[i++].setPointer((void *)aFormat.c_str(), (uint32_t)aFormat.length() + 1);
418	paParms[i++].setUInt32((uint32_t)aFormat.length() + 1);
419	paParms[i++].setPointer((void *)aData.front(), (uint32_t)aData.size());
420	paParms[i++].setUInt32((uint32_t)aData.size());
421
422	GuestDnDResponse *pResp = GuestDnDInst()->response();
423	if (pResp)
424	{
425	/* Reset any old progress status. */
426	pResp->resetProgress(m_pGuest);
427
428	/* Note: The actual data transfer of files/directoies is performed by the
429	* DnD host service. */
430	int rc = GuestDnDInst()->hostCall(DragAndDropSvc::HOST_DND_HG_SND_DATA,
431	i, paParms);
432	if (RT_SUCCESS(rc))
433	{
434	/* Query the progress object to the caller. */
435	if (aProgress)
436	pResp->queryProgressTo(aProgress.asOutParam());
437	}
438	}
439
440	return hr;
441	#endif /* VBOX_WITH_DRAG_AND_DROP */
442	}
443

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

source: vbox/trunk/src/VBox/Main/src-client/GuestDnDTargetImpl.cpp@ 51620

Download in other formats: