draganddrop.cpp@ 97827

Last change on this file since 97827 was 97827, checked in by vboxsync, 2 years ago
DnD/Additions/VBoxClient: Make use of DND_PATH_SEPARATOR_STR.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 133.2 KB

Line
1	/* $Id: draganddrop.cpp 97827 2022-12-16 15:24:52Z vboxsync $ */
2	/** @file
3	* X11 guest client - Drag and drop implementation.
4	*/
5
6	/*
7	* Copyright (C) 2011-2022 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	#include <X11/Xlib.h>
29	#include <X11/Xutil.h>
30	#include <X11/Xatom.h>
31	#ifdef VBOX_DND_WITH_XTEST
32	# include <X11/extensions/XTest.h>
33	#endif
34
35	#include <iprt/asm.h>
36	#include <iprt/buildconfig.h>
37	#include <iprt/critsect.h>
38	#include <iprt/thread.h>
39	#include <iprt/time.h>
40
41	#include <iprt/cpp/mtlist.h>
42	#include <iprt/cpp/ministring.h>
43
44	#include <limits.h>
45
46	#ifdef LOG_GROUP
47	# undef LOG_GROUP
48	#endif
49	#define LOG_GROUP LOG_GROUP_GUEST_DND
50	#include <VBox/log.h>
51	#include <VBox/VBoxGuestLib.h>
52	#include <VBox/version.h>
53
54	#include "VBox/HostServices/DragAndDropSvc.h"
55	#include "VBoxClient.h"
56
57
58	/* Enable this to handle drag'n drop "promises".
59	* This is needed for supporting certain applications (i.e. PcManFM on LXDE),
60	* which require the drag'n drop meta data a lot earlier than actually needed.
61	* That behavior is similar to macOS' drag'n drop promises, hence the name.
62	*
63	* Those applications query the data right while dragging over them (see GtkWidget::drag-motion),
64	* instead of when the source dropped the data (GtkWidget::drag-drop).
65	*
66	* This might be entirely implementation-specific, so not being a bug in GTK/GDK. Also see #9820.
67	*/
68	#ifdef VBOX_WITH_DRAG_AND_DROP_PROMISES
69	# undef VBOX_WITH_DRAG_AND_DROP_PROMISES
70	#endif
71
72	/**
73	* For X11 guest Xdnd is used. See http://www.acc.umu.se/~vatten/XDND.html for
74	* a walk trough.
75	*
76	* Also useful pages:
77	* - https://www.freedesktop.org/wiki/Draganddropwarts/
78	* - https://www.freedesktop.org/wiki/Specifications/XDNDRevision/
79	*
80	* Host -> Guest:
81	* For X11 this means mainly forwarding all the events from HGCM to the
82	* appropriate X11 events. There exists a proxy window, which is invisible and
83	* used for all the X11 communication. On a HGCM Enter event, we set our proxy
84	* window as XdndSelection owner with the given mime-types. On every HGCM move
85	* event, we move the X11 mouse cursor to the new position and query for the
86	* window below that position. Depending on if it is XdndAware, a new window or
87	* a known window, we send the appropriate X11 messages to it. On HGCM drop, we
88	* send a XdndDrop message to the current window and wait for a X11
89	* SelectionMessage from the target window. Because we didn't have the data in
90	* the requested mime-type, yet, we save that message and ask the host for the
91	* data. When the data is successfully received from the host, we put the data
92	* as a property to the window and send a X11 SelectionNotify event to the
93	* target window.
94	*
95	* Guest -> Host:
96	* This is a lot more trickery than H->G. When a pending event from HGCM
97	* arrives, we ask if there currently is an owner of the XdndSelection
98	* property. If so, our proxy window is shown (1x1, but without backing store)
99	* and some mouse event is triggered. This should be followed by an XdndEnter
100	* event send to the proxy window. From this event we can fetch the necessary
101	* info of the MIME types and allowed actions and send this back to the host.
102	* On a drop request from the host, we query for the selection and should get
103	* the data in the specified mime-type. This data is send back to the host.
104	* After that we send a XdndLeave event to the source window.
105	*
106	** @todo Cancelling (e.g. with ESC key) doesn't work.
107	** @todo INCR (incremental transfers) support.
108	** @todo Really check for the Xdnd version and the supported features.
109	** @todo Either get rid of the xHelpers class or properly unify the code with the drag instance class.
110	*/
111
112	/*********************************************************************************************************************************
113	* Definitions *
114	********************************************************************************************************************************/
115
116	/** The Xdnd protocol version we support. */
117	#define VBOX_XDND_VERSION (5)
118
119	/** No flags specified. */
120	#define VBOX_XDND_STATUS_FLAG_NONE 0
121	/** Whether the target window accepts the data being dragged over or not. */
122	#define VBOX_XDND_STATUS_FLAG_ACCEPT RT_BIT(0)
123	/** Whether the target window wants XdndPosition messages while dragging stuff over it. */
124	#define VBOX_XDND_STATUS_FLAG_WANTS_POS RT_BIT(1)
125
126	/** Whether the target window accepted the drop data or not. */
127	#define VBOX_XDND_FINISHED_FLAG_SUCCEEDED RT_BIT(0)
128
129	/** How many X properties our proxy window can hold. */
130	#define VBOX_MAX_XPROPERTIES (LONG_MAX-1)
131
132	/** The notification header text for VBClShowNotify(). */
133	#define VBOX_DND_SHOWNOTIFY_HEADER VBOX_PRODUCT " Drag'n Drop"
134
135	/**
136	* Structure for storing new X11 events and HGCM messages
137	* into a single event queue.
138	*/
139	typedef struct DNDEVENT
140	{
141	enum DnDEventType
142	{
143	/** Unknown event, do not use. */
144	DnDEventType_Unknown = 0,
145	/** VBGLR3DNDEVENT event. */
146	DnDEventType_HGCM,
147	/** X11 event. */
148	DnDEventType_X11,
149	/** Blow the type up to 32-bit. */
150	DnDEventType_32BIT_HACK = 0x7fffffff
151	};
152	/** Event type. */
153	DnDEventType enmType;
154	union
155	{
156	PVBGLR3DNDEVENT hgcm;
157	XEvent x11;
158	};
159	#ifdef IN_GUEST
160	RTMEM_IMPLEMENT_NEW_AND_DELETE();
161	#endif
162	} DNDEVENT;
163	/** Pointer to a DnD event. */
164	typedef DNDEVENT *PDNDEVENT;
165
166	enum XA_Type
167	{
168	/* States */
169	XA_WM_STATE = 0,
170	/* Properties */
171	XA_TARGETS,
172	XA_MULTIPLE,
173	XA_INCR,
174	/* Mime Types */
175	XA_image_bmp,
176	XA_image_jpg,
177	XA_image_tiff,
178	XA_image_png,
179	XA_text_uri_list,
180	XA_text_uri,
181	XA_text_plain,
182	XA_TEXT,
183	/* Xdnd */
184	XA_XdndSelection,
185	XA_XdndAware,
186	XA_XdndEnter,
187	XA_XdndLeave,
188	XA_XdndTypeList,
189	XA_XdndActionList,
190	XA_XdndPosition,
191	XA_XdndActionCopy,
192	XA_XdndActionMove,
193	XA_XdndActionLink,
194	XA_XdndStatus,
195	XA_XdndDrop,
196	XA_XdndFinished,
197	/* Our own stop marker */
198	XA_dndstop,
199	/* End marker */
200	XA_End
201	};
202
203	/**
204	* Xdnd message value indices, sorted by message type.
205	*/
206	typedef enum XdndMsg
207	{
208	/** XdndEnter. */
209	XdndEnterTypeCount = 3, /* Maximum number of types in XdndEnter message. */
210
211	XdndEnterWindow = 0, /* Source window (sender). */
212	XdndEnterFlags, /* Version in high byte, bit 0 => more data types. */
213	XdndEnterType1, /* First available data type. */
214	XdndEnterType2, /* Second available data type. */
215	XdndEnterType3, /* Third available data type. */
216
217	XdndEnterMoreTypesFlag = 1, /* Set if there are more than XdndEnterTypeCount. */
218	XdndEnterVersionRShift = 24, /* Right shift to position version number. */
219	XdndEnterVersionMask = 0xFF, /* Mask to get version after shifting. */
220
221	/** XdndHere. */
222	XdndHereWindow = 0, /* Source window (sender). */
223	XdndHereFlags, /* Reserved. */
224	XdndHerePt, /* X + Y coordinates of mouse (root window coords). */
225	XdndHereTimeStamp, /* Timestamp for requesting data. */
226	XdndHereAction, /* Action requested by user. */
227
228	/** XdndPosition. */
229	XdndPositionWindow = 0, /* Source window (sender). */
230	XdndPositionFlags, /* Flags. */
231	XdndPositionXY, /* X/Y coordinates of the mouse position relative to the root window. */
232	XdndPositionTimeStamp, /* Time stamp for retrieving the data. */
233	XdndPositionAction, /* Action requested by the user. */
234
235	/** XdndStatus. */
236	XdndStatusWindow = 0, /* Target window (sender).*/
237	XdndStatusFlags, /* Flags returned by target. */
238	XdndStatusNoMsgXY, /* X + Y of "no msg" rectangle (root window coords). */
239	XdndStatusNoMsgWH, /* Width + height of "no msg" rectangle. */
240	XdndStatusAction, /* Action accepted by target. */
241
242	XdndStatusAcceptDropFlag = 1, /* Set if target will accept the drop. */
243	XdndStatusSendHereFlag = 2, /* Set if target wants a stream of XdndPosition. */
244
245	/** XdndLeave. */
246	XdndLeaveWindow = 0, /* Source window (sender). */
247	XdndLeaveFlags, /* Reserved. */
248
249	/** XdndDrop. */
250	XdndDropWindow = 0, /* Source window (sender). */
251	XdndDropFlags, /* Reserved. */
252	XdndDropTimeStamp, /* Timestamp for requesting data. */
253
254	/** XdndFinished. */
255	XdndFinishedWindow = 0, /* Target window (sender). */
256	XdndFinishedFlags, /* Since version 5: Bit 0 is set if the current target accepted the drop. */
257	XdndFinishedAction /* Since version 5: Contains the action performed by the target. */
258
259	} XdndMsg;
260
261	class DragAndDropService;
262
263	/** List of Atoms. */
264	#define VBoxDnDAtomList RTCList<Atom>
265
266	class xHelpers
267	{
268	public:
269
270	static xHelpers getInstance(Display pDisplay = 0)
271	{
272	if (!m_pInstance)
273	{
274	AssertPtrReturn(pDisplay, NULL);
275	m_pInstance = new xHelpers(pDisplay);
276	}
277
278	return m_pInstance;
279	}
280
281	static void destroyInstance(void)
282	{
283	if (m_pInstance)
284	{
285	delete m_pInstance;
286	m_pInstance = NULL;
287	}
288	}
289
290	inline Display *display() const { return m_pDisplay; }
291	inline Atom xAtom(XA_Type e) const { return m_xAtoms[e]; }
292
293	inline Atom stringToxAtom(const char *pcszString) const
294	{
295	return XInternAtom(m_pDisplay, pcszString, False);
296	}
297	inline RTCString xAtomToString(Atom atom) const
298	{
299	if (atom == None) return "None";
300
301	char* pcsAtom = XGetAtomName(m_pDisplay, atom);
302	RTCString strAtom(pcsAtom);
303	XFree(pcsAtom);
304
305	return strAtom;
306	}
307
308	inline RTCString xAtomListToString(const VBoxDnDAtomList &formatList, const RTCString &strSep = DND_FORMATS_SEPARATOR_STR)
309	{
310	RTCString format;
311	for (size_t i = 0; i < formatList.size(); ++i)
312	format += xAtomToString(formatList.at(i)) + strSep;
313	return format;
314	}
315
316	/**
317	* Returns a filtered X11 atom list.
318	*
319	* @returns Filtered list.
320	* @param formatList Atom list to convert.
321	* @param filterList Atom list to filter out.
322	*/
323	inline VBoxDnDAtomList xAtomListFiltered(const VBoxDnDAtomList &formatList, const VBoxDnDAtomList &filterList)
324	{
325	VBoxDnDAtomList tempList = formatList;
326	tempList.filter(filterList);
327	return tempList;
328	}
329
330	RTCString xErrorToString(int xRc) const;
331	Window applicationWindowBelowCursor(Window parentWin) const;
332
333	private:
334	#ifdef RT_NEED_NEW_AND_DELETE
335	RTMEM_IMPLEMENT_NEW_AND_DELETE();
336	#endif
337	xHelpers(Display *pDisplay)
338	: m_pDisplay(pDisplay)
339	{
340	/* Not all x11 atoms we use are defined in the headers. Create the
341	* additional one we need here. */
342	for (int i = 0; i < XA_End; ++i)
343	m_xAtoms[i] = XInternAtom(m_pDisplay, m_xAtomNames[i], False);
344	};
345
346	/* Private member vars */
347	static xHelpers *m_pInstance;
348	Display *m_pDisplay;
349	Atom m_xAtoms[XA_End];
350	static const char *m_xAtomNames[XA_End];
351	};
352
353	/* Some xHelpers convenience defines. */
354	#define gX11 xHelpers::getInstance()
355	#define xAtom(xa) xHelpers::getInstance()->xAtom((xa))
356	#define xAtomToString(xa) xHelpers::getInstance()->xAtomToString((xa))
357
358	/*********************************************************************************************************************************
359	* xHelpers implementation. *
360	********************************************************************************************************************************/
361
362	xHelpers *xHelpers::m_pInstance = NULL;
363
364	/* Has to be in sync with the XA_Type enum. */
365	const char *xHelpers::m_xAtomNames[] =
366	{
367	/* States */
368	"WM_STATE",
369	/* Properties */
370	"TARGETS",
371	"MULTIPLE",
372	"INCR",
373	/* Mime Types */
374	"image/bmp",
375	"image/jpg",
376	"image/tiff",
377	"image/png",
378	"text/uri-list",
379	"text/uri",
380	"text/plain",
381	"TEXT",
382	/* Xdnd */
383	"XdndSelection",
384	"XdndAware",
385	"XdndEnter",
386	"XdndLeave",
387	"XdndTypeList",
388	"XdndActionList",
389	"XdndPosition",
390	"XdndActionCopy",
391	"XdndActionMove",
392	"XdndActionLink",
393	"XdndStatus",
394	"XdndDrop",
395	"XdndFinished",
396	/* Our own stop marker */
397	"dndstop"
398	};
399
400	RTCString xHelpers::xErrorToString(int xRc) const
401	{
402	switch (xRc)
403	{
404	case Success: return RTCStringFmt("%d (Success)", xRc); break;
405	case BadRequest: return RTCStringFmt("%d (BadRequest)", xRc); break;
406	case BadValue: return RTCStringFmt("%d (BadValue)", xRc); break;
407	case BadWindow: return RTCStringFmt("%d (BadWindow)", xRc); break;
408	case BadPixmap: return RTCStringFmt("%d (BadPixmap)", xRc); break;
409	case BadAtom: return RTCStringFmt("%d (BadAtom)", xRc); break;
410	case BadCursor: return RTCStringFmt("%d (BadCursor)", xRc); break;
411	case BadFont: return RTCStringFmt("%d (BadFont)", xRc); break;
412	case BadMatch: return RTCStringFmt("%d (BadMatch)", xRc); break;
413	case BadDrawable: return RTCStringFmt("%d (BadDrawable)", xRc); break;
414	case BadAccess: return RTCStringFmt("%d (BadAccess)", xRc); break;
415	case BadAlloc: return RTCStringFmt("%d (BadAlloc)", xRc); break;
416	case BadColor: return RTCStringFmt("%d (BadColor)", xRc); break;
417	case BadGC: return RTCStringFmt("%d (BadGC)", xRc); break;
418	case BadIDChoice: return RTCStringFmt("%d (BadIDChoice)", xRc); break;
419	case BadName: return RTCStringFmt("%d (BadName)", xRc); break;
420	case BadLength: return RTCStringFmt("%d (BadLength)", xRc); break;
421	case BadImplementation: return RTCStringFmt("%d (BadImplementation)", xRc); break;
422	}
423	return RTCStringFmt("%d (unknown)", xRc);
424	}
425
426	/** @todo Make this iterative. */
427	Window xHelpers::applicationWindowBelowCursor(Window wndParent) const
428	{
429	/* No parent, nothing to do. */
430	if(wndParent == 0)
431	return 0;
432
433	Window wndApp = 0;
434	int cProps = -1;
435
436	/* Fetch all x11 window properties of the parent window. */
437	Atom *pProps = XListProperties(m_pDisplay, wndParent, &cProps);
438	if (cProps > 0)
439	{
440	/* We check the window for the WM_STATE property. */
441	for (int i = 0; i < cProps; ++i)
442	{
443	if (pProps[i] == xAtom(XA_WM_STATE))
444	{
445	/* Found it. */
446	wndApp = wndParent;
447	break;
448	}
449	}
450
451	/* Cleanup */
452	XFree(pProps);
453	}
454
455	if (!wndApp)
456	{
457	Window wndChild, wndTemp;
458	int tmp;
459	unsigned int utmp;
460
461	/* Query the next child window of the parent window at the current
462	* mouse position. */
463	XQueryPointer(m_pDisplay, wndParent, &wndTemp, &wndChild, &tmp, &tmp, &tmp, &tmp, &utmp);
464
465	/* Recursive call our self to dive into the child tree. */
466	wndApp = applicationWindowBelowCursor(wndChild);
467	}
468
469	return wndApp;
470	}
471
472	#ifdef DEBUG
473	# define VBOX_DND_FN_DECL_LOG(x) inline x /* For LogFlowXXX logging. */
474	#else
475	# define VBOX_DND_FN_DECL_LOG(x) x
476	#endif
477
478	/**
479	* Class which handles a single drag'n drop proxy window.
480	** @todo Move all proxy window-related stuff into this class! Clean up this mess.
481	*/
482	class VBoxDnDProxyWnd
483	{
484
485	public:
486	#ifdef RT_NEED_NEW_AND_DELETE
487	RTMEM_IMPLEMENT_NEW_AND_DELETE();
488	#endif
489	VBoxDnDProxyWnd(void);
490	virtual ~VBoxDnDProxyWnd(void);
491
492	public:
493
494	int init(Display *pDisplay);
495	void destroy();
496
497	int sendFinished(Window hWndSource, VBOXDNDACTION dndAction);
498
499	public:
500
501	Display *pDisp;
502	/** Proxy window handle. */
503	Window hWnd;
504	int iX;
505	int iY;
506	int iWidth;
507	int iHeight;
508	};
509
510	/** This class only serve to avoid dragging in generic new() and delete(). */
511	class WrappedXEvent
512	{
513	public:
514	XEvent m_Event;
515
516	public:
517	#ifdef RT_NEED_NEW_AND_DELETE
518	RTMEM_IMPLEMENT_NEW_AND_DELETE();
519	#endif
520	WrappedXEvent(const XEvent &a_rSrcEvent)
521	{
522	m_Event = a_rSrcEvent;
523	}
524
525	WrappedXEvent()
526	{
527	RT_ZERO(m_Event);
528	}
529
530	WrappedXEvent &operator=(const XEvent &a_rSrcEvent)
531	{
532	m_Event = a_rSrcEvent;
533	return *this;
534	}
535	};
536
537	/**
538	* Class for handling a single drag and drop operation, that is,
539	* one source and one target at a time.
540	*
541	* For now only one DragInstance will exits when the app is running.
542	*/
543	class DragInstance
544	{
545	public:
546
547	enum State
548	{
549	Uninitialized = 0,
550	Initialized,
551	Dragging,
552	Dropped,
553	State_32BIT_Hack = 0x7fffffff
554	};
555
556	enum Mode
557	{
558	Unknown = 0,
559	HG,
560	GH,
561	Mode_32Bit_Hack = 0x7fffffff
562	};
563
564	#ifdef RT_NEED_NEW_AND_DELETE
565	RTMEM_IMPLEMENT_NEW_AND_DELETE();
566	#endif
567	DragInstance(Display pDisplay, DragAndDropService pParent);
568
569	public:
570
571	int init(uint32_t uScreenID);
572	int term(void);
573	void stop(void);
574	void reset(void);
575
576	/* X11 message processing. */
577	int onX11ClientMessage(const XEvent &e);
578	int onX11MotionNotify(const XEvent &e);
579	int onX11SelectionClear(const XEvent &e);
580	int onX11SelectionNotify(const XEvent &e);
581	int onX11SelectionRequest(const XEvent &evReq);
582	int onX11Event(const XEvent &e);
583	int waitForStatusChange(uint32_t enmState, RTMSINTERVAL uTimeoutMS = 30000);
584	bool waitForX11Msg(XEvent &evX, int iType, RTMSINTERVAL uTimeoutMS = 100);
585	bool waitForX11ClientMsg(XClientMessageEvent &evMsg, Atom aType, RTMSINTERVAL uTimeoutMS = 100);
586
587	/* Session handling. */
588	int checkForSessionChange(void);
589
590	#ifdef VBOX_WITH_DRAG_AND_DROP_GH
591	/* Guest -> Host handling. */
592	int ghIsDnDPending(void);
593	int ghDropped(const RTCString &strFormat, VBOXDNDACTION dndActionRequested);
594	#endif
595
596	/* Host -> Guest handling. */
597	int hgEnter(const RTCList<RTCString> &formats, VBOXDNDACTIONLIST dndListActionsAllowed);
598	int hgLeave(void);
599	int hgMove(uint32_t uPosX, uint32_t uPosY, VBOXDNDACTION dndActionDefault);
600	int hgDrop(uint32_t uPosX, uint32_t uPosY, VBOXDNDACTION dndActionDefault);
601	int hgDataReceive(PVBGLR3GUESTDNDMETADATA pMeta);
602
603	/* X11 helpers. */
604	int mouseCursorFakeMove(void);
605	int mouseCursorMove(int iPosX, int iPosY);
606	void mouseButtonSet(Window wndDest, int rx, int ry, int iButton, bool fPress);
607	int proxyWinShow(int piRootX = NULL, int piRootY = NULL) const;
608	int proxyWinHide(void);
609
610	/* X11 window helpers. */
611	char *wndX11GetNameA(Window wndThis) const;
612
613	/* Xdnd protocol helpers. */
614	void wndXDnDClearActionList(Window wndThis) const;
615	void wndXDnDClearFormatList(Window wndThis) const;
616	int wndXDnDGetActionList(Window wndThis, VBoxDnDAtomList &lstActions) const;
617	int wndXDnDGetFormatList(Window wndThis, VBoxDnDAtomList &lstTypes) const;
618	int wndXDnDSetActionList(Window wndThis, const VBoxDnDAtomList &lstActions) const;
619	int wndXDnDSetFormatList(Window wndThis, Atom atmProp, const VBoxDnDAtomList &lstFormats) const;
620
621	/* Atom / HGCM formatting helpers. */
622	int appendFormatsToList(const RTCList<RTCString> &lstFormats, VBoxDnDAtomList &lstAtoms) const;
623	int appendDataToList(const void *pvData, uint32_t cbData, VBoxDnDAtomList &lstAtoms) const;
624	static Atom toAtomAction(VBOXDNDACTION dndAction);
625	static int toAtomActions(VBOXDNDACTIONLIST dndActionList, VBoxDnDAtomList &lstAtoms);
626	static uint32_t toHGCMAction(Atom atom);
627	static uint32_t toHGCMActions(const VBoxDnDAtomList &actionsList);
628
629	protected:
630
631	/** The instance's own DnD context. */
632	VBGLR3GUESTDNDCMDCTX m_dndCtx;
633	/** Pointer to service instance. */
634	DragAndDropService *m_pParent;
635	/** Pointer to X display operating on. */
636	Display *m_pDisplay;
637	/** X screen ID to operate on. */
638	int m_screenID;
639	/** Pointer to X screen operating on. */
640	Screen *m_pScreen;
641	/** Root window handle. */
642	Window m_wndRoot;
643	/** Proxy window. */
644	VBoxDnDProxyWnd m_wndProxy;
645	/** Current source/target window handle. */
646	Window m_wndCur;
647	/** The XDnD protocol version the current source/target window is using.
648	* Set to 0 if not available / not set yet. */
649	uint8_t m_uXdndVer;
650	/** Last mouse X position (in pixels, absolute to root window).
651	* Set to -1 if not set yet. */
652	int m_lastMouseX;
653	/** Last mouse Y position (in pixels, absolute to root window).
654	* Set to -1 if not set yet. */
655	int m_lastMouseY;
656	/** List of default (Atom) formats required for X11 Xdnd handling.
657	* This list will be included by \a m_lstAtomFormats. */
658	VBoxDnDAtomList m_lstAtomFormatsX11;
659	/** List of (Atom) formats the current source/target window supports. */
660	VBoxDnDAtomList m_lstAtomFormats;
661	/** List of (Atom) actions the current source/target window supports. */
662	VBoxDnDAtomList m_lstAtomActions;
663	/** Buffer for answering the target window's selection request. */
664	void *m_pvSelReqData;
665	/** Size (in bytes) of selection request data buffer. */
666	uint32_t m_cbSelReqData;
667	/** Current operation mode. */
668	volatile uint32_t m_enmMode;
669	/** Current state of operation mode. */
670	volatile uint32_t m_enmState;
671	/** The instance's own X event queue. */
672	RTCMTList<WrappedXEvent> m_eventQueueList;
673	/** Critical section for providing serialized access to list event queue's contents. */
674	RTCRITSECT m_eventQueueCS;
675	/** Event for notifying this instance in case of a new event. */
676	RTSEMEVENT m_eventQueueEvent;
677	/** Critical section for data access. */
678	RTCRITSECT m_dataCS;
679	/** List of allowed formats. */
680	RTCList<RTCString> m_lstAllowedFormats;
681	/** Number of failed attempts by the host
682	* to query for an active drag and drop operation on the guest. */
683	uint16_t m_cFailedPendingAttempts;
684	};
685
686	/**
687	* Service class which implements drag'n drop.
688	*/
689	class DragAndDropService
690	{
691	public:
692	DragAndDropService(void)
693	: m_pDisplay(NULL)
694	, m_hHGCMThread(NIL_RTTHREAD)
695	, m_hX11Thread(NIL_RTTHREAD)
696	, m_hEventSem(NIL_RTSEMEVENT)
697	, m_pCurDnD(NULL)
698	, m_fStop(false)
699	{
700	RT_ZERO(m_dndCtx);
701	}
702
703	int init(void);
704	int worker(bool volatile *pfShutdown);
705	void reset(void);
706	void stop(void);
707	int term(void);
708
709	private:
710
711	static DECLCALLBACK(int) hgcmEventThread(RTTHREAD hThread, void *pvUser);
712	static DECLCALLBACK(int) x11EventThread(RTTHREAD hThread, void *pvUser);
713
714	/* Private member vars */
715	Display *m_pDisplay;
716	/** Our (thread-safe) event queue with mixed events (DnD HGCM / X11). */
717	RTCMTList<DNDEVENT> m_eventQueue;
718	/** Critical section for providing serialized access to list
719	* event queue's contents. */
720	RTCRITSECT m_eventQueueCS;
721	/** Thread handle for the HGCM message pumping thread. */
722	RTTHREAD m_hHGCMThread;
723	/** Thread handle for the X11 message pumping thread. */
724	RTTHREAD m_hX11Thread;
725	/** This service' DnD command context. */
726	VBGLR3GUESTDNDCMDCTX m_dndCtx;
727	/** Event semaphore for new DnD events. */
728	RTSEMEVENT m_hEventSem;
729	/** Pointer to the allocated DnD instance.
730	Currently we only support and handle one instance at a time. */
731	DragInstance *m_pCurDnD;
732	/** Stop indicator flag to signal the thread that it should shut down. */
733	bool m_fStop;
734
735	friend class DragInstance;
736	} g_Svc;
737
738	/*********************************************************************************************************************************
739	* DragInstanc implementation. *
740	********************************************************************************************************************************/
741
742	DragInstance::DragInstance(Display pDisplay, DragAndDropService pParent)
743	: m_pParent(pParent)
744	, m_pDisplay(pDisplay)
745	, m_pScreen(0)
746	, m_wndRoot(0)
747	, m_wndCur(0)
748	, m_uXdndVer(0)
749	, m_pvSelReqData(NULL)
750	, m_cbSelReqData(0)
751	, m_enmMode(Unknown)
752	, m_enmState(Uninitialized)
753	{
754	/* Append default targets we support.
755	* Note: The order is sorted by preference; be careful when changing this. */
756	m_lstAtomFormatsX11.append(xAtom(XA_TARGETS));
757	m_lstAtomFormatsX11.append(xAtom(XA_MULTIPLE));
758	/** @todo Support INC (incremental transfers). */
759	}
760
761	/**
762	* Stops this drag instance.
763	*/
764	void DragInstance::stop(void)
765	{
766	LogFlowFuncEnter();
767
768	int rc2 = VbglR3DnDDisconnect(&m_dndCtx);
769	AssertRC(rc2);
770
771	LogFlowFuncLeave();
772	}
773
774	/**
775	* Terminates (destroys) this drag instance.
776	*
777	* @return VBox status code.
778	*/
779	int DragInstance::term(void)
780	{
781	LogFlowFuncEnter();
782
783	if (m_wndProxy.hWnd != 0)
784	XDestroyWindow(m_pDisplay, m_wndProxy.hWnd);
785
786	int rc = VbglR3DnDDisconnect(&m_dndCtx);
787	AssertRCReturn(rc, rc);
788
789	if (m_pvSelReqData)
790	RTMemFree(m_pvSelReqData);
791
792	rc = RTSemEventDestroy(m_eventQueueEvent);
793	AssertRCReturn(rc, rc);
794
795	rc = RTCritSectDelete(&m_eventQueueCS);
796	AssertRCReturn(rc, rc);
797
798	rc = RTCritSectDelete(&m_dataCS);
799	AssertRCReturn(rc, rc);
800
801	LogFlowFuncLeaveRC(rc);
802	return rc;
803	}
804
805	/**
806	* Resets this drag instance.
807	*/
808	void DragInstance::reset(void)
809	{
810	LogFlowFuncEnter();
811
812	/* Hide the proxy win. */
813	proxyWinHide();
814
815	int rc2 = RTCritSectEnter(&m_dataCS);
816	if (RT_SUCCESS(rc2))
817	{
818	/* If we are currently the Xdnd selection owner, clear that. */
819	Window pWnd = XGetSelectionOwner(m_pDisplay, xAtom(XA_XdndSelection));
820	if (pWnd == m_wndProxy.hWnd)
821	XSetSelectionOwner(m_pDisplay, xAtom(XA_XdndSelection), None, CurrentTime);
822
823	/* Clear any other DnD specific data on the proxy window. */
824	wndXDnDClearFormatList(m_wndProxy.hWnd);
825	wndXDnDClearActionList(m_wndProxy.hWnd);
826
827	m_lstAtomActions.clear();
828
829	/* First, clear the formats list and apply the X11-specific default formats,
830	* required for making Xdnd to work. */
831	m_lstAtomFormats.clear();
832	m_lstAtomFormats.append(m_lstAtomFormatsX11);
833
834	m_wndCur = 0;
835	m_uXdndVer = 0;
836	m_lastMouseX = -1;
837	m_lastMouseY = -1;
838	m_enmState = Initialized;
839	m_enmMode = Unknown;
840	m_cFailedPendingAttempts = 0;
841
842	/* Reset the selection request buffer. */
843	if (m_pvSelReqData)
844	{
845	RTMemFree(m_pvSelReqData);
846	m_pvSelReqData = NULL;
847
848	Assert(m_cbSelReqData);
849	m_cbSelReqData = 0;
850	}
851
852	rc2 = RTCritSectEnter(&m_eventQueueCS);
853	if (RT_SUCCESS(rc2))
854	{
855	m_eventQueueList.clear();
856
857	rc2 = RTCritSectLeave(&m_eventQueueCS);
858	AssertRC(rc2);
859	}
860
861	RTCritSectLeave(&m_dataCS);
862	}
863
864	LogFlowFuncLeave();
865	}
866
867	/**
868	* Initializes this drag instance.
869	*
870	* @return IPRT status code.
871	* @param uScreenID X' screen ID to use.
872	*/
873	int DragInstance::init(uint32_t uScreenID)
874	{
875	int rc = VbglR3DnDConnect(&m_dndCtx);
876	/* Note: Can return VINF_PERMISSION_DENIED if HGCM host service is not available. */
877	if (rc != VINF_SUCCESS)
878	return rc;
879
880	if (g_cVerbosity)
881	{
882	RTCString strBody = RTCStringFmt("Connected (screen %RU32, verbosity %u)", uScreenID, g_cVerbosity);
883	VBClShowNotify(VBOX_DND_SHOWNOTIFY_HEADER, strBody.c_str());
884	}
885
886	do
887	{
888	rc = RTSemEventCreate(&m_eventQueueEvent);
889	if (RT_FAILURE(rc))
890	break;
891
892	rc = RTCritSectInit(&m_eventQueueCS);
893	if (RT_FAILURE(rc))
894	break;
895
896	rc = RTCritSectInit(&m_dataCS);
897	if (RT_FAILURE(rc))
898	break;
899
900	/*
901	* Enough screens configured in the x11 server?
902	*/
903	if ((int)uScreenID > ScreenCount(m_pDisplay))
904	{
905	rc = VERR_INVALID_PARAMETER;
906	break;
907	}
908	#if 0
909	/* Get the screen number from the x11 server. */
910	pDrag->screen = ScreenOfDisplay(m_pDisplay, uScreenID);
911	if (!pDrag->screen)
912	{
913	rc = VERR_GENERAL_FAILURE;
914	break;
915	}
916	#endif
917	m_screenID = uScreenID;
918
919	/* Now query the corresponding root window of this screen. */
920	m_wndRoot = RootWindow(m_pDisplay, m_screenID);
921	if (!m_wndRoot)
922	{
923	rc = VERR_GENERAL_FAILURE;
924	break;
925	}
926
927	/*
928	* Create an invisible window which will act as proxy for the DnD
929	* operation. This window will be used for both the GH and HG
930	* direction.
931	*/
932	XSetWindowAttributes attr;
933	RT_ZERO(attr);
934	attr.event_mask = EnterWindowMask \| LeaveWindowMask
935	\| ButtonMotionMask \| ButtonPressMask \| ButtonReleaseMask;
936	attr.override_redirect = True;
937	attr.do_not_propagate_mask = NoEventMask;
938
939	if (g_cVerbosity >= 3)
940	{
941	attr.background_pixel = XWhitePixel(m_pDisplay, m_screenID);
942	attr.border_pixel = XBlackPixel(m_pDisplay, m_screenID);
943	m_wndProxy.hWnd = XCreateWindow(m_pDisplay, m_wndRoot /* Parent */,
944	100, 100, /* Position */
945	100, 100, /* Width + height */
946	2, /* Border width */
947	CopyFromParent, /* Depth */
948	InputOutput, /* Class */
949	CopyFromParent, /* Visual */
950	CWBackPixel
951	\| CWBorderPixel
952	\| CWOverrideRedirect
953	\| CWDontPropagate, /* Value mask */
954	&attr); /* Attributes for value mask */
955	}
956
957	m_wndProxy.hWnd = XCreateWindow(m_pDisplay, m_wndRoot /* Parent */,
958	0, 0, /* Position */
959	1, 1, /* Width + height */
960	0, /* Border width */
961	CopyFromParent, /* Depth */
962	InputOnly, /* Class */
963	CopyFromParent, /* Visual */
964	CWOverrideRedirect \| CWDontPropagate, /* Value mask */
965	&attr); /* Attributes for value mask */
966
967	if (!m_wndProxy.hWnd)
968	{
969	VBClLogError("Error creating proxy window\n");
970	rc = VERR_GENERAL_FAILURE;
971	break;
972	}
973
974	rc = m_wndProxy.init(m_pDisplay);
975	if (RT_FAILURE(rc))
976	{
977	VBClLogError("Error initializing proxy window, rc=%Rrc\n", rc);
978	break;
979	}
980
981	if (g_cVerbosity >= 3) /* Make debug window visible. */
982	{
983	XFlush(m_pDisplay);
984	XMapWindow(m_pDisplay, m_wndProxy.hWnd);
985	XRaiseWindow(m_pDisplay, m_wndProxy.hWnd);
986	XFlush(m_pDisplay);
987	}
988
989	VBClLogInfo("Proxy window=%#x (debug mode: %RTbool), root window=%#x ...\n",
990	m_wndProxy.hWnd, RT_BOOL(g_cVerbosity >= 3), m_wndRoot);
991
992	/* Set the window's name for easier lookup. */
993	XStoreName(m_pDisplay, m_wndProxy.hWnd, "VBoxClientWndDnD");
994
995	/* Make the new window Xdnd aware. */
996	Atom atmVer = VBOX_XDND_VERSION;
997	XChangeProperty(m_pDisplay, m_wndProxy.hWnd, xAtom(XA_XdndAware), XA_ATOM, 32, PropModeReplace,
998	reinterpret_cast<unsigned char*>(&atmVer), 1);
999	} while (0);
1000
1001	if (RT_SUCCESS(rc))
1002	{
1003	reset();
1004	}
1005	else
1006	VBClLogError("Initializing drag instance for screen %RU32 failed with rc=%Rrc\n", uScreenID, rc);
1007
1008	LogFlowFuncLeaveRC(rc);
1009	return rc;
1010	}
1011
1012	/**
1013	* Callback handler for a generic client message from a window.
1014	*
1015	* @return IPRT status code.
1016	* @param e X11 event to handle.
1017	*/
1018	int DragInstance::onX11ClientMessage(const XEvent &e)
1019	{
1020	AssertReturn(e.type == ClientMessage, VERR_INVALID_PARAMETER);
1021
1022	LogFlowThisFunc(("mode=%RU32, state=%RU32\n", m_enmMode, m_enmState));
1023	LogFlowThisFunc(("Event wnd=%#x, msg=%s\n", e.xclient.window, xAtomToString(e.xclient.message_type).c_str()));
1024
1025	int rc = VINF_SUCCESS;
1026
1027	char *pszWndCurName = wndX11GetNameA(m_wndCur);
1028	AssertPtrReturn(pszWndCurName, VERR_NO_MEMORY);
1029
1030	switch (m_enmMode)
1031	{
1032	case HG:
1033	{
1034	/*
1035	* Client messages are used to inform us about the status of a XdndAware
1036	* window, in response of some events we send to them.
1037	*/
1038
1039	/* The target window informs us of the current Xdnd status. */
1040	if (e.xclient.message_type == xAtom(XA_XdndStatus))
1041	{
1042	Window wndTgt = static_cast<Window>(e.xclient.data.l[XdndStatusWindow]);
1043
1044	char *pszWndTgtName = wndX11GetNameA(wndTgt);
1045	AssertPtrBreakStmt(pszWndTgtName, VERR_NO_MEMORY);
1046
1047	/* Does the target accept the drop? */
1048	bool const fAcceptDrop = RT_BOOL(e.xclient.data.l[XdndStatusFlags] & VBOX_XDND_STATUS_FLAG_ACCEPT);
1049	/* Does the target want XdndPosition messages? */
1050	bool const fWantsPosition = RT_BOOL(e.xclient.data.l[XdndStatusFlags] & VBOX_XDND_STATUS_FLAG_WANTS_POS);
1051
1052	/*
1053	* The XdndStatus message tell us if the window will accept the DnD
1054	* event and with which action. We immediately send this info down to
1055	* the host as a response of a previous DnD message.
1056	*/
1057	RTCString strActions = xAtomToString(e.xclient.data.l[XdndStatusAction]);
1058
1059	VBClLogInfo("Target window %#x ('%s')\n", wndTgt, pszWndTgtName);
1060	VBClLogInfo(" - %s accept data (actions '%s')\n", fAcceptDrop ? "does" : "does not", strActions.c_str());
1061	VBClLogInfo(" - %s want position messages\n", fWantsPosition ? "does" : "does not");
1062
1063	uint16_t const x = RT_HI_U16((uint32_t)e.xclient.data.l[XdndStatusNoMsgXY]);
1064	uint16_t const y = RT_LO_U16((uint32_t)e.xclient.data.l[XdndStatusNoMsgXY]);
1065	uint16_t const cx = RT_HI_U16((uint32_t)e.xclient.data.l[XdndStatusNoMsgWH]);
1066	uint16_t const cy = RT_LO_U16((uint32_t)e.xclient.data.l[XdndStatusNoMsgWH]);
1067
1068	if (cx && cy)
1069	{
1070	VBClLogInfo("Target window %#x ('%s') reported dead area at %RU16,%RU16 (%RU16 x %RU16)\n",
1071	wndTgt, pszWndTgtName, x, y, cx, cy);
1072	/** @todo Save dead area and don't send XdndPosition messages anymore into it. */
1073	}
1074
1075	if (m_wndCur == wndTgt)
1076	{
1077	VBOXDNDACTION dndAction = VBOX_DND_ACTION_IGNORE; /* Default is ignoring. */
1078	/** @todo Compare this with the allowed actions. */
1079	if (fAcceptDrop)
1080	dndAction = toHGCMAction(static_cast<Atom>(e.xclient.data.l[XdndStatusAction]));
1081
1082	rc = VbglR3DnDHGSendAckOp(&m_dndCtx, dndAction);
1083	}
1084	else
1085	VBClLogInfo("Target window %#x ('%s') is not our current window, skipping\n", wndTgt, pszWndTgtName);
1086
1087	RTStrFree(pszWndTgtName);
1088	}
1089	/* The target window informs us that it finished the Xdnd operation and that we may free all data. */
1090	else if (e.xclient.message_type == xAtom(XA_XdndFinished))
1091	{
1092	Window wndTarget = static_cast<Window>(e.xclient.data.l[XdndFinishedWindow]);
1093
1094	char *pszWndTgtName = wndX11GetNameA(wndTarget);
1095	AssertPtrBreakStmt(pszWndTgtName, VERR_NO_MEMORY);
1096
1097	if (m_uXdndVer >= 5)
1098	{
1099	const bool fSucceeded = e.xclient.data.l[XdndFinishedFlags] & VBOX_XDND_FINISHED_FLAG_SUCCEEDED;
1100	#if 0 /** @todo Returns garbage -- investigate this! */
1101	//const char *pcszAction = fSucceeded ? xAtomToString(e.xclient.data.l[XdndFinishedAction]).c_str() : NULL;
1102	#endif
1103	VBClLogInfo("Target window %#x ('%s') has %s the data\n",
1104	wndTarget, pszWndTgtName, fSucceeded ? "accepted" : "rejected");
1105	}
1106	else /* Xdnd < version 5 did not have the XdndFinishedFlags / XdndFinishedAction properties. */
1107	VBClLogInfo("Target window %#x ('%s') has accepted the data\n", wndTarget, pszWndTgtName);
1108
1109	RTStrFree(pszWndTgtName);
1110
1111	reset();
1112	}
1113	else
1114	{
1115	LogFlowThisFunc(("Unhandled client message '%s'\n", xAtomToString(e.xclient.message_type).c_str()));
1116	rc = VERR_NOT_SUPPORTED;
1117	}
1118
1119	break;
1120	}
1121
1122	case Unknown: /* Mode not set (yet). */
1123	RT_FALL_THROUGH();
1124	case GH:
1125	{
1126	/*
1127	* This message marks the beginning of a new drag and drop
1128	* operation on the guest.
1129	*/
1130	if (e.xclient.message_type == xAtom(XA_XdndEnter))
1131	{
1132	/*
1133	* Get the window which currently has the XA_XdndSelection
1134	* bit set.
1135	*/
1136	Window wndSel = XGetSelectionOwner(m_pDisplay, xAtom(XA_XdndSelection));
1137	char *pszWndSelName = wndX11GetNameA(wndSel);
1138	AssertPtrBreakStmt(pszWndSelName, VERR_NO_MEMORY);
1139
1140	mouseButtonSet(m_wndProxy.hWnd, -1, -1, 1, true /* fPress */);
1141
1142	/*
1143	* Update our state and the window handle to process.
1144	*/
1145	rc = RTCritSectEnter(&m_dataCS);
1146	if (RT_SUCCESS(rc))
1147	{
1148	uint8_t const uXdndVer = (uint8_t)e.xclient.data.l[XdndEnterFlags] >> XdndEnterVersionRShift;
1149
1150	VBClLogInfo("Entered new source window %#x ('%s'), supports Xdnd version %u\n", wndSel, pszWndSelName, uXdndVer);
1151	#ifdef DEBUG
1152	XWindowAttributes xwa;
1153	XGetWindowAttributes(m_pDisplay, m_wndCur, &xwa);
1154	LogFlowThisFunc(("wndCur=%#x, x=%d, y=%d, width=%d, height=%d\n", m_wndCur, xwa.x, xwa.y, xwa.width, xwa.height));
1155	#endif
1156	/*
1157	* Retrieve supported formats.
1158	*/
1159
1160	/* Check if the MIME types are in the message itself or if we need
1161	* to fetch the XdndTypeList property from the window. */
1162	bool fMoreTypes = e.xclient.data.l[XdndEnterFlags] & XdndEnterMoreTypesFlag;
1163	if (!fMoreTypes)
1164	{
1165	/* Only up to 3 format types supported. */
1166	/* Start with index 2 (first item). */
1167	for (int i = 2; i < 5; i++)
1168	{
1169	LogFlowThisFunc(("\t%s\n", gX11->xAtomToString(e.xclient.data.l[i]).c_str()));
1170	m_lstAtomFormats.append(e.xclient.data.l[i]);
1171	}
1172	}
1173	else
1174	{
1175	/* More than 3 format types supported. */
1176	rc = wndXDnDGetFormatList(wndSel, m_lstAtomFormats);
1177	}
1178
1179	if (RT_FAILURE(rc))
1180	{
1181	VBClLogError("Error retrieving supported formats, rc=%Rrc\n", rc);
1182	break;
1183	}
1184
1185	/*
1186	* Retrieve supported actions.
1187	*/
1188	if (uXdndVer >= 2) /* More than one action allowed since protocol version 2. */
1189	{
1190	rc = wndXDnDGetActionList(wndSel, m_lstAtomActions);
1191	}
1192	else /* Only "copy" action allowed on legacy applications. */
1193	m_lstAtomActions.append(XA_XdndActionCopy);
1194
1195	if (RT_FAILURE(rc))
1196	{
1197	VBClLogError("Error retrieving supported actions, rc=%Rrc\n", rc);
1198	break;
1199	}
1200
1201	VBClLogInfo("Source window %#x ('%s')\n", wndSel, pszWndSelName);
1202	VBClLogInfo(" - supports the formats ");
1203	for (size_t i = 0; i < m_lstAtomFormats.size(); i++)
1204	{
1205	if (i > 0)
1206	VBClLogInfo(", ");
1207	VBClLogInfo("%s", gX11->xAtomToString(m_lstAtomFormats[i]).c_str());
1208	}
1209	VBClLogInfo("\n");
1210	VBClLogInfo(" - supports the actions ");
1211	for (size_t i = 0; i < m_lstAtomActions.size(); i++)
1212	{
1213	if (i > 0)
1214	VBClLogInfo(", ");
1215	VBClLogInfo("%s", gX11->xAtomToString(m_lstAtomActions[i]).c_str());
1216	}
1217	VBClLogInfo("\n");
1218
1219	AssertBreakStmt(wndSel == (Window)e.xclient.data.l[XdndEnterWindow],
1220	rc = VERR_INVALID_PARAMETER); /* Source window. */
1221
1222	m_wndCur = wndSel;
1223	m_uXdndVer = uXdndVer;
1224	m_enmMode = GH;
1225	m_enmState = Dragging;
1226
1227	RTCritSectLeave(&m_dataCS);
1228	}
1229
1230	RTStrFree(pszWndSelName);
1231	}
1232	else if ( e.xclient.message_type == xAtom(XA_XdndPosition)
1233	&& m_wndCur == static_cast<Window>(e.xclient.data.l[XdndPositionWindow]))
1234	{
1235	if (m_enmState != Dragging) /* Wrong mode? Bail out. */
1236	{
1237	reset();
1238	break;
1239	}
1240	#ifdef LOG_ENABLED
1241	int32_t iPos = e.xclient.data.l[XdndPositionXY];
1242	Atom atmAction = m_uXdndVer >= 2 /* Actions other than "copy" or only supported since protocol version 2. */
1243	? e.xclient.data.l[XdndPositionAction] : xAtom(XA_XdndActionCopy);
1244	LogFlowThisFunc(("XA_XdndPosition: wndProxy=%#x, wndCur=%#x, x=%RI32, y=%RI32, strAction=%s\n",
1245	m_wndProxy.hWnd, m_wndCur, RT_HIWORD(iPos), RT_LOWORD(iPos),
1246	xAtomToString(atmAction).c_str()));
1247	#endif
1248	bool fAcceptDrop = true;
1249
1250	/* Reply with a XdndStatus message to tell the source whether
1251	* the data can be dropped or not. */
1252	XClientMessageEvent m;
1253	RT_ZERO(m);
1254	m.type = ClientMessage;
1255	m.display = m_pDisplay;
1256	m.window = e.xclient.data.l[XdndPositionWindow];
1257	m.message_type = xAtom(XA_XdndStatus);
1258	m.format = 32;
1259	m.data.l[XdndStatusWindow] = m_wndProxy.hWnd;
1260	m.data.l[XdndStatusFlags] = fAcceptDrop ? VBOX_XDND_STATUS_FLAG_ACCEPT : VBOX_XDND_STATUS_FLAG_NONE; /* Whether to accept the drop or not. */
1261
1262	/* We don't want any new XA_XdndPosition messages while being
1263	* in our proxy window. */
1264	m.data.l[XdndStatusNoMsgXY] = RT_MAKE_U32(m_wndProxy.iY, m_wndProxy.iX);
1265	m.data.l[XdndStatusNoMsgWH] = RT_MAKE_U32(m_wndProxy.iHeight, m_wndProxy.iWidth);
1266
1267	/** @todo Handle default action! */
1268	m.data.l[XdndStatusAction] = fAcceptDrop ? toAtomAction(VBOX_DND_ACTION_COPY) : None;
1269
1270	int xRc = XSendEvent(m_pDisplay, e.xclient.data.l[XdndPositionWindow],
1271	False /* Propagate /, NoEventMask, reinterpret_cast<XEvent >(&m));
1272	if (xRc == 0)
1273	VBClLogError("Error sending position status event to current window %#x ('%s'): %s\n",
1274	m_wndCur, pszWndCurName, gX11->xErrorToString(xRc).c_str());
1275	}
1276	else if ( e.xclient.message_type == xAtom(XA_XdndLeave)
1277	&& m_wndCur == static_cast<Window>(e.xclient.data.l[XdndLeaveWindow]))
1278	{
1279	LogFlowThisFunc(("XA_XdndLeave\n"));
1280	VBClLogInfo("Guest to host transfer canceled by the guest source window\n");
1281
1282	/* Start over. */
1283	reset();
1284	}
1285	else if ( e.xclient.message_type == xAtom(XA_XdndDrop)
1286	&& m_wndCur == static_cast<Window>(e.xclient.data.l[XdndDropWindow]))
1287	{
1288	LogFlowThisFunc(("XA_XdndDrop\n"));
1289
1290	if (m_enmState != Dropped) /* Wrong mode? Bail out. */
1291	{
1292	/* Can occur when dragging from guest->host, but then back in to the guest again. */
1293	VBClLogInfo("Could not drop on own proxy window\n"); /* Not fatal. */
1294
1295	/* Let the source know. */
1296	rc = m_wndProxy.sendFinished(m_wndCur, VBOX_DND_ACTION_IGNORE);
1297
1298	/* Start over. */
1299	reset();
1300	break;
1301	}
1302
1303	m_eventQueueList.append(e);
1304	rc = RTSemEventSignal(m_eventQueueEvent);
1305	}
1306	else /* Unhandled event, abort. */
1307	{
1308	VBClLogInfo("Unhandled event from wnd=%#x, msg=%s\n", e.xclient.window, xAtomToString(e.xclient.message_type).c_str());
1309
1310	/* Let the source know. */
1311	rc = m_wndProxy.sendFinished(m_wndCur, VBOX_DND_ACTION_IGNORE);
1312
1313	/* Start over. */
1314	reset();
1315	}
1316	break;
1317	}
1318
1319	default:
1320	{
1321	AssertMsgFailed(("Drag and drop mode not implemented: %RU32\n", m_enmMode));
1322	rc = VERR_NOT_IMPLEMENTED;
1323	break;
1324	}
1325	}
1326
1327	RTStrFree(pszWndCurName);
1328
1329	LogFlowThisFunc(("Returning rc=%Rrc\n", rc));
1330	return rc;
1331	}
1332
1333	int DragInstance::onX11MotionNotify(const XEvent &e)
1334	{
1335	RT_NOREF1(e);
1336	LogFlowThisFunc(("mode=%RU32, state=%RU32\n", m_enmMode, m_enmState));
1337
1338	return VINF_SUCCESS;
1339	}
1340
1341	/**
1342	* Callback handler for being notified if some other window now
1343	* is the owner of the current selection.
1344	*
1345	* @return IPRT status code.
1346	* @param e X11 event to handle.
1347	*
1348	* @remark
1349	*/
1350	int DragInstance::onX11SelectionClear(const XEvent &e)
1351	{
1352	RT_NOREF1(e);
1353	LogFlowThisFunc(("mode=%RU32, state=%RU32\n", m_enmMode, m_enmState));
1354
1355	return VINF_SUCCESS;
1356	}
1357
1358	/**
1359	* Callback handler for a XDnD selection notify from a window. This is needed
1360	* to let the us know if a certain window has drag'n drop data to share with us,
1361	* e.g. our proxy window.
1362	*
1363	* @return IPRT status code.
1364	* @param e X11 event to handle.
1365	*/
1366	int DragInstance::onX11SelectionNotify(const XEvent &e)
1367	{
1368	AssertReturn(e.type == SelectionNotify, VERR_INVALID_PARAMETER);
1369
1370	LogFlowThisFunc(("mode=%RU32, state=%RU32\n", m_enmMode, m_enmState));
1371
1372	int rc;
1373
1374	switch (m_enmMode)
1375	{
1376	case GH:
1377	{
1378	if (m_enmState == Dropped)
1379	{
1380	m_eventQueueList.append(e);
1381	rc = RTSemEventSignal(m_eventQueueEvent);
1382	}
1383	else
1384	rc = VERR_WRONG_ORDER;
1385	break;
1386	}
1387
1388	default:
1389	{
1390	LogFlowThisFunc(("Unhandled: wnd=%#x, msg=%s\n",
1391	e.xclient.data.l[0], xAtomToString(e.xclient.message_type).c_str()));
1392	rc = VERR_INVALID_STATE;
1393	break;
1394	}
1395	}
1396
1397	LogFlowThisFunc(("Returning rc=%Rrc\n", rc));
1398	return rc;
1399	}
1400
1401	/**
1402	* Callback handler for a XDnD selection request from a window. This is needed
1403	* to retrieve the data required to complete the actual drag'n drop operation.
1404	*
1405	* @returns IPRT status code.
1406	* @param evReq X11 event to handle.
1407	*/
1408	int DragInstance::onX11SelectionRequest(const XEvent &evReq)
1409	{
1410	AssertReturn(evReq.type == SelectionRequest, VERR_INVALID_PARAMETER);
1411
1412	const XSelectionRequestEvent *pEvReq = &evReq.xselectionrequest;
1413
1414	char *pszWndSrcName = wndX11GetNameA(pEvReq->owner);
1415	AssertPtrReturn(pszWndSrcName, VERR_INVALID_POINTER);
1416	char *pszWndTgtName = wndX11GetNameA(pEvReq->requestor);
1417	AssertPtrReturn(pszWndTgtName, VERR_INVALID_POINTER);
1418
1419	LogFlowThisFunc(("mode=%RU32, state=%RU32\n", m_enmMode, m_enmState));
1420	LogFlowThisFunc(("Event owner=%#x ('%s'), requestor=%#x ('%s'), selection=%s, target=%s, prop=%s, time=%u\n",
1421	pEvReq->owner, pszWndSrcName,
1422	pEvReq->requestor, pszWndTgtName,
1423	xAtomToString(pEvReq->selection).c_str(),
1424	xAtomToString(pEvReq->target).c_str(),
1425	xAtomToString(pEvReq->property).c_str(),
1426	pEvReq->time));
1427
1428	VBClLogInfo("Window '%s' is asking '%s' for '%s' / '%s'\n",
1429	pszWndTgtName, pszWndSrcName, xAtomToString(pEvReq->selection).c_str(), xAtomToString(pEvReq->property).c_str());
1430
1431	RTStrFree(pszWndSrcName);
1432	/* Note: pszWndTgtName will be free'd below. */
1433
1434	int rc;
1435
1436	switch (m_enmMode)
1437	{
1438	case HG:
1439	{
1440	rc = VINF_SUCCESS;
1441
1442	/*
1443	* Start by creating a refusal selection notify message.
1444	* That way we only need to care for the success case.
1445	*/
1446
1447	XEvent evResp;
1448	RT_ZERO(evResp);
1449
1450	XSelectionEvent *pEvResp = &evResp.xselection;
1451
1452	pEvResp->type = SelectionNotify;
1453	pEvResp->display = pEvReq->display;
1454	pEvResp->requestor = pEvReq->requestor;
1455	pEvResp->selection = pEvReq->selection;
1456	pEvResp->target = pEvReq->target;
1457	pEvResp->property = None; /* "None" means refusal. */
1458	pEvResp->time = pEvReq->time;
1459
1460	if (g_cVerbosity)
1461	{
1462	VBClLogVerbose(1, "Supported formats by VBoxClient:\n");
1463	for (size_t i = 0; i < m_lstAtomFormats.size(); i++)
1464	VBClLogVerbose(1, "\t%s\n", xAtomToString(m_lstAtomFormats.at(i)).c_str());
1465	}
1466
1467	/* Is the requestor asking for the possible MIME types? */
1468	if (pEvReq->target == xAtom(XA_TARGETS))
1469	{
1470	VBClLogInfo("Target window %#x ('%s') asking for target list\n", pEvReq->requestor, pszWndTgtName);
1471
1472	/* If so, set the window property with the formats on the requestor
1473	* window. */
1474	rc = wndXDnDSetFormatList(pEvReq->requestor, pEvReq->property, m_lstAtomFormats);
1475	if (RT_SUCCESS(rc))
1476	pEvResp->property = pEvReq->property;
1477	}
1478	/* Is the requestor asking for a specific MIME type (we support)? */
1479	else if (m_lstAtomFormats.contains(pEvReq->target))
1480	{
1481	VBClLogInfo("Target window %#x ('%s') is asking for data as '%s'\n",
1482	pEvReq->requestor, pszWndTgtName, xAtomToString(pEvReq->target).c_str());
1483
1484	#ifdef VBOX_WITH_DRAG_AND_DROP_PROMISES
1485	# error "Implement me!"
1486	#else
1487	/* Did we not drop our stuff to the guest yet? Bail out. */
1488	if (m_enmState != Dropped)
1489	{
1490	VBClLogError("Data not dropped by the host on the guest yet (client state %RU32, mode %RU32), refusing selection request by guest\n",
1491	m_enmState, m_enmMode);
1492	}
1493	/* Did we not store the requestor's initial selection request yet? Then do so now. */
1494	else
1495	{
1496	#endif /* VBOX_WITH_DRAG_AND_DROP_PROMISES */
1497	/* Get the data format the requestor wants from us. */
1498	VBClLogInfo("Target window %#x ('%s') requested data from host as '%s', rc=%Rrc\n",
1499	pEvReq->requestor, pszWndTgtName, xAtomToString(pEvReq->target).c_str(), rc);
1500
1501	/* Make a copy of the MIME data to be passed back. The X server will be become
1502	* the new owner of that data, so no deletion needed. */
1503	/** @todo Do we need to do some more conversion here? XConvertSelection? */
1504	AssertMsgBreakStmt(m_pvSelReqData != NULL, ("Selection request data is NULL\n"), rc = VERR_INVALID_PARAMETER);
1505	AssertMsgBreakStmt(m_cbSelReqData > 0, ("Selection request data size is 0\n"), rc = VERR_INVALID_PARAMETER);
1506
1507	void const *pvData = RTMemDup(m_pvSelReqData, m_cbSelReqData);
1508	AssertMsgBreakStmt(pvData != NULL, ("Duplicating selection request failed\n"), rc = VERR_NO_MEMORY);
1509	uint32_t const cbData = m_cbSelReqData;
1510
1511	/* Always return the requested property. */
1512	evResp.xselection.property = pEvReq->property;
1513
1514	/* Note: Always seems to return BadRequest. Seems fine. */
1515	int xRc = XChangeProperty(pEvResp->display, pEvResp->requestor, pEvResp->property,
1516	pEvResp->target, 8, PropModeReplace,
1517	reinterpret_cast<const unsigned char*>(pvData), cbData);
1518
1519	LogFlowFunc(("Changing property '%s' (of type '%s') of window %#x ('%s'): %s\n",
1520	xAtomToString(pEvReq->property).c_str(),
1521	xAtomToString(pEvReq->target).c_str(),
1522	pEvReq->requestor, pszWndTgtName,
1523	gX11->xErrorToString(xRc).c_str()));
1524	RT_NOREF(xRc);
1525	#ifndef VBOX_WITH_DRAG_AND_DROP_PROMISES
1526	}
1527	#endif
1528	}
1529	/* Anything else. */
1530	else
1531	{
1532	VBClLogError("Refusing unknown command/format '%s' of wnd=%#x ('%s')\n",
1533	xAtomToString(pEvReq->target).c_str(), pEvReq->requestor, pszWndTgtName);
1534	rc = VERR_NOT_SUPPORTED;
1535	}
1536
1537	VBClLogVerbose(1, "Offering type '%s', property '%s' to window %#x ('%s') ...\n",
1538	xAtomToString(pEvReq->target).c_str(),
1539	xAtomToString(pEvReq->property).c_str(), pEvReq->requestor, pszWndTgtName);
1540
1541	int xRc = XSendEvent(pEvReq->display, pEvReq->requestor, True /* Propagate */, 0, &evResp);
1542	if (xRc == 0)
1543	VBClLogError("Error sending SelectionNotify(1) event to window %#x ('%s'): %s\n",
1544	pEvReq->requestor, pszWndTgtName, gX11->xErrorToString(xRc).c_str());
1545
1546	XFlush(pEvReq->display);
1547	break;
1548	}
1549
1550	default:
1551	rc = VERR_INVALID_STATE;
1552	break;
1553	}
1554
1555	RTStrFree(pszWndTgtName);
1556	pszWndTgtName = NULL;
1557
1558	LogFlowThisFunc(("Returning rc=%Rrc\n", rc));
1559	return rc;
1560	}
1561
1562	/**
1563	* Handles X11 events, called by x11EventThread.
1564	*
1565	* @returns IPRT status code.
1566	* @param e X11 event to handle.
1567	*/
1568	int DragInstance::onX11Event(const XEvent &e)
1569	{
1570	int rc;
1571
1572	LogFlowThisFunc(("X11 event, type=%d\n", e.type));
1573	switch (e.type)
1574	{
1575	/*
1576	* This can happen if a guest->host drag operation
1577	* goes back from the host to the guest. This is not what
1578	* we want and thus resetting everything.
1579	*/
1580	case ButtonPress:
1581	RT_FALL_THROUGH();
1582	case ButtonRelease:
1583	{
1584	VBClLogInfo("Mouse button %s\n", e.type == ButtonPress ? "pressed" : "released");
1585
1586	reset();
1587
1588	rc = VINF_SUCCESS;
1589	break;
1590	}
1591
1592	case ClientMessage:
1593	rc = onX11ClientMessage(e);
1594	break;
1595
1596	case SelectionClear:
1597	rc = onX11SelectionClear(e);
1598	break;
1599
1600	case SelectionNotify:
1601	rc = onX11SelectionNotify(e);
1602	break;
1603
1604	case SelectionRequest:
1605	rc = onX11SelectionRequest(e);
1606	break;
1607
1608	case MotionNotify:
1609	rc = onX11MotionNotify(e);
1610	break;
1611
1612	default:
1613	rc = VERR_NOT_IMPLEMENTED;
1614	break;
1615	}
1616
1617	LogFlowThisFunc(("rc=%Rrc\n", rc));
1618	return rc;
1619	}
1620
1621	int DragInstance::waitForStatusChange(uint32_t enmState, RTMSINTERVAL uTimeoutMS /* = 30000 */)
1622	{
1623	const uint64_t uiStart = RTTimeMilliTS();
1624	volatile uint32_t enmCurState;
1625
1626	int rc = VERR_TIMEOUT;
1627
1628	LogFlowFunc(("enmState=%RU32, uTimeoutMS=%RU32\n", enmState, uTimeoutMS));
1629
1630	do
1631	{
1632	enmCurState = ASMAtomicReadU32(&m_enmState);
1633	if (enmCurState == enmState)
1634	{
1635	rc = VINF_SUCCESS;
1636	break;
1637	}
1638	}
1639	while (RTTimeMilliTS() - uiStart < uTimeoutMS);
1640
1641	LogFlowThisFunc(("Returning %Rrc\n", rc));
1642	return rc;
1643	}
1644
1645	#ifdef VBOX_WITH_DRAG_AND_DROP_GH
1646	/**
1647	* Waits for an X11 event of a specific type.
1648	*
1649	* @returns IPRT status code.
1650	* @param evX Reference where to store the event into.
1651	* @param iType Event type to wait for.
1652	* @param uTimeoutMS Timeout (in ms) to wait for the event.
1653	*/
1654	bool DragInstance::waitForX11Msg(XEvent &evX, int iType, RTMSINTERVAL uTimeoutMS /* = 100 */)
1655	{
1656	LogFlowThisFunc(("iType=%d, uTimeoutMS=%RU32, cEventQueue=%zu\n", iType, uTimeoutMS, m_eventQueueList.size()));
1657
1658	bool fFound = false;
1659	uint64_t const tsStartMs = RTTimeMilliTS();
1660
1661	do
1662	{
1663	/* Check if there is a client message in the queue. */
1664	for (size_t i = 0; i < m_eventQueueList.size(); i++)
1665	{
1666	int rc2 = RTCritSectEnter(&m_eventQueueCS);
1667	if (RT_SUCCESS(rc2))
1668	{
1669	XEvent e = m_eventQueueList.at(i).m_Event;
1670
1671	fFound = e.type == iType;
1672	if (fFound)
1673	{
1674	m_eventQueueList.removeAt(i);
1675	evX = e;
1676	}
1677
1678	rc2 = RTCritSectLeave(&m_eventQueueCS);
1679	AssertRC(rc2);
1680
1681	if (fFound)
1682	break;
1683	}
1684	}
1685
1686	if (fFound)
1687	break;
1688
1689	int rc2 = RTSemEventWait(m_eventQueueEvent, 25 /* ms */);
1690	if ( RT_FAILURE(rc2)
1691	&& rc2 != VERR_TIMEOUT)
1692	{
1693	LogFlowFunc(("Waiting failed with rc=%Rrc\n", rc2));
1694	break;
1695	}
1696	}
1697	while (RTTimeMilliTS() - tsStartMs < uTimeoutMS);
1698
1699	LogFlowThisFunc(("Returning fFound=%RTbool, msRuntime=%RU64\n", fFound, RTTimeMilliTS() - tsStartMs));
1700	return fFound;
1701	}
1702
1703	/**
1704	* Waits for an X11 client message of a specific type.
1705	*
1706	* @returns IPRT status code.
1707	* @param evMsg Reference where to store the event into.
1708	* @param aType Event type to wait for.
1709	* @param uTimeoutMS Timeout (in ms) to wait for the event.
1710	*/
1711	bool DragInstance::waitForX11ClientMsg(XClientMessageEvent &evMsg, Atom aType,
1712	RTMSINTERVAL uTimeoutMS /* = 100 */)
1713	{
1714	LogFlowThisFunc(("aType=%s, uTimeoutMS=%RU32, cEventQueue=%zu\n",
1715	xAtomToString(aType).c_str(), uTimeoutMS, m_eventQueueList.size()));
1716
1717	bool fFound = false;
1718	const uint64_t uiStart = RTTimeMilliTS();
1719	do
1720	{
1721	/* Check if there is a client message in the queue. */
1722	for (size_t i = 0; i < m_eventQueueList.size(); i++)
1723	{
1724	int rc2 = RTCritSectEnter(&m_eventQueueCS);
1725	if (RT_SUCCESS(rc2))
1726	{
1727	XEvent e = m_eventQueueList.at(i).m_Event;
1728	if ( e.type == ClientMessage
1729	&& e.xclient.message_type == aType)
1730	{
1731	m_eventQueueList.removeAt(i);
1732	evMsg = e.xclient;
1733
1734	fFound = true;
1735	}
1736
1737	if (e.type == ClientMessage)
1738	{
1739	LogFlowThisFunc(("Client message: Type=%ld (%s)\n",
1740	e.xclient.message_type, xAtomToString(e.xclient.message_type).c_str()));
1741	}
1742	else
1743	LogFlowThisFunc(("X message: Type=%d\n", e.type));
1744
1745	rc2 = RTCritSectLeave(&m_eventQueueCS);
1746	AssertRC(rc2);
1747
1748	if (fFound)
1749	break;
1750	}
1751	}
1752
1753	if (fFound)
1754	break;
1755
1756	int rc2 = RTSemEventWait(m_eventQueueEvent, 25 /* ms */);
1757	if ( RT_FAILURE(rc2)
1758	&& rc2 != VERR_TIMEOUT)
1759	{
1760	LogFlowFunc(("Waiting failed with rc=%Rrc\n", rc2));
1761	break;
1762	}
1763	}
1764	while (RTTimeMilliTS() - uiStart < uTimeoutMS);
1765
1766	LogFlowThisFunc(("Returning fFound=%RTbool, msRuntime=%RU64\n", fFound, RTTimeMilliTS() - uiStart));
1767	return fFound;
1768	}
1769	#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
1770
1771	/*
1772	* Host -> Guest
1773	*/
1774
1775	/**
1776	* Host -> Guest: Event signalling that the host's (mouse) cursor just entered the VM's (guest's) display
1777	* area.
1778	*
1779	* @returns IPRT status code.
1780	* @param lstFormats List of supported formats from the host.
1781	* @param dndListActionsAllowed (ORed) List of supported actions from the host.
1782	*/
1783	int DragInstance::hgEnter(const RTCList<RTCString> &lstFormats, uint32_t dndListActionsAllowed)
1784	{
1785	LogFlowThisFunc(("mode=%RU32, state=%RU32\n", m_enmMode, m_enmState));
1786
1787	if (m_enmMode != Unknown)
1788	return VERR_INVALID_STATE;
1789
1790	reset();
1791
1792	#ifdef DEBUG
1793	LogFlowThisFunc(("dndListActionsAllowed=0x%x, lstFormats=%zu: ", dndListActionsAllowed, lstFormats.size()));
1794	for (size_t i = 0; i < lstFormats.size(); ++i)
1795	LogFlow(("'%s' ", lstFormats.at(i).c_str()));
1796	LogFlow(("\n"));
1797	#endif
1798
1799	int rc;
1800
1801	do
1802	{
1803	/* Check if the VM session has changed and reconnect to the HGCM service if necessary. */
1804	rc = checkForSessionChange();
1805	AssertRCBreak(rc);
1806
1807	/* Append all actual (MIME) formats we support to the list.
1808	* These must come last, after the default Atoms above. */
1809	rc = appendFormatsToList(lstFormats, m_lstAtomFormats);
1810	AssertRCBreak(rc);
1811
1812	rc = wndXDnDSetFormatList(m_wndProxy.hWnd, xAtom(XA_XdndTypeList), m_lstAtomFormats);
1813	AssertRCBreak(rc);
1814
1815	/* Announce the possible actions. */
1816	VBoxDnDAtomList lstActions;
1817	rc = toAtomActions(dndListActionsAllowed, lstActions);
1818	AssertRCBreak(rc);
1819
1820	rc = wndXDnDSetActionList(m_wndProxy.hWnd, lstActions);
1821	AssertRCBreak(rc);
1822
1823	/* Set the DnD selection owner to our window. */
1824	/** @todo Don't use CurrentTime -- according to ICCCM section 2.1. */
1825	XSetSelectionOwner(m_pDisplay, xAtom(XA_XdndSelection), m_wndProxy.hWnd, CurrentTime);
1826
1827	if (g_cVerbosity)
1828	{
1829	RTCString strMsg("Enter: Host -> Guest\n");
1830	strMsg += RTCStringFmt("Allowed actions: ");
1831	for (size_t i = 0; i < lstActions.size(); i++)
1832	{
1833	if (i > 0)
1834	strMsg += ", ";
1835	strMsg += DnDActionToStr(toHGCMAction(lstActions.at(i)));
1836	}
1837	strMsg += " - Formats: ";
1838	for (size_t i = 0; i < lstFormats.size(); i++)
1839	{
1840	if (i > 0)
1841	strMsg += ", ";
1842	strMsg += lstFormats.at(i);
1843	}
1844
1845	VBClShowNotify(VBOX_DND_SHOWNOTIFY_HEADER, strMsg.c_str());
1846	}
1847
1848	m_enmMode = HG;
1849	m_enmState = Dragging;
1850
1851	} while (0);
1852
1853	LogFlowFuncLeaveRC(rc);
1854	return rc;
1855	}
1856
1857	/**
1858	* Host -> Guest: Event signalling that the host's (mouse) cursor has left the VM's (guest's)
1859	* display area.
1860	*/
1861	int DragInstance::hgLeave(void)
1862	{
1863	if (g_cVerbosity)
1864	VBClShowNotify(VBOX_DND_SHOWNOTIFY_HEADER, "Leave: Host -> Guest");
1865
1866	if (m_enmMode == HG) /* Only reset if in the right operation mode. */
1867	reset();
1868
1869	return VINF_SUCCESS;
1870	}
1871
1872	/**
1873	* Host -> Guest: Event signalling that the host's (mouse) cursor has been moved within the VM's
1874	* (guest's) display area.
1875	*
1876	* @returns IPRT status code.
1877	* @param uPosX Relative X position within the guest's display area.
1878	* @param uPosY Relative Y position within the guest's display area.
1879	* @param dndActionDefault Default action the host wants to perform on the guest
1880	* as soon as the operation successfully finishes.
1881	*/
1882	int DragInstance::hgMove(uint32_t uPosX, uint32_t uPosY, VBOXDNDACTION dndActionDefault)
1883	{
1884	LogFlowThisFunc(("mode=%RU32, state=%RU32\n", m_enmMode, m_enmState));
1885	LogFlowThisFunc(("uPosX=%RU32, uPosY=%RU32, dndActionDefault=0x%x\n", uPosX, uPosY, dndActionDefault));
1886
1887	if ( m_enmMode != HG
1888	\|\| m_enmState != Dragging)
1889	{
1890	return VERR_INVALID_STATE;
1891	}
1892
1893	int rc = VINF_SUCCESS;
1894	int xRc = Success;
1895
1896	/* Move the mouse cursor within the guest. */
1897	mouseCursorMove(uPosX, uPosY);
1898
1899	/* Search for the application window below the cursor. */
1900	Window wndBelowCursor = gX11->applicationWindowBelowCursor(m_wndRoot);
1901	char *pszWndBelowCursorName = wndX11GetNameA(wndBelowCursor);
1902	AssertPtrReturn(pszWndBelowCursorName, VERR_NO_MEMORY);
1903
1904	uint8_t uBelowCursorXdndVer = 0; /* 0 means the current window is _not_ XdndAware. */
1905
1906	if (wndBelowCursor != None)
1907	{
1908	/* Temp stuff for the XGetWindowProperty call. */
1909	Atom atmTmp;
1910	int fmt;
1911	unsigned long cItems, cbRemaining;
1912	unsigned char *pcData = NULL;
1913
1914	/* Query the XdndAware property from the window. We are interested in
1915	* the version and if it is XdndAware at all. */
1916	xRc = XGetWindowProperty(m_pDisplay, wndBelowCursor, xAtom(XA_XdndAware),
1917	0, 2, False, AnyPropertyType,
1918	&atmTmp, &fmt, &cItems, &cbRemaining, &pcData);
1919	if (xRc != Success)
1920	{
1921	VBClLogError("Error getting properties of cursor window=%#x: %s\n", wndBelowCursor, gX11->xErrorToString(xRc).c_str());
1922	}
1923	else
1924	{
1925	if (pcData == NULL \|\| fmt != 32 \|\| cItems != 1)
1926	{
1927	/** @todo Do we need to deal with this? */
1928	VBClLogError("Wrong window properties for window %#x: pcData=%#x, iFmt=%d, cItems=%ul\n",
1929	wndBelowCursor, pcData, fmt, cItems);
1930	}
1931	else
1932	{
1933	/* Get the current window's Xdnd version. */
1934	uBelowCursorXdndVer = (uint8_t)reinterpret_cast<long *>(pcData)[0];
1935	}
1936
1937	XFree(pcData);
1938	}
1939	}
1940
1941	char *pszWndCurName = wndX11GetNameA(m_wndCur);
1942	AssertPtrReturn(pszWndCurName, VERR_NO_MEMORY);
1943
1944	LogFlowThisFunc(("wndCursor=%x ('%s', Xdnd version %u), wndCur=%x ('%s', Xdnd version %u)\n",
1945	wndBelowCursor, pszWndBelowCursorName, uBelowCursorXdndVer, m_wndCur, pszWndCurName, m_uXdndVer));
1946
1947	if ( wndBelowCursor != m_wndCur
1948	&& m_uXdndVer)
1949	{
1950	VBClLogInfo("Left old window %#x ('%s'), supported Xdnd version %u\n", m_wndCur, pszWndCurName, m_uXdndVer);
1951
1952	/* We left the current XdndAware window. Announce this to the current indow. */
1953	XClientMessageEvent m;
1954	RT_ZERO(m);
1955	m.type = ClientMessage;
1956	m.display = m_pDisplay;
1957	m.window = m_wndCur;
1958	m.message_type = xAtom(XA_XdndLeave);
1959	m.format = 32;
1960	m.data.l[XdndLeaveWindow] = m_wndProxy.hWnd;
1961
1962	xRc = XSendEvent(m_pDisplay, m_wndCur, False, NoEventMask, reinterpret_cast<XEvent*>(&m));
1963	if (xRc == 0)
1964	VBClLogError("Error sending leave event to old window %#x: %s\n", m_wndCur, gX11->xErrorToString(xRc).c_str());
1965
1966	/* Reset our current window. */
1967	m_wndCur = 0;
1968	m_uXdndVer = 0;
1969	}
1970
1971	/*
1972	* Do we have a new Xdnd-aware window which now is under the cursor?
1973	*/
1974	if ( wndBelowCursor != m_wndCur
1975	&& uBelowCursorXdndVer)
1976	{
1977	VBClLogInfo("Entered new window %#x ('%s'), supports Xdnd version=%u\n",
1978	wndBelowCursor, pszWndBelowCursorName, uBelowCursorXdndVer);
1979
1980	/*
1981	* We enter a new window. Announce the XdndEnter event to the new
1982	* window. The first three mime types are attached to the event (the
1983	* others could be requested by the XdndTypeList property from the
1984	* window itself).
1985	*/
1986	XClientMessageEvent m;
1987	RT_ZERO(m);
1988	m.type = ClientMessage;
1989	m.display = m_pDisplay;
1990	m.window = wndBelowCursor;
1991	m.message_type = xAtom(XA_XdndEnter);
1992	m.format = 32;
1993	m.data.l[XdndEnterWindow] = m_wndProxy.hWnd;
1994	m.data.l[XdndEnterFlags] = RT_MAKE_U32_FROM_U8(
1995	/* Bit 0 is set if the source supports more than three data types. */
1996	m_lstAtomFormats.size() > 3 ? RT_BIT(0) : 0,
1997	/* Reserved for future use. */
1998	0, 0,
1999	/* Protocol version to use. */
2000	RT_MIN(VBOX_XDND_VERSION, uBelowCursorXdndVer));
2001	m.data.l[XdndEnterType1] = m_lstAtomFormats.value(0, None); /* First data type to use. */
2002	m.data.l[XdndEnterType2] = m_lstAtomFormats.value(1, None); /* Second data type to use. */
2003	m.data.l[XdndEnterType3] = m_lstAtomFormats.value(2, None); /* Third data type to use. */
2004
2005	xRc = XSendEvent(m_pDisplay, wndBelowCursor, False, NoEventMask, reinterpret_cast<XEvent*>(&m));
2006	if (xRc == 0)
2007	VBClLogError("Error sending enter event to window %#x: %s\n", wndBelowCursor, gX11->xErrorToString(xRc).c_str());
2008	}
2009
2010	if (uBelowCursorXdndVer)
2011	{
2012	Assert(wndBelowCursor != None);
2013
2014	Atom atmAction = toAtomAction(dndActionDefault);
2015	LogFlowThisFunc(("strAction=%s\n", xAtomToString(atmAction).c_str()));
2016
2017	VBClLogInfo("Sent position event (%RU32 x %RU32) to window %#x ('%s') with actions '%s'\n",
2018	uPosX, uPosY, wndBelowCursor, pszWndBelowCursorName, xAtomToString(atmAction).c_str());
2019
2020	/*
2021	* Send a XdndPosition event with the proposed action to the guest.
2022	*/
2023	XClientMessageEvent m;
2024	RT_ZERO(m);
2025	m.type = ClientMessage;
2026	m.display = m_pDisplay;
2027	m.window = wndBelowCursor;
2028	m.message_type = xAtom(XA_XdndPosition);
2029	m.format = 32;
2030	m.data.l[XdndPositionWindow] = m_wndProxy.hWnd; /* X window ID of source window. */
2031	m.data.l[XdndPositionFlags] = 0; /* Reserved, set to 0. */
2032	m.data.l[XdndPositionXY] = RT_MAKE_U32(uPosY, uPosX); /* Cursor coordinates relative to the root window. */
2033	m.data.l[XdndPositionTimeStamp] = CurrentTime; /* Timestamp for retrieving data. */
2034	m.data.l[XdndPositionAction] = atmAction; /* Actions requested by the user. */
2035
2036	xRc = XSendEvent(m_pDisplay, wndBelowCursor, False, NoEventMask, reinterpret_cast<XEvent*>(&m));
2037	if (xRc == 0)
2038	VBClLogError("Error sending position event to current window %#x: %s\n", wndBelowCursor, gX11->xErrorToString(xRc).c_str());
2039	}
2040
2041	if (uBelowCursorXdndVer == 0)
2042	{
2043	/* No window to process, so send a ignore ack event to the host. */
2044	rc = VbglR3DnDHGSendAckOp(&m_dndCtx, VBOX_DND_ACTION_IGNORE);
2045	}
2046	else
2047	{
2048	Assert(wndBelowCursor != None);
2049
2050	m_wndCur = wndBelowCursor;
2051	m_uXdndVer = uBelowCursorXdndVer;
2052	}
2053
2054	RTStrFree(pszWndBelowCursorName);
2055	RTStrFree(pszWndCurName);
2056
2057	LogFlowFuncLeaveRC(rc);
2058	return rc;
2059	}
2060
2061	/**
2062	* Host -> Guest: Event signalling that the host has dropped the data over the VM (guest) window.
2063	*
2064	* @returns IPRT status code.
2065	* @param uPosX Relative X position within the guest's display area.
2066	* @param uPosY Relative Y position within the guest's display area.
2067	* @param dndActionDefault Default action the host wants to perform on the guest
2068	* as soon as the operation successfully finishes.
2069	*/
2070	int DragInstance::hgDrop(uint32_t uPosX, uint32_t uPosY, VBOXDNDACTION dndActionDefault)
2071	{
2072	RT_NOREF3(uPosX, uPosY, dndActionDefault);
2073	LogFlowThisFunc(("wndCur=%RU32, wndProxy=%RU32, mode=%RU32, state=%RU32\n", m_wndCur, m_wndProxy.hWnd, m_enmMode, m_enmState));
2074	LogFlowThisFunc(("uPosX=%RU32, uPosY=%RU32, dndActionDefault=0x%x\n", uPosX, uPosY, dndActionDefault));
2075
2076	if ( m_enmMode != HG
2077	\|\| m_enmState != Dragging)
2078	{
2079	return VERR_INVALID_STATE;
2080	}
2081
2082	/* Set the state accordingly. */
2083	m_enmState = Dropped;
2084
2085	/*
2086	* Ask the host to send the raw data, as we don't (yet) know which format
2087	* the guest exactly expects. As blocking in a SelectionRequest message turned
2088	* out to be very unreliable (e.g. with KDE apps) we request to start transferring
2089	* file/directory data (if any) here.
2090	*/
2091	char szFormat[] = { "text/uri-list" };
2092
2093	int rc = VbglR3DnDHGSendReqData(&m_dndCtx, szFormat);
2094	VBClLogInfo("Drop event from host resulted in: %Rrc\n", rc);
2095
2096	if (g_cVerbosity)
2097	VBClShowNotify(VBOX_DND_SHOWNOTIFY_HEADER, "Drop: Host -> Guest");
2098
2099	LogFlowFuncLeaveRC(rc);
2100	return rc;
2101	}
2102
2103	/**
2104	* Host -> Guest: Event signalling that the host has finished sending drag'n drop
2105	* data to the guest for further processing.
2106	*
2107	* @returns IPRT status code.
2108	* @param pMeta Pointer to meta data from host.
2109	*/
2110	int DragInstance::hgDataReceive(PVBGLR3GUESTDNDMETADATA pMeta)
2111	{
2112	LogFlowThisFunc(("enmMode=%RU32, enmState=%RU32\n", m_enmMode, m_enmState));
2113	LogFlowThisFunc(("enmMetaType=%RU32\n", pMeta->enmType));
2114
2115	if ( m_enmMode != HG
2116	\|\| m_enmState != Dropped)
2117	{
2118	return VERR_INVALID_STATE;
2119	}
2120
2121	void *pvData = NULL;
2122	size_t cbData = 0;
2123
2124	int rc = VINF_SUCCESS; /* Shut up GCC. */
2125
2126	switch (pMeta->enmType)
2127	{
2128	case VBGLR3GUESTDNDMETADATATYPE_RAW:
2129	{
2130	AssertBreakStmt(pMeta->u.Raw.pvMeta != NULL, rc = VERR_INVALID_POINTER);
2131	pvData = pMeta->u.Raw.pvMeta;
2132	AssertBreakStmt(pMeta->u.Raw.cbMeta, rc = VERR_INVALID_PARAMETER);
2133	cbData = pMeta->u.Raw.cbMeta;
2134
2135	rc = VINF_SUCCESS;
2136	break;
2137	}
2138
2139	case VBGLR3GUESTDNDMETADATATYPE_URI_LIST:
2140	{
2141	const char *pcszRootPath = DnDTransferListGetRootPathAbs(&pMeta->u.URI.Transfer);
2142	AssertPtrBreakStmt(pcszRootPath, VERR_INVALID_POINTER);
2143
2144	VBClLogInfo("Transfer list root directory is '%s'\n", pcszRootPath);
2145
2146	/* Note: Use the URI format here, as X' DnD spec says so. */
2147	rc = DnDTransferListGetRootsEx(&pMeta->u.URI.Transfer, DNDTRANSFERLISTFMT_URI, pcszRootPath,
2148	DND_PATH_SEPARATOR_STR, (char **)&pvData, &cbData);
2149	break;
2150	}
2151
2152	default:
2153	AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
2154	break;
2155	}
2156
2157	if (RT_FAILURE(rc))
2158	return rc;
2159
2160	/*
2161	* At this point all data needed (including sent files/directories) should
2162	* be on the guest, so proceed working on communicating with the target window.
2163	*/
2164	VBClLogInfo("Received %RU32 bytes of meta data from host\n", cbData);
2165
2166	/* Destroy any old data. */
2167	if (m_pvSelReqData)
2168	{
2169	Assert(m_cbSelReqData);
2170
2171	RTMemFree(m_pvSelReqData); /** @todo RTMemRealloc? */
2172	m_cbSelReqData = 0;
2173	}
2174
2175	/** @todo Handle incremental transfers. */
2176
2177	/* Make a copy of the data. This data later then will be used to fill into
2178	* the selection request. */
2179	if (cbData)
2180	{
2181	m_pvSelReqData = RTMemAlloc(cbData);
2182	if (!m_pvSelReqData)
2183	return VERR_NO_MEMORY;
2184
2185	memcpy(m_pvSelReqData, pvData, cbData);
2186	m_cbSelReqData = cbData;
2187	}
2188
2189	/*
2190	* Send a drop event to the current window (target).
2191	* This window in turn then will raise a SelectionRequest message to our proxy window,
2192	* which we will handle in our onX11SelectionRequest handler.
2193	*
2194	* The SelectionRequest will tell us in which format the target wants the data from the host.
2195	*/
2196	XClientMessageEvent m;
2197	RT_ZERO(m);
2198	m.type = ClientMessage;
2199	m.display = m_pDisplay;
2200	m.window = m_wndCur;
2201	m.message_type = xAtom(XA_XdndDrop);
2202	m.format = 32;
2203	m.data.l[XdndDropWindow] = m_wndProxy.hWnd; /* Source window. */
2204	m.data.l[XdndDropFlags] = 0; /* Reserved for future use. */
2205	m.data.l[XdndDropTimeStamp] = CurrentTime; /* Our DnD data does not rely on any timing, so just use the current time. */
2206
2207	int xRc = XSendEvent(m_pDisplay, m_wndCur, False /* Propagate /, NoEventMask, reinterpret_cast<XEvent>(&m));
2208	if (xRc == 0)
2209	VBClLogError("Error sending XA_XdndDrop event to window=%#x: %s\n", m_wndCur, gX11->xErrorToString(xRc).c_str());
2210	XFlush(m_pDisplay);
2211
2212	LogFlowFuncLeaveRC(rc);
2213	return rc;
2214	}
2215
2216	/**
2217	* Checks if the VM session has changed (can happen when restoring the VM from a saved state)
2218	* and do a reconnect to the DnD HGCM service.
2219	*
2220	* @returns IPRT status code.
2221	*/
2222	int DragInstance::checkForSessionChange(void)
2223	{
2224	uint64_t uSessionID;
2225	int rc = VbglR3GetSessionId(&uSessionID);
2226	if ( RT_SUCCESS(rc)
2227	&& uSessionID != m_dndCtx.uSessionID)
2228	{
2229	LogFlowThisFunc(("VM session has changed to %RU64\n", uSessionID));
2230
2231	rc = VbglR3DnDDisconnect(&m_dndCtx);
2232	AssertRC(rc);
2233
2234	rc = VbglR3DnDConnect(&m_dndCtx);
2235	AssertRC(rc);
2236	}
2237
2238	LogFlowFuncLeaveRC(rc);
2239	return rc;
2240	}
2241
2242	#ifdef VBOX_WITH_DRAG_AND_DROP_GH
2243	/**
2244	* Guest -> Host: Event signalling that the host is asking whether there is a pending
2245	* drag event on the guest (to the host).
2246	*
2247	* @returns IPRT status code.
2248	*/
2249	int DragInstance::ghIsDnDPending(void)
2250	{
2251	LogFlowThisFunc(("mode=%RU32, state=%RU32\n", m_enmMode, m_enmState));
2252
2253	int rc;
2254
2255	RTCString strFormats = DND_PATH_SEPARATOR_STR; /** @todo If empty, IOCTL fails with VERR_ACCESS_DENIED. */
2256	VBOXDNDACTION dndActionDefault = VBOX_DND_ACTION_IGNORE;
2257	VBOXDNDACTIONLIST dndActionList = VBOX_DND_ACTION_IGNORE;
2258
2259	/* Currently in wrong mode? Bail out. */
2260	if (m_enmMode == HG)
2261	{
2262	rc = VERR_INVALID_STATE;
2263	}
2264	/* Message already processed successfully? */
2265	else if ( m_enmMode == GH
2266	&& ( m_enmState == Dragging
2267	\|\| m_enmState == Dropped)
2268	)
2269	{
2270	/* No need to query for the source window again. */
2271	rc = VINF_SUCCESS;
2272	}
2273	else
2274	{
2275	/* Check if the VM session has changed and reconnect to the HGCM service if necessary. */
2276	rc = checkForSessionChange();
2277
2278	/* Determine the current window which currently has the XdndSelection set. */
2279	Window wndSel = XGetSelectionOwner(m_pDisplay, xAtom(XA_XdndSelection));
2280	LogFlowThisFunc(("wndSel=%#x, wndProxy=%#x, wndCur=%#x\n", wndSel, m_wndProxy.hWnd, m_wndCur));
2281
2282	/* Is this another window which has a Xdnd selection and not our proxy window? */
2283	if ( RT_SUCCESS(rc)
2284	&& wndSel
2285	&& wndSel != m_wndCur)
2286	{
2287	char *pszWndSelName = wndX11GetNameA(wndSel);
2288	AssertPtrReturn(pszWndSelName, VERR_NO_MEMORY);
2289	VBClLogInfo("New guest source window %#x ('%s')\n", wndSel, pszWndSelName);
2290
2291	/* Start over. */
2292	reset();
2293
2294	/* Map the window on the current cursor position, which should provoke
2295	* an XdndEnter event. */
2296	rc = proxyWinShow();
2297	if (RT_SUCCESS(rc))
2298	{
2299	rc = mouseCursorFakeMove();
2300	if (RT_SUCCESS(rc))
2301	{
2302	bool fWaitFailed = false; /* Waiting for status changed failed? */
2303
2304	/* Wait until we're in "Dragging" state. */
2305	rc = waitForStatusChange(Dragging, 100 /* 100ms timeout */);
2306
2307	/*
2308	* Note: Don't wait too long here, as this mostly will make
2309	* the drag and drop experience on the host being laggy
2310	* and unresponsive.
2311	*
2312	* Instead, let the host query multiple times with 100ms
2313	* timeout each (see above) and only report an error if
2314	* the overall querying time has been exceeded.<
2315	*/
2316	if (RT_SUCCESS(rc))
2317	{
2318	m_enmMode = GH;
2319	}
2320	else if (rc == VERR_TIMEOUT)
2321	{
2322	/** @todo Make m_cFailedPendingAttempts configurable. For slower window managers? */
2323	if (m_cFailedPendingAttempts++ > 50) /* Tolerate up to 5s total (100ms for each slot). */
2324	fWaitFailed = true;
2325	else
2326	rc = VINF_SUCCESS;
2327	}
2328	else if (RT_FAILURE(rc))
2329	fWaitFailed = true;
2330
2331	if (fWaitFailed)
2332	{
2333	VBClLogError("Error mapping proxy window to guest source window %#x ('%s'), rc=%Rrc\n",
2334	wndSel, pszWndSelName, rc);
2335
2336	/* Reset the counter in any case. */
2337	m_cFailedPendingAttempts = 0;
2338	}
2339	}
2340	}
2341
2342	RTStrFree(pszWndSelName);
2343	}
2344	else
2345	VBClLogInfo("No guest source window\n");
2346	}
2347
2348	/*
2349	* Acknowledge to the host in any case, regardless
2350	* if something failed here or not. Be responsive.
2351	*/
2352
2353	int rc2 = RTCritSectEnter(&m_dataCS);
2354	if (RT_SUCCESS(rc2))
2355	{
2356	/* Filter out the default X11-specific formats (required for Xdnd, 'TARGET' / 'MULTIPLE');
2357	* those will not be supported by VirtualBox. */
2358	VBoxDnDAtomList const lstAtomFormatsFiltered = gX11->xAtomListFiltered(m_lstAtomFormats, m_lstAtomFormatsX11);
2359
2360	/* Anything left to report to the host? */
2361	if (lstAtomFormatsFiltered.size())
2362	{
2363	strFormats = gX11->xAtomListToString(lstAtomFormatsFiltered);
2364	dndActionDefault = VBOX_DND_ACTION_COPY; /** @todo Handle default action! */
2365	dndActionList = VBOX_DND_ACTION_COPY; /** @todo Ditto. */
2366	dndActionList \|= toHGCMActions(m_lstAtomActions);
2367	}
2368
2369	RTCritSectLeave(&m_dataCS);
2370	}
2371
2372	if (g_cVerbosity)
2373	{
2374	char *pszActions = DnDActionListToStrA(dndActionList);
2375	AssertPtrReturn(pszActions, VERR_NO_MEMORY);
2376	VBClLogVerbose(1, "Reporting formats '%s' (actions '%s' / %#x, default action is '%s' (%#x)\n",
2377	strFormats.c_str(), pszActions, dndActionList, DnDActionToStr(dndActionDefault), dndActionDefault);
2378	RTStrFree(pszActions);
2379	}
2380
2381	rc2 = VbglR3DnDGHSendAckPending(&m_dndCtx, dndActionDefault, dndActionList,
2382	strFormats.c_str(), strFormats.length() + 1 /* Include termination */);
2383	LogFlowThisFunc(("uClientID=%RU32, dndActionDefault=0x%x, dndActionList=0x%x, strFormats=%s, rc=%Rrc\n",
2384	m_dndCtx.uClientID, dndActionDefault, dndActionList, strFormats.c_str(), rc2));
2385	if (RT_FAILURE(rc2))
2386	{
2387	switch (rc2)
2388	{
2389	case VERR_ACCESS_DENIED:
2390	{
2391	rc = VBClShowNotify(VBOX_DND_SHOWNOTIFY_HEADER,
2392	"Drag and drop to the host either is not supported or disabled. "
2393	"Please enable Guest to Host or Bidirectional drag and drop mode "
2394	"or re-install the VirtualBox Guest Additions.");
2395	AssertRC(rc);
2396	break;
2397	}
2398
2399	default:
2400	break;
2401	}
2402
2403	VBClLogError("Error reporting pending drag and drop operation status to host: %Rrc\n", rc2);
2404	if (RT_SUCCESS(rc))
2405	rc = rc2;
2406	}
2407
2408	LogFlowFuncLeaveRC(rc);
2409	return rc;
2410	}
2411
2412	/**
2413	* Guest -> Host: Event signalling that the host has dropped the item(s) on the
2414	* host side.
2415	*
2416	* @returns IPRT status code.
2417	* @param strFormat Requested format to send to the host.
2418	* @param dndActionRequested Requested action to perform on the guest.
2419	*/
2420	int DragInstance::ghDropped(const RTCString &strFormat, VBOXDNDACTION dndActionRequested)
2421	{
2422	LogFlowThisFunc(("mode=%RU32, state=%RU32, strFormat=%s, dndActionRequested=0x%x\n",
2423	m_enmMode, m_enmState, strFormat.c_str(), dndActionRequested));
2424
2425	/* Currently in wrong mode? Bail out. */
2426	if ( m_enmMode == Unknown
2427	\|\| m_enmMode == HG)
2428	{
2429	return VERR_INVALID_STATE;
2430	}
2431
2432	if ( m_enmMode == GH
2433	&& m_enmState != Dragging)
2434	{
2435	return VERR_INVALID_STATE;
2436	}
2437
2438	int rc = VINF_SUCCESS;
2439
2440	m_enmState = Dropped;
2441
2442	#ifdef DEBUG
2443	XWindowAttributes xwa;
2444	XGetWindowAttributes(m_pDisplay, m_wndCur, &xwa);
2445	LogFlowThisFunc(("wndProxy=%RU32, wndCur=%RU32, x=%d, y=%d, width=%d, height=%d\n",
2446	m_wndProxy.hWnd, m_wndCur, xwa.x, xwa.y, xwa.width, xwa.height));
2447
2448	Window wndSelection = XGetSelectionOwner(m_pDisplay, xAtom(XA_XdndSelection));
2449	LogFlowThisFunc(("wndSelection=%#x\n", wndSelection));
2450	#endif
2451
2452	/* We send a fake mouse move event to the current window, cause
2453	* this should have the grab. */
2454	mouseCursorFakeMove();
2455
2456	/**
2457	* The fake button release event above should lead to a XdndDrop event from the
2458	* source window. Because of showing our proxy window, other Xdnd events can
2459	* occur before, e.g. a XdndPosition event. We are not interested
2460	* in those, so just try to get the right one.
2461	*/
2462
2463	XClientMessageEvent evDnDDrop;
2464	bool fDrop = waitForX11ClientMsg(evDnDDrop, xAtom(XA_XdndDrop), 5 * 1000 /* 5s timeout */);
2465	if (fDrop)
2466	{
2467	LogFlowThisFunc(("XA_XdndDrop\n"));
2468
2469	/* Request to convert the selection in the specific format and
2470	* place it to our proxy window as property. */
2471	Assert(evDnDDrop.message_type == xAtom(XA_XdndDrop));
2472
2473	Window wndSource = evDnDDrop.data.l[XdndDropWindow]; /* Source window which has sent the message. */
2474	Assert(wndSource == m_wndCur);
2475
2476	Atom aFormat = gX11->stringToxAtom(strFormat.c_str());
2477
2478	Time tsDrop;
2479	if (m_uXdndVer >= 1)
2480	tsDrop = evDnDDrop.data.l[XdndDropTimeStamp];
2481	else
2482	tsDrop = CurrentTime;
2483
2484	XConvertSelection(m_pDisplay, xAtom(XA_XdndSelection), aFormat, xAtom(XA_XdndSelection),
2485	m_wndProxy.hWnd, tsDrop);
2486
2487	/* Wait for the selection notify event. */
2488	XEvent evSelNotify;
2489	RT_ZERO(evSelNotify);
2490	if (waitForX11Msg(evSelNotify, SelectionNotify, 5 * 1000 /* 5s timeout */))
2491	{
2492	bool fCancel = false;
2493
2494	/* Make some paranoid checks. */
2495	if ( evSelNotify.xselection.type == SelectionNotify
2496	&& evSelNotify.xselection.display == m_pDisplay
2497	&& evSelNotify.xselection.selection == xAtom(XA_XdndSelection)
2498	&& evSelNotify.xselection.requestor == m_wndProxy.hWnd
2499	&& evSelNotify.xselection.target == aFormat)
2500	{
2501	LogFlowThisFunc(("Selection notfiy (from wnd=%#x)\n", m_wndCur));
2502
2503	Atom aPropType;
2504	int iPropFormat;
2505	unsigned long cItems, cbRemaining;
2506	unsigned char *pcData = NULL;
2507	int xRc = XGetWindowProperty(m_pDisplay, m_wndProxy.hWnd,
2508	xAtom(XA_XdndSelection) /* Property */,
2509	0 /* Offset */,
2510	VBOX_MAX_XPROPERTIES /* Length of 32-bit multiples */,
2511	True /* Delete property? */,
2512	AnyPropertyType, /* Property type */
2513	&aPropType, &iPropFormat, &cItems, &cbRemaining, &pcData);
2514	if (xRc != Success)
2515	VBClLogError("Error getting XA_XdndSelection property of proxy window=%#x: %s\n",
2516	m_wndProxy.hWnd, gX11->xErrorToString(xRc).c_str());
2517
2518	LogFlowThisFunc(("strType=%s, iPropFormat=%d, cItems=%RU32, cbRemaining=%RU32\n",
2519	gX11->xAtomToString(aPropType).c_str(), iPropFormat, cItems, cbRemaining));
2520
2521	if ( aPropType != None
2522	&& pcData != NULL
2523	&& iPropFormat >= 8
2524	&& cItems > 0
2525	&& cbRemaining == 0)
2526	{
2527	size_t cbData = cItems * (iPropFormat / 8);
2528	LogFlowThisFunc(("cbData=%zu\n", cbData));
2529
2530	/* For whatever reason some of the string MIME types are not
2531	* zero terminated. Check that and correct it when necessary,
2532	* because the guest side wants this in any case. */
2533	if ( m_lstAllowedFormats.contains(strFormat)
2534	&& pcData[cbData - 1] != '\0')
2535	{
2536	unsigned char pvDataTmp = static_cast<unsigned char>(RTMemAlloc(cbData + 1));
2537	if (pvDataTmp)
2538	{
2539	memcpy(pvDataTmp, pcData, cbData);
2540	pvDataTmp[cbData++] = '\0';
2541
2542	rc = VbglR3DnDGHSendData(&m_dndCtx, strFormat.c_str(), pvDataTmp, cbData);
2543	RTMemFree(pvDataTmp);
2544	}
2545	else
2546	rc = VERR_NO_MEMORY;
2547	}
2548	else
2549	{
2550	/* Send the raw data to the host. */
2551	rc = VbglR3DnDGHSendData(&m_dndCtx, strFormat.c_str(), pcData, cbData);
2552	LogFlowThisFunc(("Sent strFormat=%s, rc=%Rrc\n", strFormat.c_str(), rc));
2553	}
2554
2555	if (RT_SUCCESS(rc))
2556	{
2557	rc = m_wndProxy.sendFinished(wndSource, dndActionRequested);
2558	}
2559	else
2560	fCancel = true;
2561	}
2562	else
2563	{
2564	if (aPropType == xAtom(XA_INCR))
2565	{
2566	/** @todo Support incremental transfers. */
2567	AssertMsgFailed(("Incremental transfers are not supported yet\n"));
2568
2569	VBClLogError("Incremental transfers are not supported yet\n");
2570	rc = VERR_NOT_IMPLEMENTED;
2571	}
2572	else
2573	{
2574	VBClLogError("Not supported data type: %s\n", gX11->xAtomToString(aPropType).c_str());
2575	rc = VERR_NOT_SUPPORTED;
2576	}
2577
2578	fCancel = true;
2579	}
2580
2581	if (fCancel)
2582	{
2583	VBClLogInfo("Cancelling dropping to host\n");
2584
2585	/* Cancel the operation -- inform the source window by
2586	* sending a XdndFinished message so that the source can toss the required data. */
2587	rc = m_wndProxy.sendFinished(wndSource, VBOX_DND_ACTION_IGNORE);
2588	}
2589
2590	/* Cleanup. */
2591	if (pcData)
2592	XFree(pcData);
2593	}
2594	else
2595	rc = VERR_INVALID_PARAMETER;
2596	}
2597	else
2598	rc = VERR_TIMEOUT;
2599	}
2600	else
2601	rc = VERR_TIMEOUT;
2602
2603	/* Inform the host on error. */
2604	if (RT_FAILURE(rc))
2605	{
2606	int rc2 = VbglR3DnDSendError(&m_dndCtx, rc);
2607	LogFlowThisFunc(("Sending error %Rrc to host resulted in %Rrc\n", rc, rc2)); RT_NOREF(rc2);
2608	/* This is not fatal for us, just ignore. */
2609	}
2610
2611	/* At this point, we have either successfully transfered any data or not.
2612	* So reset our internal state because we are done here for the current (ongoing)
2613	* drag and drop operation. */
2614	reset();
2615
2616	LogFlowFuncLeaveRC(rc);
2617	return rc;
2618	}
2619	#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
2620
2621	/*
2622	* Helpers
2623	*/
2624
2625	/**
2626	* Fakes moving the mouse cursor to provoke various drag and drop
2627	* events such as entering a target window or moving within a
2628	* source window.
2629	*
2630	* Not the most elegant and probably correct function, but does
2631	* the work for now.
2632	*
2633	* @returns IPRT status code.
2634	*/
2635	int DragInstance::mouseCursorFakeMove(void)
2636	{
2637	int iScreenID = XDefaultScreen(m_pDisplay);
2638	/** @todo What about multiple screens? Test this! */
2639
2640	const int iScrX = XDisplayWidth(m_pDisplay, iScreenID);
2641	const int iScrY = XDisplayHeight(m_pDisplay, iScreenID);
2642
2643	int fx, fy, rx, ry;
2644	Window wndTemp, wndChild;
2645	int wx, wy; unsigned int mask;
2646	XQueryPointer(m_pDisplay, m_wndRoot, &wndTemp, &wndChild, &rx, &ry, &wx, &wy, &mask);
2647
2648	/*
2649	* Apply some simple clipping and change the position slightly.
2650	*/
2651
2652	/* FakeX */
2653	if (rx == 0) fx = 1;
2654	else if (rx == iScrX) fx = iScrX - 1;
2655	else fx = rx + 1;
2656
2657	/* FakeY */
2658	if (ry == 0) fy = 1;
2659	else if (ry == iScrY) fy = iScrY - 1;
2660	else fy = ry + 1;
2661
2662	/*
2663	* Move the cursor to trigger the wanted events.
2664	*/
2665	LogFlowThisFunc(("cursorRootX=%d, cursorRootY=%d\n", fx, fy));
2666	int rc = mouseCursorMove(fx, fy);
2667	if (RT_SUCCESS(rc))
2668	{
2669	/* Move the cursor back to its original position. */
2670	rc = mouseCursorMove(rx, ry);
2671	}
2672
2673	return rc;
2674	}
2675
2676	/**
2677	* Moves the mouse pointer to a specific position.
2678	*
2679	* @returns IPRT status code.
2680	* @param iPosX Absolute X coordinate.
2681	* @param iPosY Absolute Y coordinate.
2682	*/
2683	int DragInstance::mouseCursorMove(int iPosX, int iPosY)
2684	{
2685	int const iScreenID = XDefaultScreen(m_pDisplay);
2686	/** @todo What about multiple screens? Test this! */
2687
2688	int const iScreenWidth = XDisplayWidth (m_pDisplay, iScreenID);
2689	int const iScreenHeight = XDisplayHeight(m_pDisplay, iScreenID);
2690
2691	iPosX = RT_CLAMP(iPosX, 0, iScreenWidth);
2692	iPosY = RT_CLAMP(iPosY, 0, iScreenHeight);
2693
2694	/* Same mouse position as before? No need to do anything. */
2695	if ( m_lastMouseX == iPosX
2696	&& m_lastMouseY == iPosY)
2697	{
2698	return VINF_SUCCESS;
2699	}
2700
2701	LogFlowThisFunc(("iPosX=%d, iPosY=%d, m_wndRoot=%#x\n", iPosX, iPosY, m_wndRoot));
2702
2703	/* Move the guest pointer to the DnD position, so we can find the window
2704	* below that position. */
2705	int xRc = XWarpPointer(m_pDisplay, None, m_wndRoot, 0, 0, 0, 0, iPosX, iPosY);
2706	if (xRc == Success)
2707	{
2708	XFlush(m_pDisplay);
2709
2710	m_lastMouseX = iPosX;
2711	m_lastMouseY = iPosY;
2712	}
2713	else
2714	VBClLogError("Moving mouse cursor failed: %s", gX11->xErrorToString(xRc).c_str());
2715
2716	return VINF_SUCCESS;
2717	}
2718
2719	/**
2720	* Sends a mouse button event to a specific window.
2721	*
2722	* @param wndDest Window to send the mouse button event to.
2723	* @param rx X coordinate relative to the root window's origin.
2724	* @param ry Y coordinate relative to the root window's origin.
2725	* @param iButton Mouse button to press/release.
2726	* @param fPress Whether to press or release the mouse button.
2727	*/
2728	void DragInstance::mouseButtonSet(Window wndDest, int rx, int ry, int iButton, bool fPress)
2729	{
2730	LogFlowThisFunc(("wndDest=%#x, rx=%d, ry=%d, iBtn=%d, fPress=%RTbool\n",
2731	wndDest, rx, ry, iButton, fPress));
2732
2733	#ifdef VBOX_DND_WITH_XTEST
2734	/** @todo Make this check run only once. */
2735	int ev, er, ma, mi;
2736	if (XTestQueryExtension(m_pDisplay, &ev, &er, &ma, &mi))
2737	{
2738	LogFlowThisFunc(("XText extension available\n"));
2739
2740	int xRc = XTestFakeButtonEvent(m_pDisplay, 1, fPress ? True : False, CurrentTime);
2741	if (Rc == 0)
2742	VBClLogError("Error sending XTestFakeButtonEvent event: %s\n", gX11->xErrorToString(xRc).c_str());
2743	XFlush(m_pDisplay);
2744	}
2745	else
2746	{
2747	#endif
2748	LogFlowThisFunc(("Note: XText extension not available or disabled\n"));
2749
2750	unsigned int mask = 0;
2751
2752	if ( rx == -1
2753	&& ry == -1)
2754	{
2755	Window wndRoot, wndChild;
2756	int wx, wy;
2757	XQueryPointer(m_pDisplay, m_wndRoot, &wndRoot, &wndChild, &rx, &ry, &wx, &wy, &mask);
2758	LogFlowThisFunc(("Mouse pointer is at root x=%d, y=%d\n", rx, ry));
2759	}
2760
2761	XButtonEvent eBtn;
2762	RT_ZERO(eBtn);
2763
2764	eBtn.display = m_pDisplay;
2765	eBtn.root = m_wndRoot;
2766	eBtn.window = wndDest;
2767	eBtn.subwindow = None;
2768	eBtn.same_screen = True;
2769	eBtn.time = CurrentTime;
2770	eBtn.button = iButton;
2771	eBtn.state = mask \| (iButton == 1 ? Button1MotionMask :
2772	iButton == 2 ? Button2MotionMask :
2773	iButton == 3 ? Button3MotionMask :
2774	iButton == 4 ? Button4MotionMask :
2775	iButton == 5 ? Button5MotionMask : 0);
2776	eBtn.type = fPress ? ButtonPress : ButtonRelease;
2777	eBtn.send_event = False;
2778	eBtn.x_root = rx;
2779	eBtn.y_root = ry;
2780
2781	XTranslateCoordinates(m_pDisplay, eBtn.root, eBtn.window, eBtn.x_root, eBtn.y_root, &eBtn.x, &eBtn.y, &eBtn.subwindow);
2782	LogFlowThisFunc(("state=0x%x, x=%d, y=%d\n", eBtn.state, eBtn.x, eBtn.y));
2783
2784	int xRc = XSendEvent(m_pDisplay, wndDest, True /* fPropagate */,
2785	ButtonPressMask,
2786	reinterpret_cast<XEvent*>(&eBtn));
2787	if (xRc == 0)
2788	VBClLogError("Error sending XButtonEvent event to window=%#x: %s\n", wndDest, gX11->xErrorToString(xRc).c_str());
2789
2790	XFlush(m_pDisplay);
2791
2792	#ifdef VBOX_DND_WITH_XTEST
2793	}
2794	#endif
2795	}
2796
2797	/**
2798	* Shows the (invisible) proxy window. The proxy window is needed for intercepting
2799	* drags from the host to the guest or from the guest to the host. It acts as a proxy
2800	* between the host and the actual (UI) element on the guest OS.
2801	*
2802	* To not make it miss any actions this window gets spawned across the entire guest
2803	* screen (think of an umbrella) to (hopefully) capture everything. A proxy window
2804	* which follows the cursor would be far too slow here.
2805	*
2806	* @returns IPRT status code.
2807	* @param piRootX X coordinate relative to the root window's origin. Optional.
2808	* @param piRootY Y coordinate relative to the root window's origin. Optional.
2809	*/
2810	int DragInstance::proxyWinShow(int piRootX / = NULL /, int piRootY /* = NULL */) const
2811	{
2812	/* piRootX is optional. */
2813	/* piRootY is optional. */
2814
2815	LogFlowThisFuncEnter();
2816
2817	int rc = VINF_SUCCESS;
2818
2819	#if 0
2820	# ifdef VBOX_DND_WITH_XTEST
2821	XTestGrabControl(m_pDisplay, False);
2822	# endif
2823	#endif
2824
2825	/* Get the mouse pointer position and determine if we're on the same screen as the root window
2826	* and return the current child window beneath our mouse pointer, if any. */
2827	int iRootX, iRootY;
2828	int iChildX, iChildY;
2829	unsigned int iMask;
2830	Window wndRoot, wndChild;
2831	Bool fInRootWnd = XQueryPointer(m_pDisplay, m_wndRoot, &wndRoot, &wndChild,
2832	&iRootX, &iRootY, &iChildX, &iChildY, &iMask);
2833
2834	LogFlowThisFunc(("fInRootWnd=%RTbool, wndRoot=%RU32, wndChild=%RU32, iRootX=%d, iRootY=%d\n",
2835	RT_BOOL(fInRootWnd), wndRoot, wndChild, iRootX, iRootY)); RT_NOREF(fInRootWnd);
2836
2837	if (piRootX)
2838	*piRootX = iRootX;
2839	if (piRootY)
2840	*piRootY = iRootY;
2841
2842	XSynchronize(m_pDisplay, True /* Enable sync */);
2843
2844	/* Bring our proxy window into foreground. */
2845	XMapWindow(m_pDisplay, m_wndProxy.hWnd);
2846	XRaiseWindow(m_pDisplay, m_wndProxy.hWnd);
2847
2848	/* Spawn our proxy window over the entire screen, making it an easy drop target for the host's cursor. */
2849	LogFlowThisFunc(("Proxy window x=%d, y=%d, width=%d, height=%d\n",
2850	m_wndProxy.iX, m_wndProxy.iY, m_wndProxy.iWidth, m_wndProxy.iHeight));
2851	XMoveResizeWindow(m_pDisplay, m_wndProxy.hWnd, m_wndProxy.iX, m_wndProxy.iY, m_wndProxy.iWidth, m_wndProxy.iHeight);
2852
2853	XFlush(m_pDisplay);
2854
2855	XSynchronize(m_pDisplay, False /* Disable sync */);
2856
2857	#if 0
2858	# ifdef VBOX_DND_WITH_XTEST
2859	XTestGrabControl(m_pDisplay, True);
2860	# endif
2861	#endif
2862
2863	LogFlowFuncLeaveRC(rc);
2864	return rc;
2865	}
2866
2867	/**
2868	* Hides the (invisible) proxy window.
2869	*/
2870	int DragInstance::proxyWinHide(void)
2871	{
2872	LogFlowFuncEnter();
2873
2874	XUnmapWindow(m_pDisplay, m_wndProxy.hWnd);
2875	XFlush(m_pDisplay);
2876
2877	return VINF_SUCCESS; /** @todo Add error checking. */
2878	}
2879
2880	/**
2881	* Allocates the name (title) of an X window.
2882	* The returned pointer must be freed using RTStrFree().
2883	*
2884	* @returns Pointer to the allocated window name.
2885	* @retval NULL on allocation failure.
2886	* @retval "<No name>" if window name was not found / invalid window handle.
2887	* @param wndThis Window to retrieve name for.
2888	*/
2889	char *DragInstance::wndX11GetNameA(Window wndThis) const
2890	{
2891	char *pszName = NULL;
2892
2893	XTextProperty propName;
2894	if ( wndThis != None
2895	&& XGetWMName(m_pDisplay, wndThis, &propName))
2896	{
2897	if (propName.value)
2898	pszName = RTStrDup((char )propName.value); /* @todo UTF8? */
2899	XFree(propName.value);
2900	}
2901
2902	if (!pszName) /* No window name found? */
2903	pszName = RTStrDup("<No name>");
2904
2905	return pszName;
2906	}
2907
2908	/**
2909	* Clear a window's supported/accepted actions list.
2910	*
2911	* @param wndThis Window to clear the list for.
2912	*/
2913	void DragInstance::wndXDnDClearActionList(Window wndThis) const
2914	{
2915	XDeleteProperty(m_pDisplay, wndThis, xAtom(XA_XdndActionList));
2916	}
2917
2918	/**
2919	* Clear a window's supported/accepted formats list.
2920	*
2921	* @param wndThis Window to clear the list for.
2922	*/
2923	void DragInstance::wndXDnDClearFormatList(Window wndThis) const
2924	{
2925	XDeleteProperty(m_pDisplay, wndThis, xAtom(XA_XdndTypeList));
2926	}
2927
2928	/**
2929	* Retrieves a window's supported/accepted XDnD actions.
2930	*
2931	* @returns IPRT status code.
2932	* @param wndThis Window to retrieve the XDnD actions for.
2933	* @param lstActions Reference to VBoxDnDAtomList to store the action into.
2934	*/
2935	int DragInstance::wndXDnDGetActionList(Window wndThis, VBoxDnDAtomList &lstActions) const
2936	{
2937	Atom iActType = None;
2938	int iActFmt;
2939	unsigned long cItems, cbData;
2940	unsigned char *pcbData = NULL;
2941
2942	/* Fetch the possible list of actions, if this property is set. */
2943	int xRc = XGetWindowProperty(m_pDisplay, wndThis,
2944	xAtom(XA_XdndActionList),
2945	0, VBOX_MAX_XPROPERTIES,
2946	False, XA_ATOM, &iActType, &iActFmt, &cItems, &cbData, &pcbData);
2947	if (xRc != Success)
2948	{
2949	LogFlowThisFunc(("Error getting XA_XdndActionList atoms from window=%#x: %s\n",
2950	wndThis, gX11->xErrorToString(xRc).c_str()));
2951	return VERR_NOT_FOUND;
2952	}
2953
2954	LogFlowThisFunc(("wndThis=%#x, cItems=%RU32, pcbData=%p\n", wndThis, cItems, pcbData));
2955
2956	if (cItems > 0)
2957	{
2958	AssertPtr(pcbData);
2959	Atom paData = reinterpret_cast<Atom >(pcbData);
2960
2961	for (unsigned i = 0; i < RT_MIN(VBOX_MAX_XPROPERTIES, cItems); i++)
2962	{
2963	LogFlowThisFunc(("\t%s\n", gX11->xAtomToString(paData[i]).c_str()));
2964	lstActions.append(paData[i]);
2965	}
2966
2967	XFree(pcbData);
2968	}
2969
2970	return VINF_SUCCESS;
2971	}
2972
2973	/**
2974	* Retrieves a window's supported/accepted XDnD formats.
2975	*
2976	* @returns IPRT status code.
2977	* @param wndThis Window to retrieve the XDnD formats for.
2978	* @param lstTypes Reference to VBoxDnDAtomList to store the formats into.
2979	*/
2980	int DragInstance::wndXDnDGetFormatList(Window wndThis, VBoxDnDAtomList &lstTypes) const
2981	{
2982	Atom iActType = None;
2983	int iActFmt;
2984	unsigned long cItems, cbData;
2985	unsigned char *pcbData = NULL;
2986
2987	int xRc = XGetWindowProperty(m_pDisplay, wndThis,
2988	xAtom(XA_XdndTypeList),
2989	0, VBOX_MAX_XPROPERTIES,
2990	False, XA_ATOM, &iActType, &iActFmt, &cItems, &cbData, &pcbData);
2991	if (xRc != Success)
2992	{
2993	LogFlowThisFunc(("Error getting XA_XdndTypeList atoms from window=%#x: %s\n",
2994	wndThis, gX11->xErrorToString(xRc).c_str()));
2995	return VERR_NOT_FOUND;
2996	}
2997
2998	LogFlowThisFunc(("wndThis=%#x, cItems=%RU32, pcbData=%p\n", wndThis, cItems, pcbData));
2999
3000	if (cItems > 0)
3001	{
3002	AssertPtr(pcbData);
3003	Atom paData = reinterpret_cast<Atom >(pcbData);
3004
3005	for (unsigned i = 0; i < RT_MIN(VBOX_MAX_XPROPERTIES, cItems); i++)
3006	{
3007	LogFlowThisFunc(("\t%s\n", gX11->xAtomToString(paData[i]).c_str()));
3008	lstTypes.append(paData[i]);
3009	}
3010
3011	XFree(pcbData);
3012	}
3013
3014	return VINF_SUCCESS;
3015	}
3016
3017	/**
3018	* Sets (replaces) a window's XDnD accepted/allowed actions.
3019	*
3020	* @returns IPRT status code.
3021	* @param wndThis Window to set the format list for.
3022	* @param lstActions Reference to list of XDnD actions to set.
3023	*/
3024	int DragInstance::wndXDnDSetActionList(Window wndThis, const VBoxDnDAtomList &lstActions) const
3025	{
3026	if (lstActions.isEmpty())
3027	return VINF_SUCCESS;
3028
3029	XChangeProperty(m_pDisplay, wndThis,
3030	xAtom(XA_XdndActionList),
3031	XA_ATOM, 32, PropModeReplace,
3032	reinterpret_cast<const unsigned char*>(lstActions.raw()),
3033	lstActions.size());
3034
3035	return VINF_SUCCESS;
3036	}
3037
3038	/**
3039	* Sets (replaces) a window's XDnD accepted format list.
3040	*
3041	* @returns IPRT status code.
3042	* @param wndThis Window to set the format list for.
3043	* @param atmProp Property to set.
3044	* @param lstFormats Reference to list of XDnD formats to set.
3045	*/
3046	int DragInstance::wndXDnDSetFormatList(Window wndThis, Atom atmProp, const VBoxDnDAtomList &lstFormats) const
3047	{
3048	if (lstFormats.isEmpty())
3049	return VERR_INVALID_PARAMETER;
3050
3051	/* Add the property with the property data to the window. */
3052	XChangeProperty(m_pDisplay, wndThis, atmProp,
3053	XA_ATOM, 32, PropModeReplace,
3054	reinterpret_cast<const unsigned char*>(lstFormats.raw()),
3055	lstFormats.size());
3056
3057	return VINF_SUCCESS;
3058	}
3059
3060	/**
3061	* Appends a RTCString list to VBoxDnDAtomList list.
3062	*
3063	* @returns IPRT status code.
3064	* @param lstFormats Reference to RTCString list to convert.
3065	* @param lstAtoms Reference to VBoxDnDAtomList list to store results in.
3066	*/
3067	int DragInstance::appendFormatsToList(const RTCList<RTCString> &lstFormats, VBoxDnDAtomList &lstAtoms) const
3068	{
3069	for (size_t i = 0; i < lstFormats.size(); ++i)
3070	lstAtoms.append(XInternAtom(m_pDisplay, lstFormats.at(i).c_str(), False));
3071
3072	return VINF_SUCCESS;
3073	}
3074
3075	/**
3076	* Appends a raw-data string list to VBoxDnDAtomList list.
3077	*
3078	* @returns IPRT status code.
3079	* @param pvData Pointer to string data to convert.
3080	* @param cbData Size (in bytes) to convert.
3081	* @param lstAtoms Reference to VBoxDnDAtomList list to store results in.
3082	*/
3083	int DragInstance::appendDataToList(const void *pvData, uint32_t cbData, VBoxDnDAtomList &lstAtoms) const
3084	{
3085	RT_NOREF1(lstAtoms);
3086	AssertPtrReturn(pvData, VERR_INVALID_POINTER);
3087	AssertReturn(cbData, VERR_INVALID_PARAMETER);
3088
3089	const char pszStr = (char )pvData;
3090	uint32_t cbStr = cbData;
3091
3092	int rc = VINF_SUCCESS;
3093
3094	VBoxDnDAtomList lstAtom;
3095	while (cbStr)
3096	{
3097	size_t cbSize = RTStrNLen(pszStr, cbStr);
3098
3099	/* Create a copy with max N chars, so that we are on the save side,
3100	* even if the data isn't zero terminated. */
3101	char *pszTmp = RTStrDupN(pszStr, cbSize);
3102	if (!pszTmp)
3103	{
3104	rc = VERR_NO_MEMORY;
3105	break;
3106	}
3107
3108	lstAtom.append(XInternAtom(m_pDisplay, pszTmp, False));
3109	RTStrFree(pszTmp);
3110
3111	pszStr += cbSize + 1;
3112	cbStr -= cbSize + 1;
3113	}
3114
3115	return rc;
3116	}
3117
3118	/**
3119	* Converts a HGCM-based drag'n drop action to a Atom-based drag'n drop action.
3120	*
3121	* @returns Converted Atom-based drag'n drop action.
3122	* @param dndAction HGCM drag'n drop actions to convert.
3123	*/
3124	/* static */
3125	Atom DragInstance::toAtomAction(VBOXDNDACTION dndAction)
3126	{
3127	/* Ignore is None. */
3128	return (isDnDCopyAction(dndAction) ? xAtom(XA_XdndActionCopy) :
3129	isDnDMoveAction(dndAction) ? xAtom(XA_XdndActionMove) :
3130	isDnDLinkAction(dndAction) ? xAtom(XA_XdndActionLink) :
3131	None);
3132	}
3133
3134	/**
3135	* Converts HGCM-based drag'n drop actions to a VBoxDnDAtomList list.
3136	*
3137	* @returns IPRT status code.
3138	* @param dndActionList HGCM drag'n drop actions to convert.
3139	* @param lstAtoms Reference to VBoxDnDAtomList to store actions in.
3140	*/
3141	/* static */
3142	int DragInstance::toAtomActions(VBOXDNDACTIONLIST dndActionList, VBoxDnDAtomList &lstAtoms)
3143	{
3144	if (hasDnDCopyAction(dndActionList))
3145	lstAtoms.append(xAtom(XA_XdndActionCopy));
3146	if (hasDnDMoveAction(dndActionList))
3147	lstAtoms.append(xAtom(XA_XdndActionMove));
3148	if (hasDnDLinkAction(dndActionList))
3149	lstAtoms.append(xAtom(XA_XdndActionLink));
3150
3151	return VINF_SUCCESS;
3152	}
3153
3154	/**
3155	* Converts an Atom-based drag'n drop action to a HGCM drag'n drop action.
3156	*
3157	* @returns HGCM drag'n drop action.
3158	* @param atom Atom-based drag'n drop action to convert.
3159	*/
3160	/* static */
3161	uint32_t DragInstance::toHGCMAction(Atom atom)
3162	{
3163	uint32_t uAction = VBOX_DND_ACTION_IGNORE;
3164
3165	if (atom == xAtom(XA_XdndActionCopy))
3166	uAction = VBOX_DND_ACTION_COPY;
3167	else if (atom == xAtom(XA_XdndActionMove))
3168	uAction = VBOX_DND_ACTION_MOVE;
3169	else if (atom == xAtom(XA_XdndActionLink))
3170	uAction = VBOX_DND_ACTION_LINK;
3171
3172	return uAction;
3173	}
3174
3175	/**
3176	* Converts an VBoxDnDAtomList list to an HGCM action list.
3177	*
3178	* @returns ORed HGCM action list.
3179	* @param lstActions List of Atom-based actions to convert.
3180	*/
3181	/* static */
3182	uint32_t DragInstance::toHGCMActions(const VBoxDnDAtomList &lstActions)
3183	{
3184	uint32_t uActions = VBOX_DND_ACTION_IGNORE;
3185
3186	for (size_t i = 0; i < lstActions.size(); i++)
3187	uActions \|= toHGCMAction(lstActions.at(i));
3188
3189	return uActions;
3190	}
3191
3192	/*********************************************************************************************************************************
3193	* VBoxDnDProxyWnd implementation. *
3194	********************************************************************************************************************************/
3195
3196	VBoxDnDProxyWnd::VBoxDnDProxyWnd(void)
3197	: pDisp(NULL)
3198	, hWnd(0)
3199	, iX(0)
3200	, iY(0)
3201	, iWidth(0)
3202	, iHeight(0)
3203	{
3204
3205	}
3206
3207	VBoxDnDProxyWnd::~VBoxDnDProxyWnd(void)
3208	{
3209	destroy();
3210	}
3211
3212	int VBoxDnDProxyWnd::init(Display *pDisplay)
3213	{
3214	/** @todo What about multiple screens? Test this! */
3215	int iScreenID = XDefaultScreen(pDisplay);
3216
3217	iWidth = XDisplayWidth(pDisplay, iScreenID);
3218	iHeight = XDisplayHeight(pDisplay, iScreenID);
3219	pDisp = pDisplay;
3220
3221	return VINF_SUCCESS;
3222	}
3223
3224	void VBoxDnDProxyWnd::destroy(void)
3225	{
3226
3227	}
3228
3229	int VBoxDnDProxyWnd::sendFinished(Window hWndSource, VBOXDNDACTION dndAction)
3230	{
3231	/* Was the drop accepted by the host? That is, anything than ignoring. */
3232	bool fDropAccepted = dndAction > VBOX_DND_ACTION_IGNORE;
3233
3234	LogFlowFunc(("dndAction=0x%x\n", dndAction));
3235
3236	/* Confirm the result of the transfer to the target window. */
3237	XClientMessageEvent m;
3238	RT_ZERO(m);
3239	m.type = ClientMessage;
3240	m.display = pDisp;
3241	m.window = hWnd;
3242	m.message_type = xAtom(XA_XdndFinished);
3243	m.format = 32;
3244	m.data.l[XdndFinishedWindow] = hWnd; /* Target window. */
3245	m.data.l[XdndFinishedFlags] = fDropAccepted ? RT_BIT(0) : 0; /* Was the drop accepted? */
3246	m.data.l[XdndFinishedAction] = fDropAccepted ? DragInstance::toAtomAction(dndAction) : None; /* Action used on accept. */
3247
3248	int xRc = XSendEvent(pDisp, hWndSource, True, NoEventMask, reinterpret_cast<XEvent*>(&m));
3249	if (xRc == 0)
3250	{
3251	VBClLogError("Error sending finished event to source window=%#x: %s\n",
3252	hWndSource, gX11->xErrorToString(xRc).c_str());
3253
3254	return VERR_GENERAL_FAILURE; /** @todo Fudge. */
3255	}
3256
3257	return VINF_SUCCESS;
3258	}
3259
3260	/*********************************************************************************************************************************
3261	* DragAndDropService implementation. *
3262	********************************************************************************************************************************/
3263
3264	/** @copydoc VBCLSERVICE::pfnInit */
3265	int DragAndDropService::init(void)
3266	{
3267	LogFlowFuncEnter();
3268
3269	/* Connect to the x11 server. */
3270	m_pDisplay = XOpenDisplay(NULL);
3271	if (!m_pDisplay)
3272	{
3273	VBClLogFatalError("Unable to connect to X server -- running in a terminal session?\n");
3274	return VERR_NOT_FOUND;
3275	}
3276
3277	xHelpers *pHelpers = xHelpers::getInstance(m_pDisplay);
3278	if (!pHelpers)
3279	return VERR_NO_MEMORY;
3280
3281	int rc;
3282
3283	do
3284	{
3285	rc = RTSemEventCreate(&m_hEventSem);
3286	AssertRCBreak(rc);
3287
3288	rc = RTCritSectInit(&m_eventQueueCS);
3289	AssertRCBreak(rc);
3290
3291	rc = VbglR3DnDConnect(&m_dndCtx);
3292	AssertRCBreak(rc);
3293
3294	/* Event thread for events coming from the HGCM device. */
3295	rc = RTThreadCreate(&m_hHGCMThread, hgcmEventThread, this,
3296	0, RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE, "dndHGCM");
3297	AssertRCBreak(rc);
3298
3299	rc = RTThreadUserWait(m_hHGCMThread, RT_MS_30SEC);
3300	AssertRCBreak(rc);
3301
3302	if (ASMAtomicReadBool(&m_fStop))
3303	break;
3304
3305	/* Event thread for events coming from the x11 system. */
3306	rc = RTThreadCreate(&m_hX11Thread, x11EventThread, this,
3307	0, RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE, "dndX11");
3308	AssertRCBreak(rc);
3309
3310	rc = RTThreadUserWait(m_hX11Thread, RT_MS_30SEC);
3311	AssertRCBreak(rc);
3312
3313	if (ASMAtomicReadBool(&m_fStop))
3314	break;
3315
3316	} while (0);
3317
3318	if (m_fStop)
3319	rc = VERR_GENERAL_FAILURE; /** @todo Fudge! */
3320
3321	if (RT_FAILURE(rc))
3322	VBClLogError("Failed to initialize, rc=%Rrc\n", rc);
3323
3324	LogFlowFuncLeaveRC(rc);
3325	return rc;
3326	}
3327
3328	/** @copydoc VBCLSERVICE::pfnWorker */
3329	int DragAndDropService::worker(bool volatile *pfShutdown)
3330	{
3331	int rc;
3332	do
3333	{
3334	m_pCurDnD = new DragInstance(m_pDisplay, this);
3335	if (!m_pCurDnD)
3336	{
3337	rc = VERR_NO_MEMORY;
3338	break;
3339	}
3340
3341	/* Note: For multiple screen support in VBox it is not necessary to use
3342	* another screen number than zero. Maybe in the future it will become
3343	* necessary if VBox supports multiple X11 screens. */
3344	rc = m_pCurDnD->init(0 /* uScreenID */);
3345	/* Note: Can return VINF_PERMISSION_DENIED if HGCM host service is not available. */
3346	if (rc != VINF_SUCCESS)
3347	{
3348	if (RT_FAILURE(rc))
3349	VBClLogError("Unable to connect to drag and drop service, rc=%Rrc\n", rc);
3350	else if (rc == VINF_PERMISSION_DENIED) /* No error, DnD might be just disabled. */
3351	VBClLogInfo("Not available on host, terminating\n");
3352	break;
3353	}
3354
3355	/* Let the main thread know that it can continue spawning services. */
3356	RTThreadUserSignal(RTThreadSelf());
3357
3358	/* Enter the main event processing loop. */
3359	do
3360	{
3361	DNDEVENT e;
3362	RT_ZERO(e);
3363
3364	LogFlowFunc(("Waiting for new events ...\n"));
3365	rc = RTSemEventWait(m_hEventSem, RT_INDEFINITE_WAIT);
3366	if (RT_FAILURE(rc))
3367	break;
3368
3369	size_t cEvents = 0;
3370
3371	int rc2 = RTCritSectEnter(&m_eventQueueCS);
3372	if (RT_SUCCESS(rc2))
3373	{
3374	cEvents = m_eventQueue.size();
3375
3376	rc2 = RTCritSectLeave(&m_eventQueueCS);
3377	AssertRC(rc2);
3378	}
3379
3380	while (cEvents)
3381	{
3382	rc2 = RTCritSectEnter(&m_eventQueueCS);
3383	if (RT_SUCCESS(rc2))
3384	{
3385	if (m_eventQueue.isEmpty())
3386	{
3387	rc2 = RTCritSectLeave(&m_eventQueueCS);
3388	AssertRC(rc2);
3389	break;
3390	}
3391
3392	e = m_eventQueue.first();
3393	m_eventQueue.removeFirst();
3394
3395	rc2 = RTCritSectLeave(&m_eventQueueCS);
3396	AssertRC(rc2);
3397	}
3398
3399	if (e.enmType == DNDEVENT::DnDEventType_HGCM)
3400	{
3401	PVBGLR3DNDEVENT pVbglR3Event = e.hgcm;
3402	AssertPtrBreak(pVbglR3Event);
3403
3404	LogFlowThisFunc(("HGCM event enmType=%RU32\n", pVbglR3Event->enmType));
3405	switch (pVbglR3Event->enmType)
3406	{
3407	case VBGLR3DNDEVENTTYPE_HG_ENTER:
3408	{
3409	if (pVbglR3Event->u.HG_Enter.cbFormats)
3410	{
3411	RTCList<RTCString> lstFormats =
3412	RTCString(pVbglR3Event->u.HG_Enter.pszFormats, pVbglR3Event->u.HG_Enter.cbFormats - 1).split(DND_PATH_SEPARATOR_STR);
3413	rc = m_pCurDnD->hgEnter(lstFormats, pVbglR3Event->u.HG_Enter.dndLstActionsAllowed);
3414	if (RT_FAILURE(rc))
3415	break;
3416	/* Enter is always followed by a move event. */
3417	}
3418	else
3419	{
3420	AssertMsgFailed(("cbFormats is 0\n"));
3421	rc = VERR_INVALID_PARAMETER;
3422	break;
3423	}
3424
3425	/* Note: After HOST_DND_FN_HG_EVT_ENTER there immediately is a move
3426	* event, so fall through is intentional here. */
3427	RT_FALL_THROUGH();
3428	}
3429
3430	case VBGLR3DNDEVENTTYPE_HG_MOVE:
3431	{
3432	rc = m_pCurDnD->hgMove(pVbglR3Event->u.HG_Move.uXpos, pVbglR3Event->u.HG_Move.uYpos,
3433	pVbglR3Event->u.HG_Move.dndActionDefault);
3434	break;
3435	}
3436
3437	case VBGLR3DNDEVENTTYPE_HG_LEAVE:
3438	{
3439	rc = m_pCurDnD->hgLeave();
3440	break;
3441	}
3442
3443	case VBGLR3DNDEVENTTYPE_HG_DROP:
3444	{
3445	rc = m_pCurDnD->hgDrop(pVbglR3Event->u.HG_Drop.uXpos, pVbglR3Event->u.HG_Drop.uYpos,
3446	pVbglR3Event->u.HG_Drop.dndActionDefault);
3447	break;
3448	}
3449
3450	/* Note: VbglR3DnDRecvNextMsg() will return HOST_DND_FN_HG_SND_DATA_HDR when
3451	* the host has finished copying over all the data to the guest.
3452	*
3453	* The actual data transfer (and message processing for it) will be done
3454	* internally by VbglR3DnDRecvNextMsg() to not duplicate any code for different
3455	* platforms.
3456	*
3457	* The data header now will contain all the (meta) data the guest needs in
3458	* order to complete the DnD operation. */
3459	case VBGLR3DNDEVENTTYPE_HG_RECEIVE:
3460	{
3461	rc = m_pCurDnD->hgDataReceive(&pVbglR3Event->u.HG_Received.Meta);
3462	break;
3463	}
3464
3465	case VBGLR3DNDEVENTTYPE_CANCEL:
3466	{
3467	m_pCurDnD->reset();
3468	break;
3469	}
3470
3471	#ifdef VBOX_WITH_DRAG_AND_DROP_GH
3472	case VBGLR3DNDEVENTTYPE_GH_ERROR:
3473	{
3474	m_pCurDnD->reset();
3475	break;
3476	}
3477
3478	case VBGLR3DNDEVENTTYPE_GH_REQ_PENDING:
3479	{
3480	rc = m_pCurDnD->ghIsDnDPending();
3481	break;
3482	}
3483
3484	case VBGLR3DNDEVENTTYPE_GH_DROP:
3485	{
3486	rc = m_pCurDnD->ghDropped(pVbglR3Event->u.GH_Drop.pszFormat, pVbglR3Event->u.GH_Drop.dndActionRequested);
3487	break;
3488	}
3489	#endif
3490	case VBGLR3DNDEVENTTYPE_QUIT:
3491	{
3492	rc = VINF_SUCCESS;
3493	break;
3494	}
3495
3496	default:
3497	{
3498	VBClLogError("Received unsupported message type %RU32\n", pVbglR3Event->enmType);
3499	rc = VERR_NOT_SUPPORTED;
3500	break;
3501	}
3502	}
3503
3504	LogFlowFunc(("Message %RU32 processed with %Rrc\n", pVbglR3Event->enmType, rc));
3505	if (RT_FAILURE(rc))
3506	{
3507	/* Tell the user. */
3508	VBClLogError("Processing message %RU32 failed with %Rrc\n", pVbglR3Event->enmType, rc);
3509
3510	/* If anything went wrong, do a reset and start over. */
3511	reset();
3512	}
3513
3514	const bool fQuit = pVbglR3Event->enmType == VBGLR3DNDEVENTTYPE_QUIT;
3515
3516	VbglR3DnDEventFree(e.hgcm);
3517	e.hgcm = NULL;
3518
3519	if (fQuit)
3520	break;
3521	}
3522	else if (e.enmType == DNDEVENT::DnDEventType_X11)
3523	{
3524	LogFlowThisFunc(("X11 event (type %#x)\n", e.x11.type));
3525	m_pCurDnD->onX11Event(e.x11);
3526	}
3527	else
3528	AssertMsgFailed(("Unknown event queue type %RU32\n", e.enmType));
3529
3530	--cEvents;
3531
3532	} /* for */
3533
3534	/*
3535	* Make sure that any X11 requests have actually been sent to the
3536	* server, since we are waiting for responses using poll() on
3537	* another thread which will not automatically trigger flushing.
3538	*/
3539	XFlush(m_pDisplay);
3540
3541	if (m_fStop)
3542	break;
3543
3544	} while (!ASMAtomicReadBool(pfShutdown));
3545
3546	} while (0);
3547
3548	if (m_pCurDnD)
3549	{
3550	delete m_pCurDnD;
3551	m_pCurDnD = NULL;
3552	}
3553
3554	LogFlowFuncLeaveRC(rc);
3555	return rc;
3556	}
3557
3558	/**
3559	* Resets the DnD service' data.
3560	*/
3561	void DragAndDropService::reset(void)
3562	{
3563	LogFlowFuncEnter();
3564
3565	if (m_pCurDnD)
3566	m_pCurDnD->reset();
3567
3568	/*
3569	* Clear the event queue.
3570	*/
3571	int rc2 = RTCritSectEnter(&m_eventQueueCS);
3572	if (RT_SUCCESS(rc2))
3573	{
3574	for (size_t i = 0; i < m_eventQueue.size(); i++)
3575	{
3576	switch (m_eventQueue[i].enmType)
3577	{
3578	case DNDEVENT::DnDEventType_HGCM:
3579	{
3580	VbglR3DnDEventFree(m_eventQueue[i].hgcm);
3581	break;
3582	}
3583
3584	default:
3585	break;
3586	}
3587
3588	}
3589
3590	m_eventQueue.clear();
3591
3592	rc2 = RTCritSectLeave(&m_eventQueueCS);
3593	AssertRC(rc2);
3594	}
3595
3596	LogFlowFuncLeave();
3597	}
3598
3599	/** @copydoc VBCLSERVICE::pfnStop */
3600	void DragAndDropService::stop(void)
3601	{
3602	LogFlowFuncEnter();
3603
3604	/* Set stop flag first. */
3605	ASMAtomicXchgBool(&m_fStop, true);
3606
3607	/* First, disconnect any instances. */
3608	if (m_pCurDnD)
3609	m_pCurDnD->stop();
3610
3611	/* Second, disconnect the service's DnD connection. */
3612	VbglR3DnDDisconnect(&m_dndCtx);
3613
3614	LogFlowFuncLeave();
3615	}
3616
3617	/** @copydoc VBCLSERVICE::pfnTerm */
3618	int DragAndDropService::term(void)
3619	{
3620	int rc = VINF_SUCCESS;
3621
3622	/*
3623	* Wait for threads to terminate.
3624	*/
3625	int rcThread;
3626
3627	if (m_hX11Thread != NIL_RTTHREAD)
3628	{
3629	VBClLogVerbose(2, "Terminating X11 thread ...\n");
3630
3631	int rc2 = RTThreadWait(m_hX11Thread, RT_MS_30SEC, &rcThread);
3632	if (RT_SUCCESS(rc2))
3633	rc2 = rcThread;
3634
3635	if (RT_FAILURE(rc2))
3636	VBClLogError("Error waiting for X11 thread to terminate: %Rrc\n", rc2);
3637
3638	if (RT_SUCCESS(rc))
3639	rc = rc2;
3640
3641	m_hX11Thread = NIL_RTTHREAD;
3642
3643	VBClLogVerbose(2, "X11 thread terminated\n");
3644	}
3645
3646	if (m_hHGCMThread != NIL_RTTHREAD)
3647	{
3648	VBClLogVerbose(2, "Terminating HGCM thread ...\n");
3649
3650	int rc2 = RTThreadWait(m_hHGCMThread, RT_MS_30SEC, &rcThread);
3651	if (RT_SUCCESS(rc2))
3652	rc2 = rcThread;
3653
3654	if (RT_FAILURE(rc2))
3655	VBClLogError("Error waiting for HGCM thread to terminate: %Rrc\n", rc2);
3656
3657	if (RT_SUCCESS(rc))
3658	rc = rc2;
3659
3660	m_hHGCMThread = NIL_RTTHREAD;
3661
3662	VBClLogVerbose(2, "HGCM thread terminated\n");
3663	}
3664
3665	reset();
3666
3667	if (m_pCurDnD)
3668	{
3669	delete m_pCurDnD;
3670	m_pCurDnD = NULL;
3671	}
3672
3673	xHelpers::destroyInstance();
3674
3675	return rc;
3676	}
3677
3678	/**
3679	* Static callback function for HGCM message processing thread. An internal
3680	* message queue will be filled which then will be processed by the according
3681	* drag'n drop instance.
3682	*
3683	* @returns IPRT status code.
3684	* @param hThread Thread handle to use.
3685	* @param pvUser Pointer to DragAndDropService instance to use.
3686	*/
3687	/* static */
3688	DECLCALLBACK(int) DragAndDropService::hgcmEventThread(RTTHREAD hThread, void *pvUser)
3689	{
3690	AssertPtrReturn(pvUser, VERR_INVALID_PARAMETER);
3691	DragAndDropService pThis = static_cast<DragAndDropService>(pvUser);
3692
3693	/* Let the service instance know in any case. */
3694	int rc = RTThreadUserSignal(hThread);
3695	AssertRCReturn(rc, rc);
3696
3697	VBClLogVerbose(2, "HGCM thread started\n");
3698
3699	/* Number of invalid messages skipped in a row. */
3700	int cMsgSkippedInvalid = 0;
3701	DNDEVENT e;
3702
3703	do
3704	{
3705	RT_ZERO(e);
3706	e.enmType = DNDEVENT::DnDEventType_HGCM;
3707
3708	/* Wait for new events. */
3709	rc = VbglR3DnDEventGetNext(&pThis->m_dndCtx, &e.hgcm);
3710	if (RT_SUCCESS(rc))
3711	{
3712	cMsgSkippedInvalid = 0; /* Reset skipped messages count. */
3713
3714	int rc2 = RTCritSectEnter(&pThis->m_eventQueueCS);
3715	if (RT_SUCCESS(rc2))
3716	{
3717	VBClLogVerbose(2, "Received new HGCM message (type %#x)\n", e.hgcm->enmType);
3718
3719	pThis->m_eventQueue.append(e);
3720
3721	rc2 = RTCritSectLeave(&pThis->m_eventQueueCS);
3722	AssertRC(rc2);
3723	}
3724
3725	rc = RTSemEventSignal(pThis->m_hEventSem);
3726	if (RT_FAILURE(rc))
3727	break;
3728	}
3729	else
3730	{
3731	VBClLogError("Processing next message failed with rc=%Rrc\n", rc);
3732
3733	/* Old(er) hosts either are broken regarding DnD support or otherwise
3734	* don't support the stuff we do on the guest side, so make sure we
3735	* don't process invalid messages forever. */
3736
3737	if (cMsgSkippedInvalid++ > 32)
3738	{
3739	VBClLogError("Too many invalid/skipped messages from host, exiting ...\n");
3740	break;
3741	}
3742	}
3743
3744	} while (!ASMAtomicReadBool(&pThis->m_fStop));
3745
3746	VBClLogVerbose(2, "HGCM thread ended\n");
3747
3748	LogFlowFuncLeaveRC(rc);
3749	return rc;
3750	}
3751
3752	/**
3753	* Static callback function for X11 message processing thread. All X11 messages
3754	* will be directly routed to the according drag'n drop instance.
3755	*
3756	* @returns IPRT status code.
3757	* @param hThread Thread handle to use.
3758	* @param pvUser Pointer to DragAndDropService instance to use.
3759	*/
3760	/* static */
3761	DECLCALLBACK(int) DragAndDropService::x11EventThread(RTTHREAD hThread, void *pvUser)
3762	{
3763	AssertPtrReturn(pvUser, VERR_INVALID_PARAMETER);
3764	DragAndDropService pThis = static_cast<DragAndDropService>(pvUser);
3765	AssertPtr(pThis);
3766
3767	int rc = VINF_SUCCESS;
3768
3769	/* Note: Nothing to initialize here (yet). */
3770
3771	/* Let the service instance know in any case. */
3772	int rc2 = RTThreadUserSignal(hThread);
3773	AssertRC(rc2);
3774
3775	VBClLogVerbose(2, "X11 thread started\n");
3776
3777	DNDEVENT e;
3778	RT_ZERO(e);
3779	e.enmType = DNDEVENT::DnDEventType_X11;
3780
3781	do
3782	{
3783	/*
3784	* Wait for new events. We can't use XIfEvent here, cause this locks
3785	* the window connection with a mutex and if no X11 events occurs this
3786	* blocks any other calls we made to X11. So instead check for new
3787	* events and if there are not any new one, sleep for a certain amount
3788	* of time.
3789	*/
3790	unsigned cNewEvents = 0;
3791	unsigned cQueued = XEventsQueued(pThis->m_pDisplay, QueuedAfterFlush);
3792	while (cQueued)
3793	{
3794	/* XNextEvent will block until a new X event becomes available. */
3795	XNextEvent(pThis->m_pDisplay, &e.x11);
3796	{
3797	rc2 = RTCritSectEnter(&pThis->m_eventQueueCS);
3798	if (RT_SUCCESS(rc2))
3799	{
3800	LogFlowFunc(("Added new X11 event, type=%d\n", e.x11.type));
3801
3802	pThis->m_eventQueue.append(e);
3803	cNewEvents++;
3804
3805	rc2 = RTCritSectLeave(&pThis->m_eventQueueCS);
3806	AssertRC(rc2);
3807	}
3808	}
3809
3810	cQueued--;
3811	}
3812
3813	if (cNewEvents)
3814	{
3815	rc = RTSemEventSignal(pThis->m_hEventSem);
3816	if (RT_FAILURE(rc))
3817	break;
3818
3819	continue;
3820	}
3821
3822	/* No new events; wait a bit. */
3823	RTThreadSleep(25 /* ms */);
3824
3825	} while (!ASMAtomicReadBool(&pThis->m_fStop));
3826
3827	VBClLogVerbose(2, "X11 thread ended\n");
3828
3829	LogFlowFuncLeaveRC(rc);
3830	return rc;
3831	}
3832	/**
3833	* @interface_method_impl{VBCLSERVICE,pfnInit}
3834	*/
3835	static DECLCALLBACK(int) vbclDnDInit(void)
3836	{
3837	return g_Svc.init();
3838	}
3839
3840	/**
3841	* @interface_method_impl{VBCLSERVICE,pfnWorker}
3842	*/
3843	static DECLCALLBACK(int) vbclDnDWorker(bool volatile *pfShutdown)
3844	{
3845	return g_Svc.worker(pfShutdown);
3846	}
3847
3848	/**
3849	* @interface_method_impl{VBCLSERVICE,pfnStop}
3850	*/
3851	static DECLCALLBACK(void) vbclDnDStop(void)
3852	{
3853	g_Svc.stop();
3854	}
3855
3856	/**
3857	* @interface_method_impl{VBCLSERVICE,pfnTerm}
3858	*/
3859	static DECLCALLBACK(int) vbclDnDTerm(void)
3860	{
3861	return g_Svc.term();
3862	}
3863
3864	VBCLSERVICE g_SvcDragAndDrop =
3865	{
3866	"dnd", /* szName */
3867	"Drag'n'Drop", /* pszDescription */
3868	".vboxclient-draganddrop.pid", /* pszPidFilePath */
3869	NULL, /* pszUsage */
3870	NULL, /* pszOptions */
3871	NULL, /* pfnOption */
3872	vbclDnDInit, /* pfnInit */
3873	vbclDnDWorker, /* pfnWorker */
3874	vbclDnDStop, /* pfnStop*/
3875	vbclDnDTerm /* pfnTerm */
3876	};
3877

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

source: vbox/trunk/src/VBox/Additions/x11/VBoxClient/draganddrop.cpp@ 97827

Download in other formats: