VBoxClipboard.cpp@ 34575

Last change on this file since 34575 was 33966, checked in by vboxsync, 14 years ago
VBoxTray: Cleaning up, refactoring, grouping window messages.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 25.9 KB

Line
1	/** @file
2	*
3	* VBoxClipboard - Shared clipboard
4	*
5	*/
6
7	/*
8	* Copyright (C) 2006-2010 Oracle Corporation
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License (GPL) as published by the Free Software
14	* Foundation, in version 2 as it comes in the "COPYING" file of the
15	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17	*/
18
19	#include "VBoxTray.h"
20	#include "VBoxHelpers.h"
21
22	#include <VBox/HostServices/VBoxClipboardSvc.h>
23	#include <strsafe.h>
24
25	typedef struct _VBOXCLIPBOARDCONTEXT
26	{
27	const VBOXSERVICEENV *pEnv;
28
29	uint32_t u32ClientID;
30
31	ATOM atomWindowClass;
32
33	HWND hwnd;
34
35	HWND hwndNextInChain;
36
37	UINT timerRefresh;
38
39	bool fCBChainPingInProcess;
40
41	// bool fOperational;
42
43	// uint32_t u32LastSentFormat;
44	// uint64_t u64LastSentCRC64;
45
46	} VBOXCLIPBOARDCONTEXT;
47
48	static char gachWindowClassName[] = "VBoxSharedClipboardClass";
49
50	enum { CBCHAIN_TIMEOUT = 5000 /* ms */ };
51
52	static int vboxClipboardChanged(VBOXCLIPBOARDCONTEXT *pCtx)
53	{
54	AssertPtr(pCtx);
55
56	/* Query list of available formats and report to host. */
57	int rc = VINF_SUCCESS;
58	if (FALSE == OpenClipboard(pCtx->hwnd))
59	{
60	rc = RTErrConvertFromWin32(GetLastError());
61	}
62	else
63	{
64	uint32_t u32Formats = 0;
65	UINT format = 0;
66
67	while ((format = EnumClipboardFormats (format)) != 0)
68	{
69	Log(("VBoxTray: vboxClipboardChanged: format = 0x%08X\n", format));
70	switch (format)
71	{
72	case CF_UNICODETEXT:
73	case CF_TEXT:
74	u32Formats \|= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
75	break;
76
77	case CF_DIB:
78	case CF_BITMAP:
79	u32Formats \|= VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
80	break;
81
82	default:
83	if (format >= 0xC000)
84	{
85	TCHAR szFormatName[256];
86
87	int cActual = GetClipboardFormatName(format, szFormatName, sizeof(szFormatName)/sizeof (TCHAR));
88	if (cActual)
89	{
90	if (strcmp (szFormatName, "HTML Format") == 0)
91	{
92	u32Formats \|= VBOX_SHARED_CLIPBOARD_FMT_HTML;
93	}
94	}
95	}
96	break;
97	}
98	}
99
100	CloseClipboard ();
101	rc = VbglR3ClipboardReportFormats(pCtx->u32ClientID, u32Formats);
102	}
103	return rc;
104	}
105
106	/* Add ourselves into the chain of cliboard listeners */
107	static void addToCBChain (VBOXCLIPBOARDCONTEXT *pCtx)
108	{
109	pCtx->hwndNextInChain = SetClipboardViewer (pCtx->hwnd);
110	}
111
112	/* Remove ourselves from the chain of cliboard listeners */
113	static void removeFromCBChain (VBOXCLIPBOARDCONTEXT *pCtx)
114	{
115	ChangeClipboardChain (pCtx->hwnd, pCtx->hwndNextInChain);
116	pCtx->hwndNextInChain = NULL;
117	}
118
119	/* Callback which is invoked when we have successfully pinged ourselves down the
120	* clipboard chain. We simply unset a boolean flag to say that we are responding.
121	* There is a race if a ping returns after the next one is initiated, but nothing
122	* very bad is likely to happen. */
123	VOID CALLBACK CBChainPingProc(HWND hwnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult)
124	{
125	(void) hwnd;
126	(void) uMsg;
127	(void) lResult;
128	VBOXCLIPBOARDCONTEXT pCtx = (VBOXCLIPBOARDCONTEXT )dwData;
129	pCtx->fCBChainPingInProcess = FALSE;
130	}
131
132	static LRESULT vboxClipboardProcessMsg(VBOXCLIPBOARDCONTEXT *pCtx, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
133	{
134	LRESULT rc = 0;
135
136	switch (msg)
137	{
138	case WM_CHANGECBCHAIN:
139	{
140	HWND hwndRemoved = (HWND)wParam;
141	HWND hwndNext = (HWND)lParam;
142
143	Log(("VBoxTray: vboxClipboardProcessMsg: WM_CHANGECBCHAIN: hwndRemoved %p, hwndNext %p, hwnd %p\n", hwndRemoved, hwndNext, pCtx->hwnd));
144
145	if (hwndRemoved == pCtx->hwndNextInChain)
146	{
147	/* The window that was next to our in the chain is being removed.
148	* Relink to the new next window. */
149	pCtx->hwndNextInChain = hwndNext;
150	}
151	else
152	{
153	if (pCtx->hwndNextInChain)
154	{
155	/* Pass the message further. */
156	DWORD_PTR dwResult;
157	rc = SendMessageTimeout(pCtx->hwndNextInChain, WM_CHANGECBCHAIN, wParam, lParam, 0, CBCHAIN_TIMEOUT, &dwResult);
158	if (!rc)
159	rc = (LRESULT) dwResult;
160	}
161	}
162	} break;
163
164	case WM_DRAWCLIPBOARD:
165	{
166	Log(("VBoxTray: vboxClipboardProcessMsg: WM_DRAWCLIPBOARD, hwnd %p\n", pCtx->hwnd));
167
168	if (GetClipboardOwner () != hwnd)
169	{
170	/* Clipboard was updated by another application. */
171	/* WM_DRAWCLIPBOARD always expects a return code of 0, so don't change "rc" here. */
172	int vboxrc = vboxClipboardChanged(pCtx);
173	if (RT_FAILURE(vboxrc))
174	Log(("VBoxTray: vboxClipboardProcessMsg: vboxClipboardChanged failed, rc = %Rrc\n", vboxrc));
175	}
176
177	/* Pass the message to next windows in the clipboard chain. */
178	SendMessageTimeout(pCtx->hwndNextInChain, msg, wParam, lParam, 0, CBCHAIN_TIMEOUT, NULL);
179	} break;
180
181	case WM_TIMER:
182	{
183	HWND hViewer = GetClipboardViewer();
184
185	/* Re-register ourselves in the clipboard chain if our last ping
186	* timed out or there seems to be no valid chain. */
187	if (!hViewer \|\| pCtx->fCBChainPingInProcess)
188	{
189	removeFromCBChain(pCtx);
190	addToCBChain(pCtx);
191	}
192	/* Start a new ping by passing a dummy WM_CHANGECBCHAIN to be
193	* processed by ourselves to the chain. */
194	pCtx->fCBChainPingInProcess = TRUE;
195	hViewer = GetClipboardViewer();
196	if (hViewer)
197	SendMessageCallback(hViewer, WM_CHANGECBCHAIN, (WPARAM)pCtx->hwndNextInChain, (LPARAM)pCtx->hwndNextInChain, CBChainPingProc, (ULONG_PTR) pCtx);
198	} break;
199
200	case WM_CLOSE:
201	{
202	/* Do nothing. Ignore the message. */
203	} break;
204
205	case WM_RENDERFORMAT:
206	{
207	/* Insert the requested clipboard format data into the clipboard. */
208	uint32_t u32Format = 0;
209	UINT format = (UINT)wParam;
210
211	Log(("VBoxTray: vboxClipboardProcessMsg: WM_RENDERFORMAT, format = %x\n", format));
212	switch (format)
213	{
214	case CF_UNICODETEXT:
215	u32Format \|= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
216	break;
217
218	case CF_DIB:
219	u32Format \|= VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
220	break;
221
222	default:
223	if (format >= 0xC000)
224	{
225	TCHAR szFormatName[256];
226
227	int cActual = GetClipboardFormatName(format, szFormatName, sizeof(szFormatName)/sizeof (TCHAR));
228	if (cActual)
229	{
230	if (strcmp (szFormatName, "HTML Format") == 0)
231	{
232	u32Format \|= VBOX_SHARED_CLIPBOARD_FMT_HTML;
233	}
234	}
235	}
236	break;
237	}
238
239	if (u32Format == 0)
240	{
241	/* Unsupported clipboard format is requested. */
242	Log(("VBoxTray: vboxClipboardProcessMsg: Unsupported clipboard format requested: %ld\n", u32Format));
243	EmptyClipboard();
244	}
245	else
246	{
247	const uint32_t cbPrealloc = 4096; /* @todo r=andy Make it dynamic for supporting larger text buffers! */
248	uint32_t cb = 0;
249
250	/* Preallocate a buffer, most of small text transfers will fit into it. */
251	HANDLE hMem = GlobalAlloc(GMEM_DDESHARE \| GMEM_MOVEABLE, cbPrealloc);
252	Log(("VBoxTray: vboxClipboardProcessMsg: Preallocated handle hMem = %p\n", hMem));
253
254	if (hMem)
255	{
256	void *pMem = GlobalLock(hMem);
257	Log(("VBoxTray: vboxClipboardProcessMsg: Locked pMem = %p, GlobalSize = %ld\n", pMem, GlobalSize(hMem)));
258
259	if (pMem)
260	{
261	/* Read the host data to the preallocated buffer. */
262	int vboxrc = VbglR3ClipboardReadData(pCtx->u32ClientID, u32Format, pMem, cbPrealloc, &cb);
263	Log(("VBoxTray: vboxClipboardProcessMsg: VbglR3ClipboardReadData returned with rc = %Rrc\n", vboxrc));
264
265	if (RT_SUCCESS(vboxrc))
266	{
267	if (cb == 0)
268	{
269	/* 0 bytes returned means the clipboard is empty.
270	* Deallocate the memory and set hMem to NULL to get to
271	* the clipboard empty code path. */
272	GlobalUnlock(hMem);
273	GlobalFree(hMem);
274	hMem = NULL;
275	}
276	else if (cb > cbPrealloc)
277	{
278	GlobalUnlock(hMem);
279
280	/* The preallocated buffer is too small, adjust the size. */
281	hMem = GlobalReAlloc(hMem, cb, 0);
282	Log(("VBoxTray: vboxClipboardProcessMsg: Reallocated hMem = %p\n", hMem));
283
284	if (hMem)
285	{
286	pMem = GlobalLock(hMem);
287	Log(("VBoxTray: vboxClipboardProcessMsg: Locked pMem = %p, GlobalSize = %ld\n", pMem, GlobalSize(hMem)));
288
289	if (pMem)
290	{
291	/* Read the host data to the preallocated buffer. */
292	uint32_t cbNew = 0;
293	vboxrc = VbglR3ClipboardReadData(pCtx->u32ClientID, u32Format, pMem, cb, &cbNew);
294	Log(("VBoxTray: VbglR3ClipboardReadData returned with rc = %Rrc, cb = %d, cbNew = %d\n", vboxrc, cb, cbNew));
295
296	if (RT_SUCCESS (vboxrc) && cbNew <= cb)
297	{
298	cb = cbNew;
299	}
300	else
301	{
302	GlobalUnlock(hMem);
303	GlobalFree(hMem);
304	hMem = NULL;
305	}
306	}
307	else
308	{
309	GlobalFree(hMem);
310	hMem = NULL;
311	}
312	}
313	}
314
315	if (hMem)
316	{
317	/* pMem is the address of the data. cb is the size of returned data. */
318	/* Verify the size of returned text, the memory block for clipboard
319	* must have the exact string size.
320	*/
321	if (u32Format == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
322	{
323	size_t cbActual = 0;
324	HRESULT hrc = StringCbLengthW((LPWSTR)pMem, cb, &cbActual);
325	if (FAILED (hrc))
326	{
327	/* Discard invalid data. */
328	GlobalUnlock(hMem);
329	GlobalFree(hMem);
330	hMem = NULL;
331	}
332	else
333	{
334	/* cbActual is the number of bytes, excluding those used
335	* for the terminating null character.
336	*/
337	cb = (uint32_t)(cbActual + 2);
338	}
339	}
340	}
341
342	if (hMem)
343	{
344	GlobalUnlock(hMem);
345
346	hMem = GlobalReAlloc(hMem, cb, 0);
347	Log(("VBoxTray: vboxClipboardProcessMsg: Reallocated hMem = %p\n", hMem));
348
349	if (hMem)
350	{
351	/* 'hMem' contains the host clipboard data.
352	* size is 'cb' and format is 'format'. */
353	HANDLE hClip = SetClipboardData(format, hMem);
354	Log(("VBoxTray: vboxClipboardProcessMsg: WM_RENDERFORMAT hClip = %p\n", hClip));
355
356	if (hClip)
357	{
358	/* The hMem ownership has gone to the system. Finish the processing. */
359	break;
360	}
361
362	/* Cleanup follows. */
363	}
364	}
365	}
366	if (hMem)
367	GlobalUnlock(hMem);
368	}
369	if (hMem)
370	GlobalFree(hMem);
371	}
372
373	/* Something went wrong. */
374	EmptyClipboard();
375	}
376	} break;
377
378	case WM_RENDERALLFORMATS:
379	{
380	/* Do nothing. The clipboard formats will be unavailable now, because the
381	* windows is to be destroyed and therefore the guest side becomes inactive.
382	*/
383	if (OpenClipboard(hwnd))
384	{
385	EmptyClipboard();
386	CloseClipboard();
387	}
388	} break;
389
390	case WM_USER:
391	{
392	/* Announce available formats. Do not insert data, they will be inserted in WM_RENDER. /
393	uint32_t u32Formats = (uint32_t)lParam;
394
395	if (FALSE == OpenClipboard(hwnd))
396	{
397	Log(("VBoxTray: vboxClipboardProcessMsg: WM_USER: Failed to open clipboard! Last error = %ld\n", GetLastError()));
398	}
399	else
400	{
401	EmptyClipboard();
402
403	HANDLE hClip = NULL;
404
405	if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
406	{
407	Log(("VBoxTray: vboxClipboardProcessMsg: WM_USER: VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT\n"));
408	hClip = SetClipboardData(CF_UNICODETEXT, NULL);
409	}
410
411	if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
412	{
413	Log(("VBoxTray: vboxClipboardProcessMsg: WM_USER: VBOX_SHARED_CLIPBOARD_FMT_BITMAP\n"));
414	hClip = SetClipboardData(CF_DIB, NULL);
415	}
416
417	if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_HTML)
418	{
419	UINT format = RegisterClipboardFormat ("HTML Format");
420	Log(("VBoxTray: vboxClipboardProcessMsg: WM_USER: VBOX_SHARED_CLIPBOARD_FMT_HTML 0x%04X\n", format));
421	if (format != 0)
422	{
423	hClip = SetClipboardData(format, NULL);
424	}
425	}
426
427	CloseClipboard();
428	Log(("VBoxTray: vboxClipboardProcessMsg: WM_USER: hClip = %p, err = %ld\n", hClip, GetLastError ()));
429	}
430	} break;
431
432	case WM_USER + 1:
433	{
434	/* Send data in the specified format to the host. */
435	uint32_t u32Formats = (uint32_t)lParam;
436	HANDLE hClip = NULL;
437
438	if (FALSE == OpenClipboard(hwnd))
439	{
440	Log(("VBoxTray: vboxClipboardProcessMsg: WM_USER: Failed to open clipboard! Last error = %ld\n", GetLastError()));
441	}
442	else
443	{
444	int vboxrc;
445	if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
446	{
447	hClip = GetClipboardData(CF_DIB);
448
449	if (hClip != NULL)
450	{
451	LPVOID lp = GlobalLock(hClip);
452	if (lp != NULL)
453	{
454	Log(("VBoxTray: vboxClipboardProcessMsg: WM_USER + 1: CF_DIB\n"));
455	vboxrc = VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_BITMAP,
456	lp, GlobalSize(hClip));
457	GlobalUnlock(hClip);
458	}
459	else
460	{
461	hClip = NULL;
462	}
463	}
464	}
465	else if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
466	{
467	hClip = GetClipboardData(CF_UNICODETEXT);
468
469	if (hClip != NULL)
470	{
471	LPWSTR uniString = (LPWSTR)GlobalLock(hClip);
472
473	if (uniString != NULL)
474	{
475	Log(("VBoxTray: vboxClipboardProcessMsg: WM_USER + 1: CF_UNICODETEXT\n"));
476	vboxrc = VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
477	uniString, (lstrlenW(uniString) + 1) * 2);
478	GlobalUnlock(hClip);
479	}
480	else
481	{
482	hClip = NULL;
483	}
484	}
485	}
486	else if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_HTML)
487	{
488	UINT format = RegisterClipboardFormat ("HTML Format");
489	if (format != 0)
490	{
491	hClip = GetClipboardData(format);
492	if (hClip != NULL)
493	{
494	LPVOID lp = GlobalLock(hClip);
495
496	if (lp != NULL)
497	{
498	Log(("VBoxTray: vboxClipboardProcessMsg: WM_USER + 1: CF_HTML\n"));
499	vboxrc = VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_HTML,
500	lp, GlobalSize(hClip));
501	GlobalUnlock(hClip);
502	}
503	else
504	{
505	hClip = NULL;
506	}
507	}
508	}
509	}
510
511	CloseClipboard();
512	}
513
514	if (hClip == NULL)
515	{
516	/* Requested clipboard format is not available, send empty data. */
517	VbglR3ClipboardWriteData(pCtx->u32ClientID, 0, NULL, 0);
518	}
519	} break;
520
521	default:
522	{
523	rc = DefWindowProc(hwnd, msg, wParam, lParam);
524	}
525	}
526
527	Log(("VBoxTray: vboxClipboardProcessMsg returned with rc = %ld\n", rc));
528	return rc;
529	}
530
531	static LRESULT CALLBACK vboxClipboardWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
532
533	static int vboxClipboardInit (VBOXCLIPBOARDCONTEXT *pCtx)
534	{
535	/* Register the Window Class. */
536	WNDCLASS wc;
537
538	wc.style = CS_NOCLOSE;
539	wc.lpfnWndProc = vboxClipboardWndProc;
540	wc.cbClsExtra = 0;
541	wc.cbWndExtra = 0;
542	wc.hInstance = pCtx->pEnv->hInstance;
543	wc.hIcon = NULL;
544	wc.hCursor = NULL;
545	wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
546	wc.lpszMenuName = NULL;
547	wc.lpszClassName = gachWindowClassName;
548
549	pCtx->atomWindowClass = RegisterClass (&wc);
550
551	int rc = VINF_SUCCESS;
552	if (pCtx->atomWindowClass == 0)
553	{
554	rc = VERR_NOT_SUPPORTED;
555	}
556	else
557	{
558	/* Create the window. */
559	pCtx->hwnd = CreateWindowEx (WS_EX_TOOLWINDOW \| WS_EX_TRANSPARENT \| WS_EX_TOPMOST,
560	gachWindowClassName, gachWindowClassName,
561	WS_POPUPWINDOW,
562	-200, -200, 100, 100, NULL, NULL, pCtx->pEnv->hInstance, NULL);
563
564	if (pCtx->hwnd == NULL)
565	{
566	rc = VERR_NOT_SUPPORTED;
567	}
568	else
569	{
570	SetWindowPos(pCtx->hwnd, HWND_TOPMOST, -200, -200, 0, 0,
571	SWP_NOACTIVATE \| SWP_HIDEWINDOW \| SWP_NOCOPYBITS \| SWP_NOREDRAW \| SWP_NOSIZE);
572
573	addToCBChain(pCtx);
574	pCtx->timerRefresh = SetTimer(pCtx->hwnd, 0, 10 * 1000, NULL);
575	}
576	}
577
578	Log(("VBoxTray: vboxClipboardInit returned with rc = %Rrc\n", rc));
579	return rc;
580	}
581
582	static void vboxClipboardDestroy(VBOXCLIPBOARDCONTEXT *pCtx)
583	{
584	if (pCtx->hwnd)
585	{
586	removeFromCBChain(pCtx);
587	if (pCtx->timerRefresh)
588	KillTimer(pCtx->hwnd, 0);
589
590	DestroyWindow (pCtx->hwnd);
591	pCtx->hwnd = NULL;
592	}
593
594	if (pCtx->atomWindowClass != 0)
595	{
596	UnregisterClass(gachWindowClassName, pCtx->pEnv->hInstance);
597	pCtx->atomWindowClass = 0;
598	}
599	}
600
601	/* Static since it is the single instance. Directly used in the windows proc. */
602	static VBOXCLIPBOARDCONTEXT gCtx = { NULL };
603
604	static LRESULT CALLBACK vboxClipboardWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
605	{
606	/* Forward with proper context. */
607	return vboxClipboardProcessMsg(&gCtx, hwnd, msg, wParam, lParam);
608	}
609
610	int VBoxClipboardInit(const VBOXSERVICEENV pEnv, void ppInstance, bool pfStartThread)
611	{
612	Log(("VBoxTray: VboxClipboardInit\n"));
613	if (gCtx.pEnv)
614	{
615	/* Clipboard was already initialized. 2 or more instances are not supported. */
616	return VERR_NOT_SUPPORTED;
617	}
618
619	RT_ZERO (gCtx);
620	gCtx.pEnv = pEnv;
621
622	int rc = VbglR3ClipboardConnect(&gCtx.u32ClientID);
623	if (RT_SUCCESS (rc))
624	{
625	rc = vboxClipboardInit(&gCtx);
626	if (RT_SUCCESS (rc))
627	{
628	/* Always start the thread for host messages. */
629	*pfStartThread = true;
630	}
631	else
632	{
633	VbglR3ClipboardDisconnect(gCtx.u32ClientID);
634	}
635	}
636
637	if (RT_SUCCESS(rc))
638	*ppInstance = &gCtx;
639	return rc;
640	}
641
642	unsigned __stdcall VBoxClipboardThread(void *pInstance)
643	{
644	Log(("VBoxTray: VBoxClipboardThread\n"));
645
646	VBOXCLIPBOARDCONTEXT pCtx = (VBOXCLIPBOARDCONTEXT )pInstance;
647	AssertPtr(pCtx);
648
649	/* The thread waits for incoming messages from the host. */
650	for (;;)
651	{
652	uint32_t u32Msg;
653	uint32_t u32Formats;
654	int rc = VbglR3ClipboardGetHostMsg(pCtx->u32ClientID, &u32Msg, &u32Formats);
655	if (RT_FAILURE(rc))
656	{
657	Log(("VBoxTray: VBoxClipboardThread: Failed to call the driver for host message! rc = %Rrc\n", rc));
658	if (rc == VERR_INTERRUPTED)
659	{
660	/* Wait for termination event. */
661	WaitForSingleObject(pCtx->pEnv->hStopEvent, INFINITE);
662	break;
663	}
664	/* Wait a bit before retrying. */
665	AssertPtr(pCtx->pEnv);
666	if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 1000) == WAIT_OBJECT_0)
667	{
668	break;
669	}
670	continue;
671	}
672	else
673	{
674	Log(("VBoxTray: VBoxClipboardThread: VbglR3ClipboardGetHostMsg u32Msg = %ld, u32Formats = %ld\n", u32Msg, u32Formats));
675	switch (u32Msg)
676	{
677	case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS:
678	{
679	/* The host has announced available clipboard formats.
680	* Forward the information to the window, so it can later
681	* respond to WM_RENDERFORMAT message. */
682	::PostMessage (pCtx->hwnd, WM_USER, 0, u32Formats);
683	} break;
684
685	case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
686	{
687	/* The host needs data in the specified format. */
688	::PostMessage (pCtx->hwnd, WM_USER + 1, 0, u32Formats);
689	} break;
690
691	case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
692	{
693	/* The host is terminating. */
694	rc = VERR_INTERRUPTED;
695	} break;
696
697	default:
698	{
699	Log(("VBoxTray: VBoxClipboardThread: Unsupported message from host! Message = %ld\n", u32Msg));
700	}
701	}
702	}
703	}
704	return 0;
705	}
706
707	void VBoxClipboardDestroy(const VBOXSERVICEENV pEnv, void pInstance)
708	{
709	VBOXCLIPBOARDCONTEXT pCtx = (VBOXCLIPBOARDCONTEXT )pInstance;
710	if (pCtx != &gCtx)
711	{
712	Log(("VBoxTray: VBoxClipboardDestroy: invalid instance %p (our = %p)!\n", pCtx, &gCtx));
713	pCtx = &gCtx;
714	}
715
716	vboxClipboardDestroy (pCtx);
717	VbglR3ClipboardDisconnect(pCtx->u32ClientID);
718	memset (pCtx, 0, sizeof (*pCtx));
719	return;
720	}
721

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

source: vbox/trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp@ 34575

Download in other formats: