VBoxClipboard-win.cpp@ 13835

Last change on this file since 13835 was 13835, checked in by vboxsync, 16 years ago
s/VBOX_SUCCESS/RT_SUCCESS/g s/VBOX_FAILURE/RT_FAILURE/g - VBOX_SUCCESS and VBOX_FAILURE have NOT been retired (because old habbits die hard) just sligtly deprecated.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 20.5 KB

Line
1	/** @file
2	* Shared Clipboard: Win32 host.
3	*/
4
5	/*
6	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*
16	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
17	* Clara, CA 95054 USA or visit http://www.sun.com if you need
18	* additional information or have any questions.
19	*/
20
21	#include <windows.h>
22
23	#include <VBox/HostServices/VBoxClipboardSvc.h>
24
25	#include <iprt/alloc.h>
26	#include <iprt/string.h>
27	#include <iprt/asm.h>
28	#include <iprt/assert.h>
29	#include <iprt/thread.h>
30	#include <process.h>
31
32	#include "VBoxClipboard.h"
33
34	#define dprintf Log
35
36	static char gachWindowClassName[] = "VBoxSharedClipboardClass";
37
38	struct _VBOXCLIPBOARDCONTEXT
39	{
40	HWND hwnd;
41	HWND hwndNextInChain;
42
43	RTTHREAD thread;
44	bool volatile fTerminate;
45
46	HANDLE hRenderEvent;
47
48	VBOXCLIPBOARDCLIENTDATA *pClient;
49	};
50
51	/* Only one client is supported. There seems to be no need for more clients. */
52	static VBOXCLIPBOARDCONTEXT g_ctx;
53
54
55	#ifdef LOG_ENABLED
56	void vboxClipboardDump(const void *pv, size_t cb, uint32_t u32Format)
57	{
58	if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
59	{
60	Log(("DUMP: VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT:\n"));
61	if (pv && cb)
62	{
63	Log(("%ls\n", pv));
64	}
65	else
66	{
67	Log(("%p %d\n", pv, cb));
68	}
69	}
70	else if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
71	{
72	dprintf(("DUMP: VBOX_SHARED_CLIPBOARD_FMT_BITMAP\n"));
73	}
74	else if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_HTML)
75	{
76	Log(("DUMP: VBOX_SHARED_CLIPBOARD_FMT_HTML:\n"));
77	if (pv && cb)
78	{
79	Log(("%s\n", pv));
80	}
81	else
82	{
83	Log(("%p %d\n", pv, cb));
84	}
85	}
86	else
87	{
88	dprintf(("DUMP: invalid format %02X\n", u32Format));
89	}
90	}
91	#else
92	#define vboxClipboardDump(__pv, __cb, __format) do { NOREF(__pv); NOREF(__cb); NOREF(__format); } while (0)
93	#endif /* LOG_ENABLED */
94
95	static void vboxClipboardGetData (uint32_t u32Format, const void *pvSrc, uint32_t cbSrc,
96	void pvDst, uint32_t cbDst, uint32_t pcbActualDst)
97	{
98	dprintf (("vboxClipboardGetData.\n"));
99
100	*pcbActualDst = cbSrc;
101
102	LogFlow(("vboxClipboardGetData cbSrc = %d, cbDst = %d\n", cbSrc, cbDst));
103
104	if (cbSrc > cbDst)
105	{
106	/* Do not copy data. The dst buffer is not enough. */
107	return;
108	}
109
110	memcpy (pvDst, pvSrc, cbSrc);
111
112	vboxClipboardDump(pvDst, cbSrc, u32Format);
113
114	return;
115	}
116
117	static int vboxClipboardReadDataFromClient (VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format)
118	{
119	Assert(pCtx->pClient);
120	Assert(pCtx->pClient->data.pv == NULL && pCtx->pClient->data.cb == 0 && pCtx->pClient->data.u32Format == 0);
121
122	LogFlow(("vboxClipboardReadDataFromClient u32Format = %02X\n", u32Format));
123
124	ResetEvent (pCtx->hRenderEvent);
125
126	vboxSvcClipboardReportMsg (pCtx->pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Format);
127
128	WaitForSingleObject(pCtx->hRenderEvent, INFINITE);
129
130	LogFlow(("vboxClipboardReadDataFromClient wait completed\n"));
131
132	return VINF_SUCCESS;
133	}
134
135	static void vboxClipboardChanged (VBOXCLIPBOARDCONTEXT *pCtx)
136	{
137	LogFlow(("vboxClipboardChanged\n"));
138
139	if (pCtx->pClient == NULL)
140	{
141	return;
142	}
143
144	/* Query list of available formats and report to host. */
145	if (OpenClipboard (pCtx->hwnd))
146	{
147	uint32_t u32Formats = 0;
148
149	UINT format = 0;
150
151	while ((format = EnumClipboardFormats (format)) != 0)
152	{
153	LogFlow(("vboxClipboardChanged format %#x\n", format));
154	switch (format)
155	{
156	case CF_UNICODETEXT:
157	case CF_TEXT:
158	u32Formats \|= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
159	break;
160
161	case CF_DIB:
162	case CF_BITMAP:
163	u32Formats \|= VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
164	break;
165
166	default:
167	if (format >= 0xC000)
168	{
169	TCHAR szFormatName[256];
170
171	int cActual = GetClipboardFormatName(format, szFormatName, sizeof(szFormatName)/sizeof (TCHAR));
172
173	if (cActual)
174	{
175	if (strcmp (szFormatName, "HTML Format") == 0)
176	{
177	u32Formats \|= VBOX_SHARED_CLIPBOARD_FMT_HTML;
178	}
179	}
180	}
181	break;
182	}
183	}
184
185	CloseClipboard ();
186
187	LogFlow(("vboxClipboardChanged u32Formats %02X\n", u32Formats));
188
189	vboxSvcClipboardReportMsg (pCtx->pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS, u32Formats);
190	}
191	}
192
193	static LRESULT CALLBACK vboxClipboardWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
194	{
195	LRESULT rc = 0;
196
197	VBOXCLIPBOARDCONTEXT *pCtx = &g_ctx;
198
199	switch (msg)
200	{
201	case WM_CHANGECBCHAIN:
202	{
203	Log(("WM_CHANGECBCHAIN\n"));
204
205	HWND hwndRemoved = (HWND)wParam;
206	HWND hwndNext = (HWND)lParam;
207
208	if (hwndRemoved == pCtx->hwndNextInChain)
209	{
210	/* The window that was next to our in the chain is being removed.
211	* Relink to the new next window.
212	*/
213	pCtx->hwndNextInChain = hwndNext;
214	}
215	else
216	{
217	if (pCtx->hwndNextInChain)
218	{
219	/* Pass the message further. */
220	rc = SendMessage (pCtx->hwndNextInChain, WM_CHANGECBCHAIN, wParam, lParam);
221	}
222	}
223	} break;
224
225	case WM_DRAWCLIPBOARD:
226	{
227	Log(("WM_DRAWCLIPBOARD next %p\n", pCtx->hwndNextInChain));
228
229	if (GetClipboardOwner () != hwnd)
230	{
231	/* Clipboard was updated by another application. */
232	vboxClipboardChanged (pCtx);
233	}
234
235	if (pCtx->hwndNextInChain)
236	{
237	/* Pass the message to next windows in the clipboard chain. */
238	rc = SendMessage (pCtx->hwndNextInChain, msg, wParam, lParam);
239	}
240	} break;
241
242	case WM_CLOSE:
243	{
244	/* Do nothing. Ignore the message. */
245	} break;
246
247	case WM_RENDERFORMAT:
248	{
249	/* Insert the requested clipboard format data into the clipboard. */
250	uint32_t u32Format = 0;
251
252	UINT format = (UINT)wParam;
253
254	Log(("WM_RENDERFORMAT %d\n", format));
255
256	switch (format)
257	{
258	case CF_UNICODETEXT:
259	u32Format \|= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
260	break;
261
262	case CF_DIB:
263	u32Format \|= VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
264	break;
265
266	default:
267	if (format >= 0xC000)
268	{
269	TCHAR szFormatName[256];
270
271	int cActual = GetClipboardFormatName(format, szFormatName, sizeof(szFormatName)/sizeof (TCHAR));
272
273	if (cActual)
274	{
275	if (strcmp (szFormatName, "HTML Format") == 0)
276	{
277	u32Format \|= VBOX_SHARED_CLIPBOARD_FMT_HTML;
278	}
279	}
280	}
281	break;
282	}
283
284	if (u32Format == 0 \|\| pCtx->pClient == NULL)
285	{
286	/* Unsupported clipboard format is requested. */
287	Log(("WM_RENDERFORMAT unsupported format requested or client is not active.\n"));
288	EmptyClipboard ();
289	}
290	else
291	{
292	int vboxrc = vboxClipboardReadDataFromClient (pCtx, u32Format);
293
294	dprintf(("vboxClipboardReadDataFromClient vboxrc = %d\n", vboxrc));
295
296	if ( RT_SUCCESS (vboxrc)
297	&& pCtx->pClient->data.pv != NULL
298	&& pCtx->pClient->data.cb > 0
299	&& pCtx->pClient->data.u32Format == u32Format)
300	{
301	HANDLE hMem = GlobalAlloc (GMEM_DDESHARE \| GMEM_MOVEABLE, pCtx->pClient->data.cb);
302
303	dprintf(("hMem %p\n", hMem));
304
305	if (hMem)
306	{
307	void *pMem = GlobalLock (hMem);
308
309	dprintf(("pMem %p, GlobalSize %d\n", pMem, GlobalSize (hMem)));
310
311	if (pMem)
312	{
313	Log(("WM_RENDERFORMAT setting data\n"));
314
315	if (pCtx->pClient->data.pv)
316	{
317	memcpy (pMem, pCtx->pClient->data.pv, pCtx->pClient->data.cb);
318
319	RTMemFree (pCtx->pClient->data.pv);
320	pCtx->pClient->data.pv = NULL;
321	}
322
323	pCtx->pClient->data.cb = 0;
324	pCtx->pClient->data.u32Format = 0;
325
326	/* The memory must be unlocked before inserting to the Clipboard. */
327	GlobalUnlock (hMem);
328
329	/* 'hMem' contains the host clipboard data.
330	* size is 'cb' and format is 'format'.
331	*/
332	HANDLE hClip = SetClipboardData (format, hMem);
333
334	dprintf(("vboxClipboardHostEvent hClip %p\n", hClip));
335
336	if (hClip)
337	{
338	/* The hMem ownership has gone to the system. Nothing to do. */
339	break;
340	}
341	}
342
343	GlobalFree (hMem);
344	}
345	}
346
347	RTMemFree (pCtx->pClient->data.pv);
348	pCtx->pClient->data.pv = NULL;
349	pCtx->pClient->data.cb = 0;
350	pCtx->pClient->data.u32Format = 0;
351
352	/* Something went wrong. */
353	EmptyClipboard ();
354	}
355	} break;
356
357	case WM_RENDERALLFORMATS:
358	{
359	Log(("WM_RENDERALLFORMATS\n"));
360
361	/* Do nothing. The clipboard formats will be unavailable now, because the
362	* windows is to be destroyed and therefore the guest side becames inactive.
363	*/
364	if (OpenClipboard (hwnd))
365	{
366	EmptyClipboard();
367
368	CloseClipboard();
369	}
370	} break;
371
372	case WM_USER:
373	{
374	if (pCtx->pClient == NULL \|\| pCtx->pClient->fMsgFormats)
375	{
376	/* Host has pending formats message. Ignore the guest announcement,
377	* because host clipboard has more priority.
378	*/
379	break;
380	}
381
382	/* Announce available formats. Do not insert data, they will be inserted in WM_RENDER. /
383	uint32_t u32Formats = (uint32_t)lParam;
384
385	Log(("WM_USER u32Formats = %02X\n", u32Formats));
386
387	if (OpenClipboard (hwnd))
388	{
389	EmptyClipboard();
390
391	Log(("WM_USER emptied clipboard\n"));
392
393	HANDLE hClip = NULL;
394
395	if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
396	{
397	dprintf(("window proc WM_USER: VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT\n"));
398
399	hClip = SetClipboardData (CF_UNICODETEXT, NULL);
400	}
401
402	if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
403	{
404	dprintf(("window proc WM_USER: VBOX_SHARED_CLIPBOARD_FMT_BITMAP\n"));
405
406	hClip = SetClipboardData (CF_DIB, NULL);
407	}
408
409	if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_HTML)
410	{
411	UINT format = RegisterClipboardFormat ("HTML Format");
412	dprintf(("window proc WM_USER: VBOX_SHARED_CLIPBOARD_FMT_HTML 0x%04X\n", format));
413	if (format != 0)
414	{
415	hClip = SetClipboardData (format, NULL);
416	}
417	}
418
419	CloseClipboard();
420
421	dprintf(("window proc WM_USER: hClip %p, err %d\n", hClip, GetLastError ()));
422	}
423	else
424	{
425	dprintf(("window proc WM_USER: failed to open clipboard\n"));
426	}
427	} break;
428
429	default:
430	{
431	Log(("WM_ %p\n", msg));
432	rc = DefWindowProc (hwnd, msg, wParam, lParam);
433	}
434	}
435
436	Log(("WM_ rc %d\n", rc));
437	return rc;
438	}
439
440	DECLCALLBACK(int) VBoxClipboardThread (RTTHREAD ThreadSelf, void *pInstance)
441	{
442	/* Create a window and make it a clipboard viewer. */
443	int rc = VINF_SUCCESS;
444
445	LogFlow(("VBoxClipboardThread\n"));
446
447	VBOXCLIPBOARDCONTEXT *pCtx = &g_ctx;
448
449	HINSTANCE hInstance = (HINSTANCE)GetModuleHandle (NULL);
450
451	/* Register the Window Class. */
452	WNDCLASS wc;
453
454	wc.style = CS_NOCLOSE;
455	wc.lpfnWndProc = vboxClipboardWndProc;
456	wc.cbClsExtra = 0;
457	wc.cbWndExtra = 0;
458	wc.hInstance = hInstance;
459	wc.hIcon = NULL;
460	wc.hCursor = NULL;
461	wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
462	wc.lpszMenuName = NULL;
463	wc.lpszClassName = gachWindowClassName;
464
465	ATOM atomWindowClass = RegisterClass (&wc);
466
467	if (atomWindowClass == 0)
468	{
469	Log(("Failed to register window class\n"));
470	rc = VERR_NOT_SUPPORTED;
471	}
472	else
473	{
474	/* Create the window. */
475	pCtx->hwnd = CreateWindowEx (WS_EX_TOOLWINDOW \| WS_EX_TRANSPARENT \| WS_EX_TOPMOST,
476	gachWindowClassName, gachWindowClassName,
477	WS_POPUPWINDOW,
478	-200, -200, 100, 100, NULL, NULL, hInstance, NULL);
479
480	if (pCtx->hwnd == NULL)
481	{
482	Log(("Failed to create window\n"));
483	rc = VERR_NOT_SUPPORTED;
484	}
485	else
486	{
487	SetWindowPos(pCtx->hwnd, HWND_TOPMOST, -200, -200, 0, 0,
488	SWP_NOACTIVATE \| SWP_HIDEWINDOW \| SWP_NOCOPYBITS \| SWP_NOREDRAW \| SWP_NOSIZE);
489
490	pCtx->hwndNextInChain = SetClipboardViewer (pCtx->hwnd);
491
492	MSG msg;
493	while (GetMessage(&msg, NULL, 0, 0) && !pCtx->fTerminate)
494	{
495	TranslateMessage(&msg);
496	DispatchMessage(&msg);
497	}
498	}
499	}
500
501	if (pCtx->hwnd)
502	{
503	ChangeClipboardChain (pCtx->hwnd, pCtx->hwndNextInChain);
504	pCtx->hwndNextInChain = NULL;
505
506	DestroyWindow (pCtx->hwnd);
507	pCtx->hwnd = NULL;
508	}
509
510	if (atomWindowClass != 0)
511	{
512	UnregisterClass (gachWindowClassName, hInstance);
513	atomWindowClass = 0;
514	}
515
516	return 0;
517	}
518
519	/*
520	* Public platform dependent functions.
521	*/
522	int vboxClipboardInit (void)
523	{
524	int rc = VINF_SUCCESS;
525
526	g_ctx.hRenderEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
527
528	rc = RTThreadCreate (&g_ctx.thread, VBoxClipboardThread, NULL, 65536,
529	RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SHCLIP");
530
531	if (RT_FAILURE (rc))
532	{
533	CloseHandle (g_ctx.hRenderEvent);
534	}
535
536	return rc;
537	}
538
539	void vboxClipboardDestroy (void)
540	{
541	Log(("vboxClipboardDestroy\n"));
542
543	/* Set the termination flag and ping the window thread. */
544	ASMAtomicWriteBool (&g_ctx.fTerminate, true);
545
546	if (g_ctx.hwnd)
547	{
548	PostMessage (g_ctx.hwnd, WM_CLOSE, 0, 0);
549	}
550
551	CloseHandle (g_ctx.hRenderEvent);
552
553	/* Wait for the window thread to terminate. */
554	RTThreadWait (g_ctx.thread, RT_INDEFINITE_WAIT, NULL);
555
556	g_ctx.thread = NIL_RTTHREAD;
557	}
558
559	int vboxClipboardConnect (VBOXCLIPBOARDCLIENTDATA *pClient)
560	{
561	Log(("vboxClipboardConnect\n"));
562
563	if (g_ctx.pClient != NULL)
564	{
565	/* One client only. */
566	return VERR_NOT_SUPPORTED;
567	}
568
569	pClient->pCtx = &g_ctx;
570
571	pClient->pCtx->pClient = pClient;
572
573	/* Synch the host clipboard content with the client. */
574	vboxClipboardSync (pClient);
575
576	return VINF_SUCCESS;
577	}
578
579	int vboxClipboardSync (VBOXCLIPBOARDCLIENTDATA *pClient)
580	{
581	/* Synch the host clipboard content with the client. */
582	vboxClipboardChanged (pClient->pCtx);
583
584	return VINF_SUCCESS;
585	}
586
587	void vboxClipboardDisconnect (VBOXCLIPBOARDCLIENTDATA *pClient)
588	{
589	Log(("vboxClipboardDisconnect\n"));
590
591	g_ctx.pClient = NULL;
592	}
593
594	void vboxClipboardFormatAnnounce (VBOXCLIPBOARDCLIENTDATA *pClient, uint32_t u32Formats)
595	{
596	/*
597	* The guest announces formats. Forward to the window thread.
598	*/
599	PostMessage (pClient->pCtx->hwnd, WM_USER, 0, u32Formats);
600	}
601
602	int vboxClipboardReadData (VBOXCLIPBOARDCLIENTDATA pClient, uint32_t u32Format, void pv, uint32_t cb, uint32_t *pcbActual)
603	{
604	LogFlow(("vboxClipboardReadData: u32Format = %02X\n", u32Format));
605
606	HANDLE hClip = NULL;
607
608	/*
609	* The guest wants to read data in the given format.
610	*/
611	if (OpenClipboard (pClient->pCtx->hwnd))
612	{
613	dprintf(("Clipboard opened.\n"));
614
615	if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
616	{
617	hClip = GetClipboardData (CF_DIB);
618
619	if (hClip != NULL)
620	{
621	LPVOID lp = GlobalLock (hClip);
622
623	if (lp != NULL)
624	{
625	dprintf(("CF_DIB\n"));
626
627	vboxClipboardGetData (VBOX_SHARED_CLIPBOARD_FMT_BITMAP, lp, GlobalSize (hClip),
628	pv, cb, pcbActual);
629
630	GlobalUnlock(hClip);
631	}
632	else
633	{
634	hClip = NULL;
635	}
636	}
637	}
638	else if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
639	{
640	hClip = GetClipboardData(CF_UNICODETEXT);
641
642	if (hClip != NULL)
643	{
644	LPWSTR uniString = (LPWSTR)GlobalLock (hClip);
645
646	if (uniString != NULL)
647	{
648	dprintf(("CF_UNICODETEXT\n"));
649
650	vboxClipboardGetData (VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, uniString, (lstrlenW (uniString) + 1) * 2,
651	pv, cb, pcbActual);
652
653	GlobalUnlock(hClip);
654	}
655	else
656	{
657	hClip = NULL;
658	}
659	}
660	}
661	else if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_HTML)
662	{
663	UINT format = RegisterClipboardFormat ("HTML Format");
664
665	if (format != 0)
666	{
667	hClip = GetClipboardData (format);
668
669	if (hClip != NULL)
670	{
671	LPVOID lp = GlobalLock (hClip);
672
673	if (lp != NULL)
674	{
675	dprintf(("CF_HTML\n"));
676
677	vboxClipboardGetData (VBOX_SHARED_CLIPBOARD_FMT_HTML, lp, GlobalSize (hClip),
678	pv, cb, pcbActual);
679
680	GlobalUnlock(hClip);
681	}
682	else
683	{
684	hClip = NULL;
685	}
686	}
687	}
688	}
689
690	CloseClipboard ();
691	}
692	else
693	{
694	dprintf(("failed to open clipboard\n"));
695	}
696
697	if (hClip == NULL)
698	{
699	/* Reply with empty data. */
700	vboxClipboardGetData (0, NULL, 0,
701	pv, cb, pcbActual);
702	}
703
704	return VINF_SUCCESS;
705	}
706
707	void vboxClipboardWriteData (VBOXCLIPBOARDCLIENTDATA pClient, void pv, uint32_t cb, uint32_t u32Format)
708	{
709	LogFlow(("vboxClipboardWriteData\n"));
710
711	/*
712	* The guest returns data that was requested in the WM_RENDERFORMAT handler.
713	*/
714	Assert(pClient->data.pv == NULL && pClient->data.cb == 0 && pClient->data.u32Format == 0);
715
716	vboxClipboardDump(pv, cb, u32Format);
717
718	if (cb > 0)
719	{
720	pClient->data.pv = RTMemAlloc (cb);
721
722	if (pClient->data.pv)
723	{
724	memcpy (pClient->data.pv, pv, cb);
725	pClient->data.cb = cb;
726	pClient->data.u32Format = u32Format;
727	}
728	}
729
730	SetEvent(pClient->pCtx->hRenderEvent);
731	}

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

source: vbox/trunk/src/VBox/HostServices/SharedClipboard/VBoxClipboard-win.cpp@ 13835

Download in other formats: