1 | /** @file
|
---|
2 | * Shared Clipboard: Common X11 code.
|
---|
3 | */
|
---|
4 |
|
---|
5 | /*
|
---|
6 | * Copyright (C) 2006-2023 Oracle and/or its affiliates.
|
---|
7 | *
|
---|
8 | * This file is part of VirtualBox base platform packages, as
|
---|
9 | * available from https://www.virtualbox.org.
|
---|
10 | *
|
---|
11 | * This program is free software; you can redistribute it and/or
|
---|
12 | * modify it under the terms of the GNU General Public License
|
---|
13 | * as published by the Free Software Foundation, in version 3 of the
|
---|
14 | * License.
|
---|
15 | *
|
---|
16 | * This program is distributed in the hope that it will be useful, but
|
---|
17 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
19 | * General Public License for more details.
|
---|
20 | *
|
---|
21 | * You should have received a copy of the GNU General Public License
|
---|
22 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
23 | *
|
---|
24 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
25 | */
|
---|
26 |
|
---|
27 | /* Note: to automatically run regression tests on the Shared Clipboard,
|
---|
28 | * execute the tstClipboardGH-X11 testcase. If you often make changes to the
|
---|
29 | * clipboard code, adding the line
|
---|
30 | *
|
---|
31 | * OTHERS += $(PATH_tstClipboardGH-X11)/tstClipboardGH-X11.run
|
---|
32 | *
|
---|
33 | * to LocalConfig.kmk will cause the tests to be run every time the code is
|
---|
34 | * changed.
|
---|
35 | */
|
---|
36 |
|
---|
37 |
|
---|
38 | /*********************************************************************************************************************************
|
---|
39 | * Header Files *
|
---|
40 | *********************************************************************************************************************************/
|
---|
41 | #define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
|
---|
42 |
|
---|
43 | #include <errno.h>
|
---|
44 |
|
---|
45 | #include <dlfcn.h>
|
---|
46 | #include <fcntl.h>
|
---|
47 | #include <unistd.h>
|
---|
48 |
|
---|
49 | #ifdef RT_OS_SOLARIS
|
---|
50 | #include <tsol/label.h>
|
---|
51 | #endif
|
---|
52 |
|
---|
53 | #include <X11/Xlib.h>
|
---|
54 | #include <X11/Xatom.h>
|
---|
55 | #include <X11/Intrinsic.h>
|
---|
56 | #include <X11/Shell.h>
|
---|
57 | #include <X11/Xproto.h>
|
---|
58 | #include <X11/StringDefs.h>
|
---|
59 |
|
---|
60 | #include <iprt/assert.h>
|
---|
61 | #include <iprt/types.h>
|
---|
62 | #include <iprt/mem.h>
|
---|
63 | #include <iprt/semaphore.h>
|
---|
64 | #include <iprt/thread.h>
|
---|
65 | #include <iprt/utf16.h>
|
---|
66 | #include <iprt/uri.h>
|
---|
67 |
|
---|
68 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
|
---|
69 | # include <iprt/cpp/list.h>
|
---|
70 | # include <iprt/cpp/ministring.h>
|
---|
71 | # include <VBox/GuestHost/SharedClipboard-transfers.h>
|
---|
72 | #endif
|
---|
73 |
|
---|
74 | #include <VBox/log.h>
|
---|
75 | #include <VBox/version.h>
|
---|
76 |
|
---|
77 | #include <VBox/GuestHost/SharedClipboard.h>
|
---|
78 | #include <VBox/GuestHost/SharedClipboard-x11.h>
|
---|
79 | #include <VBox/GuestHost/clipboard-helper.h>
|
---|
80 | #include <VBox/HostServices/VBoxClipboardSvc.h>
|
---|
81 |
|
---|
82 | /** Own macro for declaring function visibility / linkage based on whether this
|
---|
83 | * code runs as part of test cases or not. */
|
---|
84 | #ifdef TESTCASE
|
---|
85 | # define SHCL_X11_DECL(x) x
|
---|
86 | #else
|
---|
87 | # define SHCL_X11_DECL(x) static x
|
---|
88 | #endif
|
---|
89 |
|
---|
90 |
|
---|
91 | /*********************************************************************************************************************************
|
---|
92 | * Externals *
|
---|
93 | *********************************************************************************************************************************/
|
---|
94 | #ifdef TESTCASE
|
---|
95 | extern void tstThreadScheduleCall(void (*proc)(void *, void *), void *client_data);
|
---|
96 | extern void tstClipRequestData(SHCLX11CTX* pCtx, SHCLX11FMTIDX target, void *closure);
|
---|
97 | extern void tstRequestTargets(SHCLX11CTX* pCtx);
|
---|
98 | #endif
|
---|
99 |
|
---|
100 |
|
---|
101 | /*********************************************************************************************************************************
|
---|
102 | * Prototypes *
|
---|
103 | *********************************************************************************************************************************/
|
---|
104 | class formats;
|
---|
105 | SHCL_X11_DECL(Atom) clipGetAtom(PSHCLX11CTX pCtx, const char *pszName);
|
---|
106 | SHCL_X11_DECL(void) clipQueryX11Targets(PSHCLX11CTX pCtx);
|
---|
107 |
|
---|
108 | static int clipInitInternal(PSHCLX11CTX pCtx);
|
---|
109 | static void clipUninitInternal(PSHCLX11CTX pCtx);
|
---|
110 |
|
---|
111 |
|
---|
112 | /*********************************************************************************************************************************
|
---|
113 | * Global Variables *
|
---|
114 | *********************************************************************************************************************************/
|
---|
115 |
|
---|
116 | /**
|
---|
117 | * The table maps X11 names to data formats
|
---|
118 | * and to the corresponding VBox clipboard formats.
|
---|
119 | */
|
---|
120 | SHCL_X11_DECL(SHCLX11FMTTABLE) g_aFormats[] =
|
---|
121 | {
|
---|
122 | { "INVALID", SHCLX11FMT_INVALID, VBOX_SHCL_FMT_NONE },
|
---|
123 |
|
---|
124 | { "UTF8_STRING", SHCLX11FMT_UTF8, VBOX_SHCL_FMT_UNICODETEXT },
|
---|
125 | { "text/plain;charset=UTF-8", SHCLX11FMT_UTF8, VBOX_SHCL_FMT_UNICODETEXT },
|
---|
126 | { "text/plain;charset=utf-8", SHCLX11FMT_UTF8, VBOX_SHCL_FMT_UNICODETEXT },
|
---|
127 | { "STRING", SHCLX11FMT_TEXT, VBOX_SHCL_FMT_UNICODETEXT },
|
---|
128 | { "TEXT", SHCLX11FMT_TEXT, VBOX_SHCL_FMT_UNICODETEXT },
|
---|
129 | { "text/plain", SHCLX11FMT_TEXT, VBOX_SHCL_FMT_UNICODETEXT },
|
---|
130 |
|
---|
131 | { "text/html", SHCLX11FMT_HTML, VBOX_SHCL_FMT_HTML },
|
---|
132 | { "text/html;charset=utf-8", SHCLX11FMT_HTML, VBOX_SHCL_FMT_HTML },
|
---|
133 | { "application/x-moz-nativehtml", SHCLX11FMT_HTML, VBOX_SHCL_FMT_HTML },
|
---|
134 |
|
---|
135 | { "image/bmp", SHCLX11FMT_BMP, VBOX_SHCL_FMT_BITMAP },
|
---|
136 | { "image/x-bmp", SHCLX11FMT_BMP, VBOX_SHCL_FMT_BITMAP },
|
---|
137 | { "image/x-MS-bmp", SHCLX11FMT_BMP, VBOX_SHCL_FMT_BITMAP },
|
---|
138 | /** @todo Inkscape exports image/png but not bmp... */
|
---|
139 |
|
---|
140 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
|
---|
141 | { "text/uri-list", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST },
|
---|
142 | { "x-special/gnome-copied-files", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST },
|
---|
143 | { "x-special/nautilus-clipboard", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST },
|
---|
144 | { "application/x-kde-cutselection", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST },
|
---|
145 | /** @todo Anything else we need to add here? */
|
---|
146 | /** @todo Add Wayland / Weston support. */
|
---|
147 | #endif
|
---|
148 | };
|
---|
149 |
|
---|
150 |
|
---|
151 | #ifdef TESTCASE
|
---|
152 | # ifdef RT_OS_SOLARIS_10
|
---|
153 | char XtStrings [] = "";
|
---|
154 | WidgetClassRec* applicationShellWidgetClass;
|
---|
155 | char XtShellStrings [] = "";
|
---|
156 | int XmbTextPropertyToTextList(
|
---|
157 | Display* /* display */,
|
---|
158 | XTextProperty* /* text_prop */,
|
---|
159 | char*** /* list_return */,
|
---|
160 | int* /* count_return */
|
---|
161 | )
|
---|
162 | {
|
---|
163 | return 0;
|
---|
164 | }
|
---|
165 | # else
|
---|
166 | const char XtStrings [] = "";
|
---|
167 | _WidgetClassRec* applicationShellWidgetClass;
|
---|
168 | const char XtShellStrings [] = "";
|
---|
169 | # endif /* RT_OS_SOLARIS_10 */
|
---|
170 | #endif /* TESTCASE */
|
---|
171 |
|
---|
172 |
|
---|
173 | /*********************************************************************************************************************************
|
---|
174 | * Defines *
|
---|
175 | *********************************************************************************************************************************/
|
---|
176 |
|
---|
177 | #define SHCL_MAX_X11_FORMATS RT_ELEMENTS(g_aFormats)
|
---|
178 |
|
---|
179 |
|
---|
180 | /*********************************************************************************************************************************
|
---|
181 | * Internal structures *
|
---|
182 | *********************************************************************************************************************************/
|
---|
183 |
|
---|
184 | /**
|
---|
185 | * A structure containing information about where to store a request
|
---|
186 | * for the X11 clipboard contents.
|
---|
187 | */
|
---|
188 | typedef struct _CLIPREADX11CBREQ
|
---|
189 | {
|
---|
190 | /** The format VBox would like the data in. */
|
---|
191 | SHCLFORMAT uFmtVBox;
|
---|
192 | /** The format we requested from X11. */
|
---|
193 | SHCLX11FMTIDX idxFmtX11;
|
---|
194 | /** The clipboard context this request is associated with. */
|
---|
195 | SHCLX11CTX *pCtx;
|
---|
196 | /** The request structure passed in from the backend. */
|
---|
197 | CLIPREADCBREQ *pReq;
|
---|
198 | } CLIPREADX11CBREQ;
|
---|
199 |
|
---|
200 |
|
---|
201 |
|
---|
202 | #ifdef TESTCASE
|
---|
203 | /**
|
---|
204 | * Return the max. number of elements in the X11 format table.
|
---|
205 | * Used by the testing code in tstClipboardGH-X11.cpp
|
---|
206 | * which cannot use RT_ELEMENTS(g_aFormats) directly.
|
---|
207 | *
|
---|
208 | * @return size_t The number of elements in the g_aFormats array.
|
---|
209 | */
|
---|
210 | SHCL_X11_DECL(size_t) clipReportMaxX11Formats(void)
|
---|
211 | {
|
---|
212 | return (RT_ELEMENTS(g_aFormats));
|
---|
213 | }
|
---|
214 | #endif
|
---|
215 |
|
---|
216 | /**
|
---|
217 | * Returns the atom corresponding to a supported X11 format.
|
---|
218 | *
|
---|
219 | * @returns Found atom to the corresponding X11 format.
|
---|
220 | * @param pCtx The X11 clipboard context to use.
|
---|
221 | * @param uFmtIdx Format index to look up atom for.
|
---|
222 | */
|
---|
223 | static Atom clipAtomForX11Format(PSHCLX11CTX pCtx, SHCLX11FMTIDX uFmtIdx)
|
---|
224 | {
|
---|
225 | AssertReturn(uFmtIdx < RT_ELEMENTS(g_aFormats), 0);
|
---|
226 | return clipGetAtom(pCtx, g_aFormats[uFmtIdx].pcszAtom);
|
---|
227 | }
|
---|
228 |
|
---|
229 | /**
|
---|
230 | * Returns the SHCLX11FMT corresponding to a supported X11 format.
|
---|
231 | *
|
---|
232 | * @return SHCLX11FMT for a specific format index.
|
---|
233 | * @param uFmtIdx Format index to look up SHCLX11CLIPFMT for.
|
---|
234 | */
|
---|
235 | SHCL_X11_DECL(SHCLX11FMT) clipRealFormatForX11Format(SHCLX11FMTIDX uFmtIdx)
|
---|
236 | {
|
---|
237 | AssertReturn(uFmtIdx < RT_ELEMENTS(g_aFormats), SHCLX11FMT_INVALID);
|
---|
238 | return g_aFormats[uFmtIdx].enmFmtX11;
|
---|
239 | }
|
---|
240 |
|
---|
241 | /**
|
---|
242 | * Returns the VBox format corresponding to a supported X11 format.
|
---|
243 | *
|
---|
244 | * @return SHCLFORMAT for a specific format index.
|
---|
245 | * @param uFmtIdx Format index to look up VBox format for.
|
---|
246 | */
|
---|
247 | static SHCLFORMAT clipVBoxFormatForX11Format(SHCLX11FMTIDX uFmtIdx)
|
---|
248 | {
|
---|
249 | AssertReturn(uFmtIdx < RT_ELEMENTS(g_aFormats), VBOX_SHCL_FMT_NONE);
|
---|
250 | return g_aFormats[uFmtIdx].uFmtVBox;
|
---|
251 | }
|
---|
252 |
|
---|
253 | /**
|
---|
254 | * Looks up the X11 format matching a given X11 atom.
|
---|
255 | *
|
---|
256 | * @returns The format on success, NIL_CLIPX11FORMAT on failure.
|
---|
257 | * @param pCtx The X11 clipboard context to use.
|
---|
258 | * @param atomFormat Atom to look up X11 format for.
|
---|
259 | */
|
---|
260 | static SHCLX11FMTIDX clipFindX11FormatByAtom(PSHCLX11CTX pCtx, Atom atomFormat)
|
---|
261 | {
|
---|
262 | for (unsigned i = 0; i < RT_ELEMENTS(g_aFormats); ++i)
|
---|
263 | if (clipAtomForX11Format(pCtx, i) == atomFormat)
|
---|
264 | {
|
---|
265 | LogFlowFunc(("Returning index %u for atom '%s'\n", i, g_aFormats[i].pcszAtom));
|
---|
266 | return i;
|
---|
267 | }
|
---|
268 | return NIL_CLIPX11FORMAT;
|
---|
269 | }
|
---|
270 |
|
---|
271 | /**
|
---|
272 | * Enumerates supported X11 clipboard formats corresponding to given VBox formats.
|
---|
273 | *
|
---|
274 | * @returns The next matching X11 format index in the list, or NIL_CLIPX11FORMAT if there are no more.
|
---|
275 | * @param uFormatsVBox VBox formats to enumerate supported X11 clipboard formats for.
|
---|
276 | * @param lastFmtIdx The value returned from the last call of this function.
|
---|
277 | * Use NIL_CLIPX11FORMAT to start the enumeration.
|
---|
278 | */
|
---|
279 | static SHCLX11FMTIDX clipEnumX11Formats(SHCLFORMATS uFormatsVBox,
|
---|
280 | SHCLX11FMTIDX lastFmtIdx)
|
---|
281 | {
|
---|
282 | for (unsigned i = lastFmtIdx + 1; i < RT_ELEMENTS(g_aFormats); ++i)
|
---|
283 | {
|
---|
284 | if (uFormatsVBox & clipVBoxFormatForX11Format(i))
|
---|
285 | return i;
|
---|
286 | }
|
---|
287 |
|
---|
288 | return NIL_CLIPX11FORMAT;
|
---|
289 | }
|
---|
290 |
|
---|
291 | /**
|
---|
292 | * Array of structures for mapping Xt widgets to context pointers. We
|
---|
293 | * need this because the widget clipboard callbacks do not pass user data.
|
---|
294 | */
|
---|
295 | static struct
|
---|
296 | {
|
---|
297 | /** Pointer to widget we want to associate the context with. */
|
---|
298 | Widget pWidget;
|
---|
299 | /** Pointer to X11 context associated with the widget. */
|
---|
300 | PSHCLX11CTX pCtx;
|
---|
301 | } g_aContexts[VBOX_SHARED_CLIPBOARD_X11_CONNECTIONS_MAX];
|
---|
302 |
|
---|
303 | /**
|
---|
304 | * Registers a new X11 clipboard context.
|
---|
305 | *
|
---|
306 | * @returns VBox status code.
|
---|
307 | * @param pCtx The X11 clipboard context to use.
|
---|
308 | */
|
---|
309 | static int clipRegisterContext(PSHCLX11CTX pCtx)
|
---|
310 | {
|
---|
311 | AssertPtrReturn(pCtx, VERR_INVALID_PARAMETER);
|
---|
312 |
|
---|
313 | bool fFound = false;
|
---|
314 |
|
---|
315 | Widget pWidget = pCtx->pWidget;
|
---|
316 | AssertReturn(pWidget != NULL, VERR_INVALID_PARAMETER);
|
---|
317 |
|
---|
318 | for (unsigned i = 0; i < RT_ELEMENTS(g_aContexts); ++i)
|
---|
319 | {
|
---|
320 | AssertReturn( (g_aContexts[i].pWidget != pWidget)
|
---|
321 | && (g_aContexts[i].pCtx != pCtx), VERR_WRONG_ORDER);
|
---|
322 | if (g_aContexts[i].pWidget == NULL && !fFound)
|
---|
323 | {
|
---|
324 | AssertReturn(g_aContexts[i].pCtx == NULL, VERR_INTERNAL_ERROR);
|
---|
325 | g_aContexts[i].pWidget = pWidget;
|
---|
326 | g_aContexts[i].pCtx = pCtx;
|
---|
327 | fFound = true;
|
---|
328 | }
|
---|
329 | }
|
---|
330 |
|
---|
331 | return fFound ? VINF_SUCCESS : VERR_OUT_OF_RESOURCES;
|
---|
332 | }
|
---|
333 |
|
---|
334 | /**
|
---|
335 | * Unregister an X11 clipboard context.
|
---|
336 | *
|
---|
337 | * @param pCtx The X11 clipboard context to use.
|
---|
338 | */
|
---|
339 | static void clipUnregisterContext(PSHCLX11CTX pCtx)
|
---|
340 | {
|
---|
341 | AssertPtrReturnVoid(pCtx);
|
---|
342 |
|
---|
343 | Widget pWidget = pCtx->pWidget;
|
---|
344 | AssertPtrReturnVoid(pWidget);
|
---|
345 |
|
---|
346 | bool fFound = false;
|
---|
347 | for (unsigned i = 0; i < RT_ELEMENTS(g_aContexts); ++i)
|
---|
348 | {
|
---|
349 | Assert(!fFound || g_aContexts[i].pWidget != pWidget);
|
---|
350 | if (g_aContexts[i].pWidget == pWidget)
|
---|
351 | {
|
---|
352 | Assert(g_aContexts[i].pCtx != NULL);
|
---|
353 | g_aContexts[i].pWidget = NULL;
|
---|
354 | g_aContexts[i].pCtx = NULL;
|
---|
355 | fFound = true;
|
---|
356 | }
|
---|
357 | }
|
---|
358 | }
|
---|
359 |
|
---|
360 | /**
|
---|
361 | * Finds a X11 clipboard context for a specific X11 widget.
|
---|
362 | *
|
---|
363 | * @returns Pointer to associated X11 clipboard context if found, or NULL if not found.
|
---|
364 | * @param pWidget X11 widget to return X11 clipboard context for.
|
---|
365 | */
|
---|
366 | static PSHCLX11CTX clipLookupContext(Widget pWidget)
|
---|
367 | {
|
---|
368 | AssertPtrReturn(pWidget, NULL);
|
---|
369 |
|
---|
370 | for (unsigned i = 0; i < RT_ELEMENTS(g_aContexts); ++i)
|
---|
371 | {
|
---|
372 | if (g_aContexts[i].pWidget == pWidget)
|
---|
373 | {
|
---|
374 | Assert(g_aContexts[i].pCtx != NULL);
|
---|
375 | return g_aContexts[i].pCtx;
|
---|
376 | }
|
---|
377 | }
|
---|
378 |
|
---|
379 | return NULL;
|
---|
380 | }
|
---|
381 |
|
---|
382 | /**
|
---|
383 | * Converts an atom name string to an X11 atom, looking it up in a cache before asking the server.
|
---|
384 | *
|
---|
385 | * @returns Found X11 atom.
|
---|
386 | * @param pCtx The X11 clipboard context to use.
|
---|
387 | * @param pcszName Name of atom to return atom for.
|
---|
388 | */
|
---|
389 | SHCL_X11_DECL(Atom) clipGetAtom(PSHCLX11CTX pCtx, const char *pcszName)
|
---|
390 | {
|
---|
391 | AssertPtrReturn(pcszName, None);
|
---|
392 | return XInternAtom(XtDisplay(pCtx->pWidget), pcszName, False);
|
---|
393 | }
|
---|
394 |
|
---|
395 | /** String written to the wakeup pipe. */
|
---|
396 | #define WAKE_UP_STRING "WakeUp!"
|
---|
397 | /** Length of the string written. */
|
---|
398 | #define WAKE_UP_STRING_LEN ( sizeof(WAKE_UP_STRING) - 1 )
|
---|
399 |
|
---|
400 | /**
|
---|
401 | * Schedules a function call to run on the Xt event thread by passing it to
|
---|
402 | * the application context as a 0ms timeout and waking up the event loop by
|
---|
403 | * writing to the wakeup pipe which it monitors.
|
---|
404 | */
|
---|
405 | static int clipThreadScheduleCall(PSHCLX11CTX pCtx,
|
---|
406 | void (*proc)(void *, void *),
|
---|
407 | void *client_data)
|
---|
408 | {
|
---|
409 | LogFlowFunc(("proc=%p, client_data=%p\n", proc, client_data));
|
---|
410 |
|
---|
411 | #ifndef TESTCASE
|
---|
412 | AssertReturn(pCtx, VERR_INVALID_POINTER);
|
---|
413 | AssertReturn(pCtx->pAppContext, VERR_INVALID_POINTER);
|
---|
414 |
|
---|
415 | XtAppAddTimeOut(pCtx->pAppContext, 0, (XtTimerCallbackProc)proc,
|
---|
416 | (XtPointer)client_data);
|
---|
417 | ssize_t cbWritten = write(pCtx->wakeupPipeWrite, WAKE_UP_STRING, WAKE_UP_STRING_LEN);
|
---|
418 | Assert(cbWritten == WAKE_UP_STRING_LEN);
|
---|
419 | RT_NOREF(cbWritten);
|
---|
420 | #else
|
---|
421 | RT_NOREF(pCtx);
|
---|
422 | tstThreadScheduleCall(proc, client_data);
|
---|
423 | #endif
|
---|
424 |
|
---|
425 | LogFlowFuncLeaveRC(VINF_SUCCESS);
|
---|
426 | return VINF_SUCCESS;
|
---|
427 | }
|
---|
428 |
|
---|
429 | /**
|
---|
430 | * Reports the formats currently supported by the X11 clipboard to VBox.
|
---|
431 | *
|
---|
432 | * @note Runs in Xt event thread.
|
---|
433 | *
|
---|
434 | * @param pCtx The X11 clipboard context to use.
|
---|
435 | */
|
---|
436 | static void clipReportFormatsToVBox(PSHCLX11CTX pCtx)
|
---|
437 | {
|
---|
438 | SHCLFORMATS vboxFmt = clipVBoxFormatForX11Format(pCtx->idxFmtText);
|
---|
439 | vboxFmt |= clipVBoxFormatForX11Format(pCtx->idxFmtBmp);
|
---|
440 | vboxFmt |= clipVBoxFormatForX11Format(pCtx->idxFmtHTML);
|
---|
441 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
|
---|
442 | vboxFmt |= clipVBoxFormatForX11Format(pCtx->idxFmtURI);
|
---|
443 | #endif
|
---|
444 |
|
---|
445 | LogFlowFunc(("idxFmtText=%u ('%s'), idxFmtBmp=%u ('%s'), idxFmtHTML=%u ('%s')",
|
---|
446 | pCtx->idxFmtText, g_aFormats[pCtx->idxFmtText].pcszAtom,
|
---|
447 | pCtx->idxFmtBmp, g_aFormats[pCtx->idxFmtBmp].pcszAtom,
|
---|
448 | pCtx->idxFmtHTML, g_aFormats[pCtx->idxFmtHTML].pcszAtom));
|
---|
449 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
|
---|
450 | LogFlowFunc((", idxFmtURI=%u ('%s')", pCtx->idxFmtURI, g_aFormats[pCtx->idxFmtURI].pcszAtom));
|
---|
451 | #endif
|
---|
452 | LogFlow((" -> vboxFmt=%#x\n", vboxFmt));
|
---|
453 |
|
---|
454 | #ifdef LOG_ENABLED
|
---|
455 | char *pszFmts = ShClFormatsToStrA(vboxFmt);
|
---|
456 | AssertPtrReturnVoid(pszFmts);
|
---|
457 | LogRel2(("Shared Clipboard: X11 reported available VBox formats '%s'\n", pszFmts));
|
---|
458 | RTStrFree(pszFmts);
|
---|
459 | #endif
|
---|
460 |
|
---|
461 | pCtx->Callbacks.pfnReportFormats(pCtx->pFrontend, vboxFmt, NULL /* pvUser */);
|
---|
462 | }
|
---|
463 |
|
---|
464 | /**
|
---|
465 | * Forgets which formats were previously in the X11 clipboard. Called when we
|
---|
466 | * grab the clipboard.
|
---|
467 | *
|
---|
468 | * @param pCtx The X11 clipboard context to use.
|
---|
469 | */
|
---|
470 | static void clipResetX11Formats(PSHCLX11CTX pCtx)
|
---|
471 | {
|
---|
472 | LogFlowFuncEnter();
|
---|
473 |
|
---|
474 | pCtx->idxFmtText = 0;
|
---|
475 | pCtx->idxFmtBmp = 0;
|
---|
476 | pCtx->idxFmtHTML = 0;
|
---|
477 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
|
---|
478 | pCtx->idxFmtURI = 0;
|
---|
479 | #endif
|
---|
480 | }
|
---|
481 |
|
---|
482 | /**
|
---|
483 | * Tells VBox that X11 currently has nothing in its clipboard.
|
---|
484 | *
|
---|
485 | * @param pCtx The X11 clipboard context to use.
|
---|
486 | */
|
---|
487 | SHCL_X11_DECL(void) clipReportEmpty(PSHCLX11CTX pCtx)
|
---|
488 | {
|
---|
489 | clipResetX11Formats(pCtx);
|
---|
490 | clipReportFormatsToVBox(pCtx);
|
---|
491 | }
|
---|
492 |
|
---|
493 | /**
|
---|
494 | * Go through an array of X11 clipboard targets to see if they contain a text
|
---|
495 | * format we can support, and if so choose the ones we prefer (e.g. we like
|
---|
496 | * UTF-8 better than plain text).
|
---|
497 | *
|
---|
498 | * @return Index to supported X clipboard format.
|
---|
499 | * @param pCtx The X11 clipboard context to use.
|
---|
500 | * @param paIdxFmtTargets The list of targets.
|
---|
501 | * @param cTargets The size of the list in @a pTargets.
|
---|
502 | */
|
---|
503 | SHCL_X11_DECL(SHCLX11FMTIDX) clipGetTextFormatFromTargets(PSHCLX11CTX pCtx,
|
---|
504 | SHCLX11FMTIDX *paIdxFmtTargets,
|
---|
505 | size_t cTargets)
|
---|
506 | {
|
---|
507 | AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
|
---|
508 | AssertReturn(RT_VALID_PTR(paIdxFmtTargets) || cTargets == 0, NIL_CLIPX11FORMAT);
|
---|
509 |
|
---|
510 | SHCLX11FMTIDX idxFmtText = NIL_CLIPX11FORMAT;
|
---|
511 | SHCLX11FMT fmtTextX11 = SHCLX11FMT_INVALID;
|
---|
512 | for (unsigned i = 0; i < cTargets; ++i)
|
---|
513 | {
|
---|
514 | SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i];
|
---|
515 | if (idxFmt != NIL_CLIPX11FORMAT)
|
---|
516 | {
|
---|
517 | if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_UNICODETEXT)
|
---|
518 | && fmtTextX11 < clipRealFormatForX11Format(idxFmt))
|
---|
519 | {
|
---|
520 | fmtTextX11 = clipRealFormatForX11Format(idxFmt);
|
---|
521 | idxFmtText = idxFmt;
|
---|
522 | }
|
---|
523 | }
|
---|
524 | }
|
---|
525 | return idxFmtText;
|
---|
526 | }
|
---|
527 |
|
---|
528 | /**
|
---|
529 | * Goes through an array of X11 clipboard targets to see if they contain a bitmap
|
---|
530 | * format we can support, and if so choose the ones we prefer (e.g. we like
|
---|
531 | * BMP better than PNG because we don't have to convert).
|
---|
532 | *
|
---|
533 | * @return Supported X clipboard format.
|
---|
534 | * @param pCtx The X11 clipboard context to use.
|
---|
535 | * @param paIdxFmtTargets The list of targets.
|
---|
536 | * @param cTargets The size of the list in @a pTargets.
|
---|
537 | */
|
---|
538 | static SHCLX11FMTIDX clipGetBitmapFormatFromTargets(PSHCLX11CTX pCtx,
|
---|
539 | SHCLX11FMTIDX *paIdxFmtTargets,
|
---|
540 | size_t cTargets)
|
---|
541 | {
|
---|
542 | AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
|
---|
543 | AssertReturn(RT_VALID_PTR(paIdxFmtTargets) || cTargets == 0, NIL_CLIPX11FORMAT);
|
---|
544 |
|
---|
545 | SHCLX11FMTIDX idxFmtBmp = NIL_CLIPX11FORMAT;
|
---|
546 | SHCLX11FMT fmtBmpX11 = SHCLX11FMT_INVALID;
|
---|
547 | for (unsigned i = 0; i < cTargets; ++i)
|
---|
548 | {
|
---|
549 | SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i];
|
---|
550 | if (idxFmt != NIL_CLIPX11FORMAT)
|
---|
551 | {
|
---|
552 | if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_BITMAP)
|
---|
553 | && fmtBmpX11 < clipRealFormatForX11Format(idxFmt))
|
---|
554 | {
|
---|
555 | fmtBmpX11 = clipRealFormatForX11Format(idxFmt);
|
---|
556 | idxFmtBmp = idxFmt;
|
---|
557 | }
|
---|
558 | }
|
---|
559 | }
|
---|
560 | return idxFmtBmp;
|
---|
561 | }
|
---|
562 |
|
---|
563 | /**
|
---|
564 | * Goes through an array of X11 clipboard targets to see if they contain a HTML
|
---|
565 | * format we can support, and if so choose the ones we prefer.
|
---|
566 | *
|
---|
567 | * @return Supported X clipboard format.
|
---|
568 | * @param pCtx The X11 clipboard context to use.
|
---|
569 | * @param paIdxFmtTargets The list of targets.
|
---|
570 | * @param cTargets The size of the list in @a pTargets.
|
---|
571 | */
|
---|
572 | static SHCLX11FMTIDX clipGetHtmlFormatFromTargets(PSHCLX11CTX pCtx,
|
---|
573 | SHCLX11FMTIDX *paIdxFmtTargets,
|
---|
574 | size_t cTargets)
|
---|
575 | {
|
---|
576 | AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
|
---|
577 | AssertReturn(RT_VALID_PTR(paIdxFmtTargets) || cTargets == 0, NIL_CLIPX11FORMAT);
|
---|
578 |
|
---|
579 | SHCLX11FMTIDX idxFmtHTML = NIL_CLIPX11FORMAT;
|
---|
580 | SHCLX11FMT fmxHTMLX11 = SHCLX11FMT_INVALID;
|
---|
581 | for (unsigned i = 0; i < cTargets; ++i)
|
---|
582 | {
|
---|
583 | SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i];
|
---|
584 | if (idxFmt != NIL_CLIPX11FORMAT)
|
---|
585 | {
|
---|
586 | if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_HTML)
|
---|
587 | && fmxHTMLX11 < clipRealFormatForX11Format(idxFmt))
|
---|
588 | {
|
---|
589 | fmxHTMLX11 = clipRealFormatForX11Format(idxFmt);
|
---|
590 | idxFmtHTML = idxFmt;
|
---|
591 | }
|
---|
592 | }
|
---|
593 | }
|
---|
594 | return idxFmtHTML;
|
---|
595 | }
|
---|
596 |
|
---|
597 | # ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
|
---|
598 | /**
|
---|
599 | * Goes through an array of X11 clipboard targets to see if they contain an URI list
|
---|
600 | * format we can support, and if so choose the ones we prefer.
|
---|
601 | *
|
---|
602 | * @return Supported X clipboard format.
|
---|
603 | * @param pCtx The X11 clipboard context to use.
|
---|
604 | * @param paIdxFmtTargets The list of targets.
|
---|
605 | * @param cTargets The size of the list in @a pTargets.
|
---|
606 | */
|
---|
607 | static SHCLX11FMTIDX clipGetURIListFormatFromTargets(PSHCLX11CTX pCtx,
|
---|
608 | SHCLX11FMTIDX *paIdxFmtTargets,
|
---|
609 | size_t cTargets)
|
---|
610 | {
|
---|
611 | AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT);
|
---|
612 | AssertReturn(RT_VALID_PTR(paIdxFmtTargets) || cTargets == 0, NIL_CLIPX11FORMAT);
|
---|
613 |
|
---|
614 | SHCLX11FMTIDX idxFmtURI = NIL_CLIPX11FORMAT;
|
---|
615 | SHCLX11FMT fmtURIX11 = SHCLX11FMT_INVALID;
|
---|
616 | for (unsigned i = 0; i < cTargets; ++i)
|
---|
617 | {
|
---|
618 | SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i];
|
---|
619 | if (idxFmt != NIL_CLIPX11FORMAT)
|
---|
620 | {
|
---|
621 | if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_URI_LIST)
|
---|
622 | && fmtURIX11 < clipRealFormatForX11Format(idxFmt))
|
---|
623 | {
|
---|
624 | fmtURIX11 = clipRealFormatForX11Format(idxFmt);
|
---|
625 | idxFmtURI = idxFmt;
|
---|
626 | }
|
---|
627 | }
|
---|
628 | }
|
---|
629 | return idxFmtURI;
|
---|
630 | }
|
---|
631 | # endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
|
---|
632 |
|
---|
633 | /**
|
---|
634 | * Goes through an array of X11 clipboard targets to see if we can support any
|
---|
635 | * of them and if relevant to choose the ones we prefer (e.g. we like Utf8
|
---|
636 | * better than plain text).
|
---|
637 | *
|
---|
638 | * @param pCtx The X11 clipboard context to use.
|
---|
639 | * @param paIdxFmtTargets The list of targets.
|
---|
640 | * @param cTargets The size of the list in @a pTargets.
|
---|
641 | */
|
---|
642 | static void clipGetFormatsFromTargets(PSHCLX11CTX pCtx,
|
---|
643 | SHCLX11FMTIDX *paIdxFmtTargets, size_t cTargets)
|
---|
644 | {
|
---|
645 | AssertPtrReturnVoid(pCtx);
|
---|
646 | AssertPtrReturnVoid(paIdxFmtTargets);
|
---|
647 |
|
---|
648 | SHCLX11FMTIDX idxFmtText = clipGetTextFormatFromTargets(pCtx, paIdxFmtTargets, cTargets);
|
---|
649 | if (pCtx->idxFmtText != idxFmtText)
|
---|
650 | pCtx->idxFmtText = idxFmtText;
|
---|
651 |
|
---|
652 | pCtx->idxFmtBmp = SHCLX11FMT_INVALID; /* not yet supported */ /** @todo r=andy Check this. */
|
---|
653 | SHCLX11FMTIDX idxFmtBmp = clipGetBitmapFormatFromTargets(pCtx, paIdxFmtTargets, cTargets);
|
---|
654 | if (pCtx->idxFmtBmp != idxFmtBmp)
|
---|
655 | pCtx->idxFmtBmp = idxFmtBmp;
|
---|
656 |
|
---|
657 | SHCLX11FMTIDX idxFmtHTML = clipGetHtmlFormatFromTargets(pCtx, paIdxFmtTargets, cTargets);
|
---|
658 | if (pCtx->idxFmtHTML != idxFmtHTML)
|
---|
659 | pCtx->idxFmtHTML = idxFmtHTML;
|
---|
660 |
|
---|
661 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
|
---|
662 | SHCLX11FMTIDX idxFmtURI = clipGetURIListFormatFromTargets(pCtx, paIdxFmtTargets, cTargets);
|
---|
663 | if (pCtx->idxFmtURI != idxFmtURI)
|
---|
664 | pCtx->idxFmtURI = idxFmtURI;
|
---|
665 | #endif
|
---|
666 | }
|
---|
667 |
|
---|
668 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
|
---|
669 | DECLINLINE(bool) clipGetXtBusy(PSHCLX11CTX pCtx)
|
---|
670 | {
|
---|
671 | LogFlowFunc(("fXtBusy=%RTbool, fXtNeedsUpdate=%RTbool\n", pCtx->fXtBusy, pCtx->fXtNeedsUpdate));
|
---|
672 | return pCtx->fXtBusy;
|
---|
673 | }
|
---|
674 |
|
---|
675 | DECLINLINE(bool) clipGetXtNeedsUpdate(PSHCLX11CTX pCtx)
|
---|
676 | {
|
---|
677 | LogFlowFunc(("fXtBusy=%RTbool, fXtNeedsUpdate=%RTbool\n", pCtx->fXtBusy, pCtx->fXtNeedsUpdate));
|
---|
678 | return pCtx->fXtNeedsUpdate;
|
---|
679 | }
|
---|
680 |
|
---|
681 | DECLINLINE(bool) clipSetXtBusy(PSHCLX11CTX pCtx, bool fBusy)
|
---|
682 | {
|
---|
683 | pCtx->fXtBusy = fBusy;
|
---|
684 | LogFlowFunc(("fXtBusy=%RTbool, fXtNeedsUpdate=%RTbool\n", pCtx->fXtBusy, pCtx->fXtNeedsUpdate));
|
---|
685 | return pCtx->fXtBusy;
|
---|
686 | }
|
---|
687 |
|
---|
688 | DECLINLINE(bool) clipSetXtNeedsUpdate(PSHCLX11CTX pCtx, bool fNeedsUpdate)
|
---|
689 | {
|
---|
690 | pCtx->fXtNeedsUpdate = fNeedsUpdate;
|
---|
691 | LogFlowFunc(("fXtBusy=%RTbool, fXtNeedsUpdate=%RTbool\n", pCtx->fXtBusy, pCtx->fXtNeedsUpdate));
|
---|
692 | return pCtx->fXtNeedsUpdate;
|
---|
693 | }
|
---|
694 | #endif /* VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY */
|
---|
695 |
|
---|
696 | /**
|
---|
697 | * Updates the context's information about targets currently supported by X11,
|
---|
698 | * based on an array of X11 atoms.
|
---|
699 | *
|
---|
700 | * @param pCtx The X11 clipboard context to use.
|
---|
701 | * @param pTargets The array of atoms describing the targets supported.
|
---|
702 | * @param cTargets The size of the array @a pTargets.
|
---|
703 | */
|
---|
704 | SHCL_X11_DECL(void) clipUpdateX11Targets(PSHCLX11CTX pCtx, SHCLX11FMTIDX *paIdxFmtTargets, size_t cTargets)
|
---|
705 | {
|
---|
706 | LogFlowFuncEnter();
|
---|
707 |
|
---|
708 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
|
---|
709 | clipSetXtBusy(pCtx, false);
|
---|
710 | if (clipGetXtNeedsUpdate(pCtx))
|
---|
711 | {
|
---|
712 | /* We may already be out of date. */
|
---|
713 | clipSetXtNeedsUpdate(pCtx, false);
|
---|
714 | clipQueryX11Targets(pCtx);
|
---|
715 | return;
|
---|
716 | }
|
---|
717 | #endif
|
---|
718 |
|
---|
719 | if (paIdxFmtTargets == NULL)
|
---|
720 | {
|
---|
721 | /* No data available */
|
---|
722 | clipReportEmpty(pCtx);
|
---|
723 | return;
|
---|
724 | }
|
---|
725 |
|
---|
726 | clipGetFormatsFromTargets(pCtx, paIdxFmtTargets, cTargets);
|
---|
727 | clipReportFormatsToVBox(pCtx);
|
---|
728 | }
|
---|
729 |
|
---|
730 | /**
|
---|
731 | * Notifies the VBox clipboard about available data formats ("targets" on X11),
|
---|
732 | * based on the information obtained from the X11 clipboard.
|
---|
733 | *
|
---|
734 | * @note Callback installed by clipQueryX11Targets() for XtGetSelectionValue().
|
---|
735 | * @note This function is treated as API glue, and as such is not part of any
|
---|
736 | * unit test. So keep it simple, be paranoid and log everything.
|
---|
737 | */
|
---|
738 | SHCL_X11_DECL(void) clipQueryX11TargetsCallback(Widget widget, XtPointer pClient,
|
---|
739 | Atom * /* selection */, Atom *atomType,
|
---|
740 | XtPointer pValue, long unsigned int *pcLen,
|
---|
741 | int *piFormat)
|
---|
742 | {
|
---|
743 | RT_NOREF(piFormat);
|
---|
744 |
|
---|
745 | PSHCLX11CTX pCtx = reinterpret_cast<SHCLX11CTX *>(pClient);
|
---|
746 |
|
---|
747 | LogFlowFunc(("pValue=%p, *pcLen=%u, *atomType=%d%s\n",
|
---|
748 | pValue, *pcLen, *atomType, *atomType == XT_CONVERT_FAIL ? " (XT_CONVERT_FAIL)" : ""));
|
---|
749 |
|
---|
750 | Atom *pAtoms = (Atom *)pValue;
|
---|
751 |
|
---|
752 | unsigned cFormats = *pcLen;
|
---|
753 |
|
---|
754 | LogRel2(("Shared Clipboard: Querying X11 formats ...\n"));
|
---|
755 | LogRel2(("Shared Clipboard: %u X11 formats were found\n", cFormats));
|
---|
756 |
|
---|
757 | SHCLX11FMTIDX *paIdxFmt = NULL;
|
---|
758 | if ( cFormats
|
---|
759 | && pValue
|
---|
760 | && (*atomType != XT_CONVERT_FAIL /* time out */))
|
---|
761 | {
|
---|
762 | /* Allocated array to hold the format indices. */
|
---|
763 | paIdxFmt = (SHCLX11FMTIDX *)RTMemAllocZ(cFormats * sizeof(SHCLX11FMTIDX));
|
---|
764 | }
|
---|
765 |
|
---|
766 | #if !defined(TESTCASE)
|
---|
767 | if (pValue)
|
---|
768 | {
|
---|
769 | for (unsigned i = 0; i < cFormats; ++i)
|
---|
770 | {
|
---|
771 | if (pAtoms[i])
|
---|
772 | {
|
---|
773 | char *pszName = XGetAtomName(XtDisplay(widget), pAtoms[i]);
|
---|
774 | LogRel2(("Shared Clipboard: Found X11 format '%s'\n", pszName));
|
---|
775 | XFree(pszName);
|
---|
776 | }
|
---|
777 | else
|
---|
778 | LogFunc(("Found empty target\n"));
|
---|
779 | }
|
---|
780 | }
|
---|
781 | #endif
|
---|
782 |
|
---|
783 | if (paIdxFmt)
|
---|
784 | {
|
---|
785 | for (unsigned i = 0; i < cFormats; ++i)
|
---|
786 | {
|
---|
787 | for (unsigned j = 0; j < RT_ELEMENTS(g_aFormats); ++j)
|
---|
788 | {
|
---|
789 | Atom target = XInternAtom(XtDisplay(widget),
|
---|
790 | g_aFormats[j].pcszAtom, False);
|
---|
791 | if (*(pAtoms + i) == target)
|
---|
792 | paIdxFmt[i] = j;
|
---|
793 | }
|
---|
794 | #if !defined(TESTCASE)
|
---|
795 | if (paIdxFmt[i] != SHCLX11FMT_INVALID)
|
---|
796 | LogRel2(("Shared Clipboard: Reporting X11 format '%s'\n", g_aFormats[paIdxFmt[i]].pcszAtom));
|
---|
797 | #endif
|
---|
798 | }
|
---|
799 | }
|
---|
800 | else
|
---|
801 | LogFunc(("Reporting empty targets (none reported or allocation failure)\n"));
|
---|
802 |
|
---|
803 | clipUpdateX11Targets(pCtx, paIdxFmt, cFormats);
|
---|
804 | RTMemFree(paIdxFmt);
|
---|
805 |
|
---|
806 | XtFree(reinterpret_cast<char *>(pValue));
|
---|
807 | }
|
---|
808 |
|
---|
809 | /**
|
---|
810 | * Queries the current formats ("targets") of the X11 clipboard ("CLIPBOARD").
|
---|
811 | *
|
---|
812 | * @param pCtx The X11 clipboard context to use.
|
---|
813 | */
|
---|
814 | SHCL_X11_DECL(void) clipQueryX11Targets(PSHCLX11CTX pCtx)
|
---|
815 | {
|
---|
816 | #ifndef TESTCASE
|
---|
817 |
|
---|
818 | # ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
|
---|
819 | if (clipGetXtBusy(pCtx))
|
---|
820 | {
|
---|
821 | clipSetXtNeedsUpdate(pCtx, true);
|
---|
822 | return;
|
---|
823 | }
|
---|
824 | clipSetXtBusy(pCtx, true);
|
---|
825 | # endif
|
---|
826 |
|
---|
827 | XtGetSelectionValue(pCtx->pWidget,
|
---|
828 | clipGetAtom(pCtx, "CLIPBOARD"),
|
---|
829 | clipGetAtom(pCtx, "TARGETS"),
|
---|
830 | clipQueryX11TargetsCallback, pCtx,
|
---|
831 | CurrentTime);
|
---|
832 | #else
|
---|
833 | tstRequestTargets(pCtx);
|
---|
834 | #endif
|
---|
835 | }
|
---|
836 |
|
---|
837 | typedef struct
|
---|
838 | {
|
---|
839 | int type; /* event base */
|
---|
840 | unsigned long serial;
|
---|
841 | Bool send_event;
|
---|
842 | Display *display;
|
---|
843 | Window window;
|
---|
844 | int subtype;
|
---|
845 | Window owner;
|
---|
846 | Atom selection;
|
---|
847 | Time timestamp;
|
---|
848 | Time selection_timestamp;
|
---|
849 | } XFixesSelectionNotifyEvent;
|
---|
850 |
|
---|
851 | #ifndef TESTCASE
|
---|
852 | /**
|
---|
853 | * Waits until an event arrives and handle it if it is an XFIXES selection
|
---|
854 | * event, which Xt doesn't know about.
|
---|
855 | *
|
---|
856 | * @param pCtx The X11 clipboard context to use.
|
---|
857 | */
|
---|
858 | static void clipPeekEventAndDoXFixesHandling(PSHCLX11CTX pCtx)
|
---|
859 | {
|
---|
860 | union
|
---|
861 | {
|
---|
862 | XEvent event;
|
---|
863 | XFixesSelectionNotifyEvent fixes;
|
---|
864 | } event = { { 0 } };
|
---|
865 |
|
---|
866 | if (XtAppPeekEvent(pCtx->pAppContext, &event.event))
|
---|
867 | {
|
---|
868 | if ( (event.event.type == pCtx->fixesEventBase)
|
---|
869 | && (event.fixes.owner != XtWindow(pCtx->pWidget)))
|
---|
870 | {
|
---|
871 | if ( (event.fixes.subtype == 0 /* XFixesSetSelectionOwnerNotify */)
|
---|
872 | && (event.fixes.owner != 0))
|
---|
873 | clipQueryX11Targets(pCtx);
|
---|
874 | else
|
---|
875 | clipReportEmpty(pCtx);
|
---|
876 | }
|
---|
877 | }
|
---|
878 | }
|
---|
879 |
|
---|
880 | /**
|
---|
881 | * The main loop of our X11 event thread.
|
---|
882 | *
|
---|
883 | * @returns VBox status code.
|
---|
884 | * @param hThreadSelf Associated thread handle.
|
---|
885 | * @param pvUser Pointer to the X11 clipboard context to use.
|
---|
886 | */
|
---|
887 | static DECLCALLBACK(int) clipThreadMain(RTTHREAD hThreadSelf, void *pvUser)
|
---|
888 | {
|
---|
889 | PSHCLX11CTX pCtx = (PSHCLX11CTX)pvUser;
|
---|
890 | AssertPtr(pCtx);
|
---|
891 |
|
---|
892 | LogFlowFunc(("pCtx=%p\n", pCtx));
|
---|
893 |
|
---|
894 | bool fSignalled = false; /* Whether we have signalled the parent already or not. */
|
---|
895 |
|
---|
896 | int rc = clipInitInternal(pCtx);
|
---|
897 | if (RT_SUCCESS(rc))
|
---|
898 | {
|
---|
899 | rc = clipRegisterContext(pCtx);
|
---|
900 | if (RT_SUCCESS(rc))
|
---|
901 | {
|
---|
902 | if (pCtx->fGrabClipboardOnStart)
|
---|
903 | clipQueryX11Targets(pCtx);
|
---|
904 |
|
---|
905 | pCtx->fThreadStarted = true;
|
---|
906 |
|
---|
907 | /* We're now ready to run, tell parent. */
|
---|
908 | int rc2 = RTThreadUserSignal(hThreadSelf);
|
---|
909 | AssertRC(rc2);
|
---|
910 |
|
---|
911 | fSignalled = true;
|
---|
912 |
|
---|
913 | while (XtAppGetExitFlag(pCtx->pAppContext) == FALSE)
|
---|
914 | {
|
---|
915 | clipPeekEventAndDoXFixesHandling(pCtx);
|
---|
916 | XtAppProcessEvent(pCtx->pAppContext, XtIMAll);
|
---|
917 | }
|
---|
918 |
|
---|
919 | LogRel(("Shared Clipboard: X11 event thread exiting\n"));
|
---|
920 |
|
---|
921 | clipUnregisterContext(pCtx);
|
---|
922 | }
|
---|
923 | else
|
---|
924 | {
|
---|
925 | LogRel(("Shared Clipboard: unable to register clip context: %Rrc\n", rc));
|
---|
926 | }
|
---|
927 |
|
---|
928 | clipUninitInternal(pCtx);
|
---|
929 | }
|
---|
930 |
|
---|
931 | if (!fSignalled) /* Signal parent if we didn't do so yet. */
|
---|
932 | {
|
---|
933 | int rc2 = RTThreadUserSignal(hThreadSelf);
|
---|
934 | AssertRC(rc2);
|
---|
935 | }
|
---|
936 |
|
---|
937 | LogFlowFuncLeaveRC(rc);
|
---|
938 | return rc;
|
---|
939 | }
|
---|
940 |
|
---|
941 | /**
|
---|
942 | * Worker function for stopping the clipboard which runs on the event
|
---|
943 | * thread.
|
---|
944 | *
|
---|
945 | * @param pvUserData Pointer to the X11 clipboard context to use.
|
---|
946 | */
|
---|
947 | static void clipThreadSignalStop(void *pvUserData, void *)
|
---|
948 | {
|
---|
949 | PSHCLX11CTX pCtx = (PSHCLX11CTX)pvUserData;
|
---|
950 |
|
---|
951 | /* This might mean that we are getting stopped twice. */
|
---|
952 | Assert(pCtx->pWidget != NULL);
|
---|
953 |
|
---|
954 | /* Set the termination flag to tell the Xt event loop to exit. We
|
---|
955 | * reiterate that any outstanding requests from the X11 event loop to
|
---|
956 | * the VBox part *must* have returned before we do this. */
|
---|
957 | XtAppSetExitFlag(pCtx->pAppContext);
|
---|
958 | }
|
---|
959 |
|
---|
960 | /**
|
---|
961 | * Sets up the XFixes library and load the XFixesSelectSelectionInput symbol.
|
---|
962 | */
|
---|
963 | static int clipLoadXFixes(Display *pDisplay, PSHCLX11CTX pCtx)
|
---|
964 | {
|
---|
965 | int rc;
|
---|
966 |
|
---|
967 | void *hFixesLib = dlopen("libXfixes.so.1", RTLD_LAZY);
|
---|
968 | if (!hFixesLib)
|
---|
969 | hFixesLib = dlopen("libXfixes.so.2", RTLD_LAZY);
|
---|
970 | if (!hFixesLib)
|
---|
971 | hFixesLib = dlopen("libXfixes.so.3", RTLD_LAZY);
|
---|
972 | if (!hFixesLib)
|
---|
973 | hFixesLib = dlopen("libXfixes.so.4", RTLD_LAZY);
|
---|
974 | if (hFixesLib)
|
---|
975 | {
|
---|
976 | /* For us, a NULL function pointer is a failure */
|
---|
977 | pCtx->fixesSelectInput = (void (*)(Display *, Window, Atom, long unsigned int))
|
---|
978 | (uintptr_t)dlsym(hFixesLib, "XFixesSelectSelectionInput");
|
---|
979 | if (pCtx->fixesSelectInput)
|
---|
980 | {
|
---|
981 | int dummy1 = 0;
|
---|
982 | int dummy2 = 0;
|
---|
983 | if (XQueryExtension(pDisplay, "XFIXES", &dummy1, &pCtx->fixesEventBase, &dummy2) != 0)
|
---|
984 | {
|
---|
985 | if (pCtx->fixesEventBase >= 0)
|
---|
986 | {
|
---|
987 | rc = VINF_SUCCESS;
|
---|
988 | }
|
---|
989 | else
|
---|
990 | {
|
---|
991 | LogRel(("Shared Clipboard: fixesEventBase is less than zero: %d\n", pCtx->fixesEventBase));
|
---|
992 | rc = VERR_NOT_SUPPORTED;
|
---|
993 | }
|
---|
994 | }
|
---|
995 | else
|
---|
996 | {
|
---|
997 | LogRel(("Shared Clipboard: XQueryExtension failed\n"));
|
---|
998 | rc = VERR_NOT_SUPPORTED;
|
---|
999 | }
|
---|
1000 | }
|
---|
1001 | else
|
---|
1002 | {
|
---|
1003 | LogRel(("Shared Clipboard: Symbol XFixesSelectSelectionInput not found!\n"));
|
---|
1004 | rc = VERR_NOT_SUPPORTED;
|
---|
1005 | }
|
---|
1006 | }
|
---|
1007 | else
|
---|
1008 | {
|
---|
1009 | LogRel(("Shared Clipboard: libxFixes.so.* not found!\n"));
|
---|
1010 | rc = VERR_NOT_SUPPORTED;
|
---|
1011 | }
|
---|
1012 | return rc;
|
---|
1013 | }
|
---|
1014 |
|
---|
1015 | /**
|
---|
1016 | * This is the callback which is scheduled when data is available on the
|
---|
1017 | * wakeup pipe. It simply reads all data from the pipe.
|
---|
1018 | *
|
---|
1019 | * @param pvUserData Pointer to the X11 clipboard context to use.
|
---|
1020 | */
|
---|
1021 | static void clipThreadDrainWakeupPipe(XtPointer pvUserData, int *, XtInputId *)
|
---|
1022 | {
|
---|
1023 | LogFlowFuncEnter();
|
---|
1024 |
|
---|
1025 | PSHCLX11CTX pCtx = (PSHCLX11CTX)pvUserData;
|
---|
1026 | char acBuf[WAKE_UP_STRING_LEN];
|
---|
1027 |
|
---|
1028 | while (read(pCtx->wakeupPipeRead, acBuf, sizeof(acBuf)) > 0) {}
|
---|
1029 | }
|
---|
1030 | #endif /* !TESTCASE */
|
---|
1031 |
|
---|
1032 | /**
|
---|
1033 | * X11-specific initialisation for the Shared Clipboard.
|
---|
1034 | *
|
---|
1035 | * Note: Must be called from the thread serving the Xt stuff.
|
---|
1036 | *
|
---|
1037 | * @returns VBox status code.
|
---|
1038 | * @param pCtx The X11 clipboard context to init.
|
---|
1039 | */
|
---|
1040 | static int clipInitInternal(PSHCLX11CTX pCtx)
|
---|
1041 | {
|
---|
1042 | LogFlowFunc(("pCtx=%p\n", pCtx));
|
---|
1043 |
|
---|
1044 | /* Make sure we are thread safe. */
|
---|
1045 | XtToolkitThreadInitialize();
|
---|
1046 |
|
---|
1047 | /*
|
---|
1048 | * Set up the Clipboard application context and main window. We call all
|
---|
1049 | * these functions directly instead of calling XtOpenApplication() so
|
---|
1050 | * that we can fail gracefully if we can't get an X11 display.
|
---|
1051 | */
|
---|
1052 | XtToolkitInitialize();
|
---|
1053 |
|
---|
1054 | int rc = VINF_SUCCESS;
|
---|
1055 |
|
---|
1056 | Assert(pCtx->pAppContext == NULL); /* No nested initialization. */
|
---|
1057 | pCtx->pAppContext = XtCreateApplicationContext();
|
---|
1058 | if (pCtx->pAppContext == NULL)
|
---|
1059 | {
|
---|
1060 | LogRel(("Shared Clipboard: Failed to create Xt application context\n"));
|
---|
1061 | return VERR_NOT_SUPPORTED; /** @todo Fudge! */
|
---|
1062 | }
|
---|
1063 |
|
---|
1064 | /* Create a window and make it a clipboard viewer. */
|
---|
1065 | int cArgc = 0;
|
---|
1066 | char *pcArgv = 0;
|
---|
1067 | Display *pDisplay = XtOpenDisplay(pCtx->pAppContext, 0, 0, "VBoxShCl", 0, 0, &cArgc, &pcArgv);
|
---|
1068 | if (pDisplay == NULL)
|
---|
1069 | {
|
---|
1070 | LogRel(("Shared Clipboard: Failed to connect to the X11 clipboard - the window system may not be running\n"));
|
---|
1071 | rc = VERR_NOT_SUPPORTED;
|
---|
1072 | }
|
---|
1073 |
|
---|
1074 | #ifndef TESTCASE
|
---|
1075 | if (RT_SUCCESS(rc))
|
---|
1076 | {
|
---|
1077 | rc = clipLoadXFixes(pDisplay, pCtx);
|
---|
1078 | if (RT_FAILURE(rc))
|
---|
1079 | LogRel(("Shared Clipboard: Failed to load the XFIXES extension\n"));
|
---|
1080 | }
|
---|
1081 | #endif
|
---|
1082 |
|
---|
1083 | if (RT_SUCCESS(rc))
|
---|
1084 | {
|
---|
1085 | pCtx->pWidget = XtVaAppCreateShell(0, "VBoxShCl",
|
---|
1086 | applicationShellWidgetClass,
|
---|
1087 | pDisplay, XtNwidth, 1, XtNheight,
|
---|
1088 | 1, NULL);
|
---|
1089 | if (pCtx->pWidget == NULL)
|
---|
1090 | {
|
---|
1091 | LogRel(("Shared Clipboard: Failed to create Xt app shell\n"));
|
---|
1092 | rc = VERR_NO_MEMORY; /** @todo r=andy Improve this. */
|
---|
1093 | }
|
---|
1094 | else
|
---|
1095 | {
|
---|
1096 | #ifndef TESTCASE
|
---|
1097 | if (!XtAppAddInput(pCtx->pAppContext, pCtx->wakeupPipeRead,
|
---|
1098 | (XtPointer) XtInputReadMask,
|
---|
1099 | clipThreadDrainWakeupPipe, (XtPointer) pCtx))
|
---|
1100 | {
|
---|
1101 | LogRel(("Shared Clipboard: Failed to add input to Xt app context\n"));
|
---|
1102 | rc = VERR_ACCESS_DENIED; /** @todo r=andy Improve this. */
|
---|
1103 | }
|
---|
1104 | #endif
|
---|
1105 | }
|
---|
1106 | }
|
---|
1107 |
|
---|
1108 | if (RT_SUCCESS(rc))
|
---|
1109 | {
|
---|
1110 | XtSetMappedWhenManaged(pCtx->pWidget, false);
|
---|
1111 | XtRealizeWidget(pCtx->pWidget);
|
---|
1112 |
|
---|
1113 | #ifndef TESTCASE
|
---|
1114 | /* Enable clipboard update notification. */
|
---|
1115 | pCtx->fixesSelectInput(pDisplay, XtWindow(pCtx->pWidget),
|
---|
1116 | clipGetAtom(pCtx, "CLIPBOARD"),
|
---|
1117 | 7 /* All XFixes*Selection*NotifyMask flags */);
|
---|
1118 | #endif
|
---|
1119 | }
|
---|
1120 |
|
---|
1121 | if (RT_FAILURE(rc))
|
---|
1122 | {
|
---|
1123 | LogRel(("Shared Clipboard: Initialisation failed: %Rrc\n", rc));
|
---|
1124 | clipUninitInternal(pCtx);
|
---|
1125 | }
|
---|
1126 |
|
---|
1127 | LogFlowFuncLeaveRC(rc);
|
---|
1128 | return rc;
|
---|
1129 | }
|
---|
1130 |
|
---|
1131 | /**
|
---|
1132 | * X11-specific uninitialisation for the Shared Clipboard.
|
---|
1133 | *
|
---|
1134 | * Note: Must be called from the thread serving the Xt stuff.
|
---|
1135 | *
|
---|
1136 | * @param pCtx The X11 clipboard context to uninit.
|
---|
1137 | */
|
---|
1138 | static void clipUninitInternal(PSHCLX11CTX pCtx)
|
---|
1139 | {
|
---|
1140 | AssertPtrReturnVoid(pCtx);
|
---|
1141 |
|
---|
1142 | LogFlowFunc(("pCtx=%p\n", pCtx));
|
---|
1143 |
|
---|
1144 | if (pCtx->pWidget)
|
---|
1145 | {
|
---|
1146 | /* Valid widget + invalid appcontext = bug. But don't return yet. */
|
---|
1147 | AssertPtr(pCtx->pAppContext);
|
---|
1148 |
|
---|
1149 | XtDestroyWidget(pCtx->pWidget);
|
---|
1150 | pCtx->pWidget = NULL;
|
---|
1151 | }
|
---|
1152 |
|
---|
1153 | if (pCtx->pAppContext)
|
---|
1154 | {
|
---|
1155 | XtDestroyApplicationContext(pCtx->pAppContext);
|
---|
1156 | pCtx->pAppContext = NULL;
|
---|
1157 | }
|
---|
1158 |
|
---|
1159 | LogFlowFuncLeaveRC(VINF_SUCCESS);
|
---|
1160 | }
|
---|
1161 |
|
---|
1162 | /**
|
---|
1163 | * Sets the callback table, internal version.
|
---|
1164 | *
|
---|
1165 | * @param pCtx The clipboard context.
|
---|
1166 | * @param pCallbacks Callback table to set. If NULL, the current callback table will be cleared.
|
---|
1167 | */
|
---|
1168 | static void shClX11SetCallbacksInternal(PSHCLX11CTX pCtx, PSHCLCALLBACKS pCallbacks)
|
---|
1169 | {
|
---|
1170 | if (pCallbacks)
|
---|
1171 | {
|
---|
1172 | memcpy(&pCtx->Callbacks, pCallbacks, sizeof(SHCLCALLBACKS));
|
---|
1173 | }
|
---|
1174 | else
|
---|
1175 | RT_ZERO(pCtx->Callbacks);
|
---|
1176 | }
|
---|
1177 |
|
---|
1178 | /**
|
---|
1179 | * Sets the callback table.
|
---|
1180 | *
|
---|
1181 | * @param pCtx The clipboard context.
|
---|
1182 | * @param pCallbacks Callback table to set. If NULL, the current callback table will be cleared.
|
---|
1183 | */
|
---|
1184 | void ShClX11SetCallbacks(PSHCLX11CTX pCtx, PSHCLCALLBACKS pCallbacks)
|
---|
1185 | {
|
---|
1186 | shClX11SetCallbacksInternal(pCtx, pCallbacks);
|
---|
1187 | }
|
---|
1188 |
|
---|
1189 | /**
|
---|
1190 | * Initializes a X11 context of the Shared Clipboard.
|
---|
1191 | *
|
---|
1192 | * @returns VBox status code.
|
---|
1193 | * @param pCtx The clipboard context to initialize.
|
---|
1194 | * @param pCallbacks Callback table to use.
|
---|
1195 | * @param pParent Parent context to use.
|
---|
1196 | * @param fHeadless Whether the code runs in a headless environment or not.
|
---|
1197 | */
|
---|
1198 | int ShClX11Init(PSHCLX11CTX pCtx, PSHCLCALLBACKS pCallbacks, PSHCLCONTEXT pParent, bool fHeadless)
|
---|
1199 | {
|
---|
1200 | AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
|
---|
1201 |
|
---|
1202 | LogFlowFunc(("pCtx=%p\n", pCtx));
|
---|
1203 |
|
---|
1204 | int rc = VINF_SUCCESS;
|
---|
1205 |
|
---|
1206 | RT_BZERO(pCtx, sizeof(SHCLX11CTX));
|
---|
1207 |
|
---|
1208 | if (fHeadless)
|
---|
1209 | {
|
---|
1210 | /*
|
---|
1211 | * If we don't find the DISPLAY environment variable we assume that
|
---|
1212 | * we are not connected to an X11 server. Don't actually try to do
|
---|
1213 | * this then, just fail silently and report success on every call.
|
---|
1214 | * This is important for VBoxHeadless.
|
---|
1215 | */
|
---|
1216 | LogRel(("Shared Clipboard: X11 DISPLAY variable not set -- disabling clipboard sharing\n"));
|
---|
1217 | }
|
---|
1218 |
|
---|
1219 | /* Install given callbacks. */
|
---|
1220 | shClX11SetCallbacksInternal(pCtx, pCallbacks);
|
---|
1221 |
|
---|
1222 | pCtx->fHaveX11 = !fHeadless;
|
---|
1223 | pCtx->pFrontend = pParent;
|
---|
1224 |
|
---|
1225 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
|
---|
1226 | pCtx->fXtBusy = false;
|
---|
1227 | pCtx->fXtNeedsUpdate = false;
|
---|
1228 | #endif
|
---|
1229 |
|
---|
1230 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
|
---|
1231 | ShClTransferHttpServerInit(&pCtx->HttpCtx.HttpServer);
|
---|
1232 | #endif
|
---|
1233 |
|
---|
1234 | #ifdef TESTCASE
|
---|
1235 | if (RT_SUCCESS(rc))
|
---|
1236 | {
|
---|
1237 | /** @todo The testcases currently do not utilize the threading code. So init stuff here. */
|
---|
1238 | rc = clipInitInternal(pCtx);
|
---|
1239 | if (RT_SUCCESS(rc))
|
---|
1240 | rc = clipRegisterContext(pCtx);
|
---|
1241 | }
|
---|
1242 | #endif
|
---|
1243 |
|
---|
1244 | LogFlowFuncLeaveRC(rc);
|
---|
1245 | return rc;
|
---|
1246 | }
|
---|
1247 |
|
---|
1248 | /**
|
---|
1249 | * Destroys a Shared Clipboard X11 context.
|
---|
1250 | *
|
---|
1251 | * @param pCtx The X11 clipboard context to destroy.
|
---|
1252 | */
|
---|
1253 | void ShClX11Destroy(PSHCLX11CTX pCtx)
|
---|
1254 | {
|
---|
1255 | if (!pCtx)
|
---|
1256 | return;
|
---|
1257 |
|
---|
1258 | LogFlowFunc(("pCtx=%p\n", pCtx));
|
---|
1259 |
|
---|
1260 | #ifdef TESTCASE
|
---|
1261 | /** @todo The testcases currently do not utilize the threading code. So uninit stuff here. */
|
---|
1262 | clipUnregisterContext(pCtx);
|
---|
1263 | clipUninitInternal(pCtx);
|
---|
1264 | #endif
|
---|
1265 |
|
---|
1266 | if (pCtx->fHaveX11)
|
---|
1267 | {
|
---|
1268 | /* We set this to NULL when the event thread exits. It really should
|
---|
1269 | * have exited at this point, when we are about to unload the code from
|
---|
1270 | * memory. */
|
---|
1271 | Assert(pCtx->pWidget == NULL);
|
---|
1272 | }
|
---|
1273 | }
|
---|
1274 |
|
---|
1275 | #ifndef TESTCASE
|
---|
1276 | /**
|
---|
1277 | * Starts our own Xt even thread for handling Shared Clipboard messages, extended version.
|
---|
1278 | *
|
---|
1279 | * @returns VBox status code.
|
---|
1280 | * @param pCtx The X11 clipboard context to use.
|
---|
1281 | * @param pszName Thread name to use.
|
---|
1282 | * @param fGrab Whether we should try to grab the shared clipboard at once.
|
---|
1283 | */
|
---|
1284 | int ShClX11ThreadStartEx(PSHCLX11CTX pCtx, const char *pszName, bool fGrab)
|
---|
1285 | {
|
---|
1286 | AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
|
---|
1287 |
|
---|
1288 | /*
|
---|
1289 | * Immediately return if we are not connected to the X server.
|
---|
1290 | */
|
---|
1291 | if (!pCtx->fHaveX11)
|
---|
1292 | return VINF_SUCCESS;
|
---|
1293 |
|
---|
1294 | pCtx->fGrabClipboardOnStart = fGrab;
|
---|
1295 |
|
---|
1296 | clipResetX11Formats(pCtx);
|
---|
1297 |
|
---|
1298 | int rc;
|
---|
1299 |
|
---|
1300 | /*
|
---|
1301 | * Create the pipes.
|
---|
1302 | ** @todo r=andy Replace this with RTPipe API.
|
---|
1303 | */
|
---|
1304 | int pipes[2];
|
---|
1305 | if (!pipe(pipes))
|
---|
1306 | {
|
---|
1307 | pCtx->wakeupPipeRead = pipes[0];
|
---|
1308 | pCtx->wakeupPipeWrite = pipes[1];
|
---|
1309 |
|
---|
1310 | if (!fcntl(pCtx->wakeupPipeRead, F_SETFL, O_NONBLOCK))
|
---|
1311 | {
|
---|
1312 | rc = VINF_SUCCESS;
|
---|
1313 | }
|
---|
1314 | else
|
---|
1315 | rc = RTErrConvertFromErrno(errno);
|
---|
1316 | }
|
---|
1317 | else
|
---|
1318 | rc = RTErrConvertFromErrno(errno);
|
---|
1319 |
|
---|
1320 | if (RT_SUCCESS(rc))
|
---|
1321 | {
|
---|
1322 | LogRel2(("Shared Clipboard: Starting X11 event thread ...\n"));
|
---|
1323 |
|
---|
1324 | rc = RTThreadCreate(&pCtx->Thread, clipThreadMain, pCtx, 0,
|
---|
1325 | RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, pszName);
|
---|
1326 | if (RT_SUCCESS(rc))
|
---|
1327 | rc = RTThreadUserWait(pCtx->Thread, RT_MS_30SEC /* msTimeout */);
|
---|
1328 |
|
---|
1329 | if (RT_FAILURE(rc))
|
---|
1330 | {
|
---|
1331 | LogRel(("Shared Clipboard: Failed to start the X11 event thread with %Rrc\n", rc));
|
---|
1332 | clipUninitInternal(pCtx);
|
---|
1333 | }
|
---|
1334 | else
|
---|
1335 | {
|
---|
1336 | if (!pCtx->fThreadStarted)
|
---|
1337 | {
|
---|
1338 | LogRel(("Shared Clipboard: X11 event thread reported an error while starting\n"));
|
---|
1339 | }
|
---|
1340 | else
|
---|
1341 | LogRel2(("Shared Clipboard: X11 event thread started\n"));
|
---|
1342 | }
|
---|
1343 | }
|
---|
1344 |
|
---|
1345 | LogFlowFuncLeaveRC(rc);
|
---|
1346 | return rc;
|
---|
1347 | }
|
---|
1348 |
|
---|
1349 | /**
|
---|
1350 | * Starts our own Xt even thread for handling Shared Clipboard messages.
|
---|
1351 | *
|
---|
1352 | * @returns VBox status code.
|
---|
1353 | * @param pCtx The X11 clipboard context to use.
|
---|
1354 | * @param fGrab Whether we should try to grab the shared clipboard at once.
|
---|
1355 | */
|
---|
1356 | int ShClX11ThreadStart(PSHCLX11CTX pCtx, bool fGrab)
|
---|
1357 | {
|
---|
1358 | return ShClX11ThreadStartEx(pCtx, "SHCLX11", fGrab);
|
---|
1359 | }
|
---|
1360 |
|
---|
1361 | /**
|
---|
1362 | * Stops the Shared Clipboard Xt even thread.
|
---|
1363 | *
|
---|
1364 | * @note Any requests from this object to get clipboard data from VBox
|
---|
1365 | * *must* have completed or aborted before we are called, as
|
---|
1366 | * otherwise the X11 event loop will still be waiting for the request
|
---|
1367 | * to return and will not be able to terminate.
|
---|
1368 | *
|
---|
1369 | * @returns VBox status code.
|
---|
1370 | * @param pCtx The X11 clipboard context to use.
|
---|
1371 | */
|
---|
1372 | int ShClX11ThreadStop(PSHCLX11CTX pCtx)
|
---|
1373 | {
|
---|
1374 | int rc;
|
---|
1375 | /*
|
---|
1376 | * Immediately return if we are not connected to the X server.
|
---|
1377 | */
|
---|
1378 | if (!pCtx->fHaveX11)
|
---|
1379 | return VINF_SUCCESS;
|
---|
1380 |
|
---|
1381 | LogRel2(("Shared Clipboard: Signalling the X11 event thread to stop\n"));
|
---|
1382 |
|
---|
1383 | /* Write to the "stop" pipe. */
|
---|
1384 | rc = clipThreadScheduleCall(pCtx, clipThreadSignalStop, (XtPointer)pCtx);
|
---|
1385 | if (RT_FAILURE(rc))
|
---|
1386 | {
|
---|
1387 | LogRel(("Shared Clipboard: cannot notify X11 event thread on shutdown with %Rrc\n", rc));
|
---|
1388 | return rc;
|
---|
1389 | }
|
---|
1390 |
|
---|
1391 | LogRel2(("Shared Clipboard: Waiting for X11 event thread to stop ...\n"));
|
---|
1392 |
|
---|
1393 | int rcThread;
|
---|
1394 | rc = RTThreadWait(pCtx->Thread, RT_MS_30SEC /* msTimeout */, &rcThread);
|
---|
1395 | if (RT_SUCCESS(rc))
|
---|
1396 | rc = rcThread;
|
---|
1397 | if (RT_SUCCESS(rc))
|
---|
1398 | {
|
---|
1399 | if (pCtx->wakeupPipeRead != 0)
|
---|
1400 | {
|
---|
1401 | close(pCtx->wakeupPipeRead);
|
---|
1402 | pCtx->wakeupPipeRead = 0;
|
---|
1403 | }
|
---|
1404 |
|
---|
1405 | if (pCtx->wakeupPipeWrite != 0)
|
---|
1406 | {
|
---|
1407 | close(pCtx->wakeupPipeWrite);
|
---|
1408 | pCtx->wakeupPipeWrite = 0;
|
---|
1409 | }
|
---|
1410 | }
|
---|
1411 |
|
---|
1412 | if (RT_SUCCESS(rc))
|
---|
1413 | {
|
---|
1414 | LogRel2(("Shared Clipboard: X11 event thread stopped successfully\n"));
|
---|
1415 | }
|
---|
1416 | else
|
---|
1417 | LogRel(("Shared Clipboard: Stopping X11 event thread failed with %Rrc\n", rc));
|
---|
1418 |
|
---|
1419 | LogFlowFuncLeaveRC(rc);
|
---|
1420 | return rc;
|
---|
1421 | }
|
---|
1422 | #endif /* !TESTCASE */
|
---|
1423 |
|
---|
1424 | /**
|
---|
1425 | * Returns the targets supported by VBox.
|
---|
1426 | *
|
---|
1427 | * This will return a list of atoms which tells the caller
|
---|
1428 | * what kind of clipboard formats we support.
|
---|
1429 | *
|
---|
1430 | * @returns VBox status code.
|
---|
1431 | * @param pCtx The X11 clipboard context to use.
|
---|
1432 | * @param atomTypeReturn The type of the data we are returning.
|
---|
1433 | * @param pValReturn A pointer to the data we are returning. This
|
---|
1434 | * should be set to memory allocated by XtMalloc,
|
---|
1435 | * which will be freed later by the Xt toolkit.
|
---|
1436 | * @param pcLenReturn The length of the data we are returning.
|
---|
1437 | * @param piFormatReturn The format (8bit, 16bit, 32bit) of the data we are
|
---|
1438 | * returning.
|
---|
1439 | * @note X11 backend code, called by the XtOwnSelection callback.
|
---|
1440 | */
|
---|
1441 | static int clipCreateX11Targets(PSHCLX11CTX pCtx, Atom *atomTypeReturn,
|
---|
1442 | XtPointer *pValReturn,
|
---|
1443 | unsigned long *pcLenReturn,
|
---|
1444 | int *piFormatReturn)
|
---|
1445 | {
|
---|
1446 | const unsigned cFixedTargets = 3; /* See below. */
|
---|
1447 |
|
---|
1448 | Atom *pAtomTargets = (Atom *)XtMalloc((SHCL_MAX_X11_FORMATS + cFixedTargets) * sizeof(Atom));
|
---|
1449 | if (!pAtomTargets)
|
---|
1450 | return VERR_NO_MEMORY;
|
---|
1451 |
|
---|
1452 | unsigned cTargets = 0;
|
---|
1453 | SHCLX11FMTIDX idxFmt = NIL_CLIPX11FORMAT;
|
---|
1454 | do
|
---|
1455 | {
|
---|
1456 | idxFmt = clipEnumX11Formats(pCtx->vboxFormats, idxFmt);
|
---|
1457 | if (idxFmt != NIL_CLIPX11FORMAT)
|
---|
1458 | {
|
---|
1459 | pAtomTargets[cTargets] = clipAtomForX11Format(pCtx, idxFmt);
|
---|
1460 | ++cTargets;
|
---|
1461 | }
|
---|
1462 | } while (idxFmt != NIL_CLIPX11FORMAT);
|
---|
1463 |
|
---|
1464 | /* We always offer these fixed targets. */
|
---|
1465 | pAtomTargets[cTargets] = clipGetAtom(pCtx, "TARGETS");
|
---|
1466 | pAtomTargets[cTargets + 1] = clipGetAtom(pCtx, "MULTIPLE");
|
---|
1467 | pAtomTargets[cTargets + 2] = clipGetAtom(pCtx, "TIMESTAMP");
|
---|
1468 |
|
---|
1469 | *atomTypeReturn = XA_ATOM;
|
---|
1470 | *pValReturn = (XtPointer)pAtomTargets;
|
---|
1471 | *pcLenReturn = cTargets + cFixedTargets;
|
---|
1472 | *piFormatReturn = 32;
|
---|
1473 |
|
---|
1474 | LogFlowFunc(("cTargets=%u\n", cTargets + cFixedTargets));
|
---|
1475 |
|
---|
1476 | return VINF_SUCCESS;
|
---|
1477 | }
|
---|
1478 |
|
---|
1479 | /**
|
---|
1480 | * Helper for ShClX11RequestDataForX11Callback() that will cache the data returned.
|
---|
1481 | *
|
---|
1482 | * @returns VBox status code. VERR_NO_DATA if no data available.
|
---|
1483 | * @param pCtx The X11 clipboard context to use.
|
---|
1484 | * @param uFmt Clipboard format to read data in.
|
---|
1485 | * @param ppv Returns an allocated buffer with data read on success.
|
---|
1486 | * Needs to be free'd with RTMemFree() by the caller.
|
---|
1487 | * @param pcb Returns the amount of data read (in bytes) on success.
|
---|
1488 | */
|
---|
1489 | static int shClX11RequestDataForX11CallbackHelper(PSHCLX11CTX pCtx, SHCLFORMAT uFmt,
|
---|
1490 | void **ppv, uint32_t *pcb)
|
---|
1491 | {
|
---|
1492 | AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
|
---|
1493 | AssertPtrReturn(ppv, VERR_INVALID_POINTER);
|
---|
1494 | AssertPtrReturn(pcb, VERR_INVALID_POINTER);
|
---|
1495 |
|
---|
1496 | LogFlowFunc(("pCtx=%p, uFmt=%#x\n", pCtx, uFmt));
|
---|
1497 |
|
---|
1498 | int rc = VINF_SUCCESS;
|
---|
1499 |
|
---|
1500 | void *pv = NULL;
|
---|
1501 | uint32_t cb = 0;
|
---|
1502 |
|
---|
1503 | if (uFmt == VBOX_SHCL_FMT_UNICODETEXT)
|
---|
1504 | {
|
---|
1505 | if (pCtx->pvUnicodeCache == NULL) /** @todo r=andy Using string cache here? */
|
---|
1506 | rc = pCtx->Callbacks.pfnOnRequestDataFromSource(pCtx->pFrontend, uFmt, &pCtx->pvUnicodeCache, &pCtx->cbUnicodeCache,
|
---|
1507 | NULL /* pvUser */);
|
---|
1508 | if ( RT_SUCCESS(rc)
|
---|
1509 | /* Catch misbehaving callbacks. */
|
---|
1510 | && pCtx->pvUnicodeCache
|
---|
1511 | && pCtx->cbUnicodeCache)
|
---|
1512 | {
|
---|
1513 | pv = RTMemDup(pCtx->pvUnicodeCache, pCtx->cbUnicodeCache);
|
---|
1514 | if (pv)
|
---|
1515 | cb = pCtx->cbUnicodeCache;
|
---|
1516 | else
|
---|
1517 | rc = VERR_NO_MEMORY;
|
---|
1518 | }
|
---|
1519 | }
|
---|
1520 | else
|
---|
1521 | rc = pCtx->Callbacks.pfnOnRequestDataFromSource(pCtx->pFrontend, uFmt, &pv, &cb, NULL /* pvUser */);
|
---|
1522 |
|
---|
1523 |
|
---|
1524 | /* Safey net in case the callbacks above misbehave
|
---|
1525 | * (must return VERR_NO_DATA if no data available). */
|
---|
1526 | if ( RT_SUCCESS(rc)
|
---|
1527 | && (pv == NULL || cb == 0))
|
---|
1528 | rc = VERR_NO_DATA;
|
---|
1529 |
|
---|
1530 | if (RT_SUCCESS(rc))
|
---|
1531 | {
|
---|
1532 | *ppv = pv;
|
---|
1533 | *pcb = cb;
|
---|
1534 | }
|
---|
1535 |
|
---|
1536 | LogFlowFunc(("Returning pv=%p, cb=%RU32, rc=%Rrc\n", pv, cb, rc));
|
---|
1537 | return rc;
|
---|
1538 | }
|
---|
1539 |
|
---|
1540 | /**
|
---|
1541 | * Satisfies a request from X11 to convert the clipboard text to UTF-8 LF.
|
---|
1542 | *
|
---|
1543 | * @returns VBox status code. VERR_NO_DATA if no data was converted.
|
---|
1544 | * @param pDisplay An X11 display structure, needed for conversions
|
---|
1545 | * performed by Xlib.
|
---|
1546 | * @param pv The text to be converted (UCS-2 with Windows EOLs).
|
---|
1547 | * @param cb The length of the text in @cb in bytes.
|
---|
1548 | * @param atomTypeReturn Where to store the atom for the type of the data
|
---|
1549 | * we are returning.
|
---|
1550 | * @param pValReturn Where to store the pointer to the data we are
|
---|
1551 | * returning. This should be to memory allocated by
|
---|
1552 | * XtMalloc, which will be freed by the Xt toolkit
|
---|
1553 | * later.
|
---|
1554 | * @param pcLenReturn Where to store the length of the data we are
|
---|
1555 | * returning.
|
---|
1556 | * @param piFormatReturn Where to store the bit width (8, 16, 32) of the
|
---|
1557 | * data we are returning.
|
---|
1558 | */
|
---|
1559 | static int clipConvertUtf16ToX11Data(Display *pDisplay, PRTUTF16 pwszSrc,
|
---|
1560 | size_t cbSrc, Atom *atomTarget,
|
---|
1561 | Atom *atomTypeReturn,
|
---|
1562 | XtPointer *pValReturn,
|
---|
1563 | unsigned long *pcLenReturn,
|
---|
1564 | int *piFormatReturn)
|
---|
1565 | {
|
---|
1566 | RT_NOREF(pDisplay);
|
---|
1567 | AssertReturn(cbSrc % sizeof(RTUTF16) == 0, VERR_INVALID_PARAMETER);
|
---|
1568 |
|
---|
1569 | const size_t cwcSrc = cbSrc / sizeof(RTUTF16);
|
---|
1570 | if (!cwcSrc)
|
---|
1571 | return VERR_NO_DATA;
|
---|
1572 |
|
---|
1573 | /* This may slightly overestimate the space needed. */
|
---|
1574 | size_t chDst = 0;
|
---|
1575 | int rc = ShClUtf16LenUtf8(pwszSrc, cwcSrc, &chDst);
|
---|
1576 | if (RT_SUCCESS(rc))
|
---|
1577 | {
|
---|
1578 | chDst++; /* Add space for terminator. */
|
---|
1579 |
|
---|
1580 | char *pszDst = (char *)XtMalloc(chDst);
|
---|
1581 | if (pszDst)
|
---|
1582 | {
|
---|
1583 | size_t cbActual = 0;
|
---|
1584 | rc = ShClConvUtf16CRLFToUtf8LF(pwszSrc, cwcSrc, pszDst, chDst, &cbActual);
|
---|
1585 | if (RT_SUCCESS(rc))
|
---|
1586 | {
|
---|
1587 | *atomTypeReturn = *atomTarget;
|
---|
1588 | *pValReturn = (XtPointer)pszDst;
|
---|
1589 | *pcLenReturn = cbActual + 1 /* Include terminator */;
|
---|
1590 | *piFormatReturn = 8;
|
---|
1591 | }
|
---|
1592 | }
|
---|
1593 | else
|
---|
1594 | rc = VERR_NO_MEMORY;
|
---|
1595 | }
|
---|
1596 |
|
---|
1597 | LogFlowFuncLeaveRC(rc);
|
---|
1598 | return rc;
|
---|
1599 | }
|
---|
1600 |
|
---|
1601 | /**
|
---|
1602 | * Satisfies a request from X11 to convert the clipboard HTML fragment to UTF-8. We
|
---|
1603 | * return null-terminated text, but can cope with non-null-terminated input.
|
---|
1604 | *
|
---|
1605 | * @returns VBox status code.
|
---|
1606 | * @param pDisplay An X11 display structure, needed for conversions
|
---|
1607 | * performed by Xlib.
|
---|
1608 | * @param pv The text to be converted (UTF8 with Windows EOLs).
|
---|
1609 | * @param cb The length of the text in @cb in bytes.
|
---|
1610 | * @param atomTypeReturn Where to store the atom for the type of the data
|
---|
1611 | * we are returning.
|
---|
1612 | * @param pValReturn Where to store the pointer to the data we are
|
---|
1613 | * returning. This should be to memory allocated by
|
---|
1614 | * XtMalloc, which will be freed by the Xt toolkit later.
|
---|
1615 | * @param pcLenReturn Where to store the length of the data we are returning.
|
---|
1616 | * @param piFormatReturn Where to store the bit width (8, 16, 32) of the
|
---|
1617 | * data we are returning.
|
---|
1618 | */
|
---|
1619 | static int clipConvertHtmlToX11Data(Display *pDisplay, const char *pszSrc,
|
---|
1620 | size_t cbSrc, Atom *atomTarget,
|
---|
1621 | Atom *atomTypeReturn,
|
---|
1622 | XtPointer *pValReturn,
|
---|
1623 | unsigned long *pcLenReturn,
|
---|
1624 | int *piFormatReturn)
|
---|
1625 | {
|
---|
1626 | RT_NOREF(pDisplay, pValReturn);
|
---|
1627 |
|
---|
1628 | /* This may slightly overestimate the space needed. */
|
---|
1629 | LogFlowFunc(("Source: %s", pszSrc));
|
---|
1630 |
|
---|
1631 | char *pszDest = (char *)XtMalloc(cbSrc);
|
---|
1632 | if (pszDest == NULL)
|
---|
1633 | return VERR_NO_MEMORY;
|
---|
1634 |
|
---|
1635 | memcpy(pszDest, pszSrc, cbSrc);
|
---|
1636 |
|
---|
1637 | *atomTypeReturn = *atomTarget;
|
---|
1638 | *pValReturn = (XtPointer)pszDest;
|
---|
1639 | *pcLenReturn = cbSrc;
|
---|
1640 | *piFormatReturn = 8;
|
---|
1641 |
|
---|
1642 | return VINF_SUCCESS;
|
---|
1643 | }
|
---|
1644 |
|
---|
1645 |
|
---|
1646 | /**
|
---|
1647 | * Does this atom correspond to one of the two selection types we support?
|
---|
1648 | *
|
---|
1649 | * @param pCtx The X11 clipboard context to use.
|
---|
1650 | * @param selType The atom in question.
|
---|
1651 | */
|
---|
1652 | static bool clipIsSupportedSelectionType(PSHCLX11CTX pCtx, Atom selType)
|
---|
1653 | {
|
---|
1654 | return( (selType == clipGetAtom(pCtx, "CLIPBOARD"))
|
---|
1655 | || (selType == clipGetAtom(pCtx, "PRIMARY")));
|
---|
1656 | }
|
---|
1657 |
|
---|
1658 | /**
|
---|
1659 | * Removes a trailing nul character from a string by adjusting the string
|
---|
1660 | * length. Some X11 applications don't like zero-terminated text...
|
---|
1661 | *
|
---|
1662 | * @param pText The text in question.
|
---|
1663 | * @param pcText The length of the text, adjusted on return.
|
---|
1664 | * @param format The format of the text.
|
---|
1665 | */
|
---|
1666 | static void clipTrimTrailingNul(XtPointer pText, unsigned long *pcText,
|
---|
1667 | SHCLX11FMT format)
|
---|
1668 | {
|
---|
1669 | AssertPtrReturnVoid(pText);
|
---|
1670 | AssertPtrReturnVoid(pcText);
|
---|
1671 | AssertReturnVoid((format == SHCLX11FMT_UTF8) || (format == SHCLX11FMT_TEXT) || (format == SHCLX11FMT_HTML));
|
---|
1672 |
|
---|
1673 | if (((char *)pText)[*pcText - 1] == '\0')
|
---|
1674 | --(*pcText);
|
---|
1675 | }
|
---|
1676 |
|
---|
1677 | static int clipConvertToX11Data(PSHCLX11CTX pCtx, Atom *atomTarget,
|
---|
1678 | Atom *atomTypeReturn,
|
---|
1679 | XtPointer *pValReturn,
|
---|
1680 | unsigned long *pcLenReturn,
|
---|
1681 | int *piFormatReturn)
|
---|
1682 | {
|
---|
1683 | int rc = VERR_NOT_SUPPORTED; /* Play safe by default. */
|
---|
1684 |
|
---|
1685 | SHCLX11FMTIDX idxFmtX11 = clipFindX11FormatByAtom(pCtx, *atomTarget);
|
---|
1686 | SHCLX11FMT fmtX11 = clipRealFormatForX11Format(idxFmtX11);
|
---|
1687 |
|
---|
1688 | LogFlowFunc(("vboxFormats=0x%x, idxFmtX11=%u ('%s'), fmtX11=%u\n",
|
---|
1689 | pCtx->vboxFormats, idxFmtX11, g_aFormats[idxFmtX11].pcszAtom, fmtX11));
|
---|
1690 |
|
---|
1691 | #ifdef LOG_ENABLED
|
---|
1692 | char *pszFmts = ShClFormatsToStrA(pCtx->vboxFormats);
|
---|
1693 | AssertPtrReturn(pszFmts, VERR_NO_MEMORY);
|
---|
1694 | LogRel2(("Shared Clipboard: Converting VBox formats '%s' to '%s' for X11\n",
|
---|
1695 | pszFmts, g_aFormats[idxFmtX11].pcszAtom));
|
---|
1696 | RTStrFree(pszFmts);
|
---|
1697 | #endif
|
---|
1698 |
|
---|
1699 | void *pv = NULL;
|
---|
1700 | uint32_t cb = 0;
|
---|
1701 |
|
---|
1702 | if ( ( (fmtX11 == SHCLX11FMT_UTF8)
|
---|
1703 | || (fmtX11 == SHCLX11FMT_TEXT)
|
---|
1704 | )
|
---|
1705 | && (pCtx->vboxFormats & VBOX_SHCL_FMT_UNICODETEXT))
|
---|
1706 | {
|
---|
1707 | rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_UNICODETEXT, &pv, &cb);
|
---|
1708 | if ( RT_SUCCESS(rc)
|
---|
1709 | && ( (fmtX11 == SHCLX11FMT_UTF8)
|
---|
1710 | || (fmtX11 == SHCLX11FMT_TEXT)))
|
---|
1711 | {
|
---|
1712 | rc = clipConvertUtf16ToX11Data(XtDisplay(pCtx->pWidget),
|
---|
1713 | (PRTUTF16)pv, cb, atomTarget,
|
---|
1714 | atomTypeReturn, pValReturn,
|
---|
1715 | pcLenReturn, piFormatReturn);
|
---|
1716 | }
|
---|
1717 |
|
---|
1718 | if (RT_SUCCESS(rc))
|
---|
1719 | clipTrimTrailingNul(*(XtPointer *)pValReturn, pcLenReturn, fmtX11);
|
---|
1720 |
|
---|
1721 | RTMemFree(pv);
|
---|
1722 | }
|
---|
1723 | else if ( (fmtX11 == SHCLX11FMT_BMP)
|
---|
1724 | && (pCtx->vboxFormats & VBOX_SHCL_FMT_BITMAP))
|
---|
1725 | {
|
---|
1726 | rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_BITMAP, &pv, &cb);
|
---|
1727 | if ( RT_SUCCESS(rc)
|
---|
1728 | && (fmtX11 == SHCLX11FMT_BMP))
|
---|
1729 | {
|
---|
1730 | /* Create a full BMP from it. */
|
---|
1731 | rc = ShClDibToBmp(pv, cb, (void **)pValReturn,
|
---|
1732 | (size_t *)pcLenReturn);
|
---|
1733 | }
|
---|
1734 |
|
---|
1735 | if (RT_SUCCESS(rc))
|
---|
1736 | {
|
---|
1737 | *atomTypeReturn = *atomTarget;
|
---|
1738 | *piFormatReturn = 8;
|
---|
1739 | }
|
---|
1740 |
|
---|
1741 | RTMemFree(pv);
|
---|
1742 | }
|
---|
1743 | else if ( (fmtX11 == SHCLX11FMT_HTML)
|
---|
1744 | && (pCtx->vboxFormats & VBOX_SHCL_FMT_HTML))
|
---|
1745 | {
|
---|
1746 | rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_HTML, &pv, &cb);
|
---|
1747 | if (RT_SUCCESS(rc))
|
---|
1748 | {
|
---|
1749 | /**
|
---|
1750 | * The common VBox HTML encoding will be UTF-8.
|
---|
1751 | * Before sending it to the X11 clipboard we have to convert it to UTF-8 first.
|
---|
1752 | *
|
---|
1753 | * Strange that we get UTF-16 from the X11 clipboard, but
|
---|
1754 | * in same time we send UTF-8 to X11 clipboard and it works.
|
---|
1755 | ** @todo r=andy Verify this.
|
---|
1756 | */
|
---|
1757 | rc = clipConvertHtmlToX11Data(XtDisplay(pCtx->pWidget),
|
---|
1758 | (const char*)pv, cb, atomTarget,
|
---|
1759 | atomTypeReturn, pValReturn,
|
---|
1760 | pcLenReturn, piFormatReturn);
|
---|
1761 | if (RT_SUCCESS(rc))
|
---|
1762 | clipTrimTrailingNul(*(XtPointer *)pValReturn, pcLenReturn, fmtX11);
|
---|
1763 |
|
---|
1764 | RTMemFree(pv);
|
---|
1765 | }
|
---|
1766 | }
|
---|
1767 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
|
---|
1768 | else if (fmtX11 == SHCLX11FMT_URI_LIST)
|
---|
1769 | {
|
---|
1770 | if (pCtx->vboxFormats & VBOX_SHCL_FMT_URI_LIST)
|
---|
1771 | {
|
---|
1772 | rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_URI_LIST, &pv, &cb);
|
---|
1773 | if (RT_SUCCESS(rc))
|
---|
1774 | {
|
---|
1775 | void *pvDst = (void *)XtMalloc(cb);
|
---|
1776 | if (pvDst)
|
---|
1777 | {
|
---|
1778 | memcpy(pvDst, pv, cb);
|
---|
1779 |
|
---|
1780 | *atomTypeReturn = *atomTarget;
|
---|
1781 | *pValReturn = (XtPointer)pvDst;
|
---|
1782 | *pcLenReturn = cb;
|
---|
1783 | *piFormatReturn = 8;
|
---|
1784 | }
|
---|
1785 | else
|
---|
1786 | rc = VERR_NO_MEMORY;
|
---|
1787 | }
|
---|
1788 | }
|
---|
1789 | /* else not supported yet. */
|
---|
1790 | }
|
---|
1791 | #endif
|
---|
1792 | else
|
---|
1793 | {
|
---|
1794 | *atomTypeReturn = XT_CONVERT_FAIL;
|
---|
1795 | *pValReturn = (XtPointer)NULL;
|
---|
1796 | *pcLenReturn = 0;
|
---|
1797 | *piFormatReturn = 0;
|
---|
1798 | }
|
---|
1799 |
|
---|
1800 | if (RT_FAILURE(rc))
|
---|
1801 | {
|
---|
1802 | char *pszFmts2 = ShClFormatsToStrA(pCtx->vboxFormats);
|
---|
1803 | char *pszAtomName = XGetAtomName(XtDisplay(pCtx->pWidget), *atomTarget);
|
---|
1804 |
|
---|
1805 | LogRel(("Shared Clipboard: Converting VBox formats '%s' to '%s' for X11 (idxFmtX11=%u, fmtX11=%u, atomTarget='%s') failed, rc=%Rrc\n",
|
---|
1806 | pszFmts2 ? pszFmts2 : "unknown", g_aFormats[idxFmtX11].pcszAtom, idxFmtX11, fmtX11, pszAtomName ? pszAtomName : "unknown", rc));
|
---|
1807 |
|
---|
1808 | if (pszFmts2)
|
---|
1809 | RTStrFree(pszFmts2);
|
---|
1810 | if (pszAtomName)
|
---|
1811 | XFree(pszAtomName);
|
---|
1812 | }
|
---|
1813 |
|
---|
1814 | LogFlowFuncLeaveRC(rc);
|
---|
1815 | return rc;
|
---|
1816 | }
|
---|
1817 |
|
---|
1818 | /**
|
---|
1819 | * Returns VBox's clipboard data for an X11 client.
|
---|
1820 | *
|
---|
1821 | * @note Callback for XtOwnSelection.
|
---|
1822 | */
|
---|
1823 | static Boolean clipXtConvertSelectionProc(Widget widget, Atom *atomSelection,
|
---|
1824 | Atom *atomTarget,
|
---|
1825 | Atom *atomTypeReturn,
|
---|
1826 | XtPointer *pValReturn,
|
---|
1827 | unsigned long *pcLenReturn,
|
---|
1828 | int *piFormatReturn)
|
---|
1829 | {
|
---|
1830 | LogFlowFuncEnter();
|
---|
1831 |
|
---|
1832 | PSHCLX11CTX pCtx = clipLookupContext(widget);
|
---|
1833 | if (!pCtx)
|
---|
1834 | return False;
|
---|
1835 |
|
---|
1836 | /* Is this the rigt selection (clipboard) we were asked for? */
|
---|
1837 | if (!clipIsSupportedSelectionType(pCtx, *atomSelection))
|
---|
1838 | return False;
|
---|
1839 |
|
---|
1840 | int rc;
|
---|
1841 | if (*atomTarget == clipGetAtom(pCtx, "TARGETS"))
|
---|
1842 | rc = clipCreateX11Targets(pCtx, atomTypeReturn, pValReturn,
|
---|
1843 | pcLenReturn, piFormatReturn);
|
---|
1844 | else
|
---|
1845 | rc = clipConvertToX11Data(pCtx, atomTarget, atomTypeReturn,
|
---|
1846 | pValReturn, pcLenReturn, piFormatReturn);
|
---|
1847 |
|
---|
1848 | #if 0 /** @todo Disabled -- crashes when running with tstClipboardGH-X11. */
|
---|
1849 | XSelectionRequestEvent* pReq =
|
---|
1850 | XtGetSelectionRequest(widget, *atomSelection, (XtRequestId)NULL);
|
---|
1851 | LogFlowFunc(("returning pVBoxWnd=%#x, ownerWnd=%#x, reqWnd=%#x, %RTbool, rc=%Rrc\n",
|
---|
1852 | XtWindow(pCtx->pWidget), pReq->owner, pReq->requestor, RT_SUCCESS(rc), rc));
|
---|
1853 | #endif
|
---|
1854 | return RT_SUCCESS(rc) ? True : False;
|
---|
1855 | }
|
---|
1856 |
|
---|
1857 | static void clipXtConvertSelectionProcLose(Widget widget, Atom *atomSelection)
|
---|
1858 | {
|
---|
1859 | RT_NOREF(widget, atomSelection);
|
---|
1860 | LogFlowFuncEnter();
|
---|
1861 | }
|
---|
1862 |
|
---|
1863 | static void clipXtConvertSelectionProcDone(Widget widget, Atom *atomSelection, Atom *atomTarget)
|
---|
1864 | {
|
---|
1865 | RT_NOREF(widget, atomSelection, atomTarget);
|
---|
1866 | LogFlowFuncEnter();
|
---|
1867 | }
|
---|
1868 |
|
---|
1869 | /**
|
---|
1870 | * Structure used to pass information about formats that VBox supports.
|
---|
1871 | */
|
---|
1872 | typedef struct _CLIPNEWVBOXFORMATS
|
---|
1873 | {
|
---|
1874 | /** Context information for the X11 clipboard. */
|
---|
1875 | PSHCLX11CTX pCtx;
|
---|
1876 | /** Formats supported by VBox. */
|
---|
1877 | SHCLFORMATS Formats;
|
---|
1878 | } CLIPNEWVBOXFORMATS, *PCLIPNEWVBOXFORMATS;
|
---|
1879 |
|
---|
1880 |
|
---|
1881 |
|
---|
1882 | /**
|
---|
1883 | * Invalidates the local cache of the data in the VBox clipboard.
|
---|
1884 | *
|
---|
1885 | * @param pCtx The X11 clipboard context to use.
|
---|
1886 | */
|
---|
1887 | static void clipInvalidateClipboardCache(PSHCLX11CTX pCtx)
|
---|
1888 | {
|
---|
1889 | if (pCtx->pvUnicodeCache != NULL)
|
---|
1890 | {
|
---|
1891 | RTMemFree(pCtx->pvUnicodeCache);
|
---|
1892 | pCtx->pvUnicodeCache = NULL;
|
---|
1893 | }
|
---|
1894 | }
|
---|
1895 |
|
---|
1896 | /**
|
---|
1897 | * Takes possession of the X11 clipboard (and middle-button selection).
|
---|
1898 | *
|
---|
1899 | * @param pCtx The X11 clipboard context to use.
|
---|
1900 | * @param uFormats Clipboard formats to set.
|
---|
1901 | */
|
---|
1902 | static void clipGrabX11Clipboard(PSHCLX11CTX pCtx, SHCLFORMATS uFormats)
|
---|
1903 | {
|
---|
1904 | LogFlowFuncEnter();
|
---|
1905 |
|
---|
1906 | /** @ŧodo r=andy The docs say: "the value CurrentTime is not acceptable" here!? */
|
---|
1907 | if (XtOwnSelection(pCtx->pWidget, clipGetAtom(pCtx, "CLIPBOARD"),
|
---|
1908 | CurrentTime,
|
---|
1909 | clipXtConvertSelectionProc, clipXtConvertSelectionProcLose, clipXtConvertSelectionProcDone))
|
---|
1910 | {
|
---|
1911 | pCtx->vboxFormats = uFormats;
|
---|
1912 |
|
---|
1913 | /* Grab the middle-button paste selection too. */
|
---|
1914 | XtOwnSelection(pCtx->pWidget, clipGetAtom(pCtx, "PRIMARY"),
|
---|
1915 | CurrentTime, clipXtConvertSelectionProc, NULL, 0);
|
---|
1916 | #ifndef TESTCASE
|
---|
1917 | /* Xt suppresses these if we already own the clipboard, so send them
|
---|
1918 | * ourselves. */
|
---|
1919 | XSetSelectionOwner(XtDisplay(pCtx->pWidget),
|
---|
1920 | clipGetAtom(pCtx, "CLIPBOARD"),
|
---|
1921 | XtWindow(pCtx->pWidget), CurrentTime);
|
---|
1922 | XSetSelectionOwner(XtDisplay(pCtx->pWidget),
|
---|
1923 | clipGetAtom(pCtx, "PRIMARY"),
|
---|
1924 | XtWindow(pCtx->pWidget), CurrentTime);
|
---|
1925 | #endif
|
---|
1926 | }
|
---|
1927 | }
|
---|
1928 |
|
---|
1929 | /**
|
---|
1930 | * Worker function for ShClX11ReportFormatsToX11 which runs on the
|
---|
1931 | * event thread.
|
---|
1932 | *
|
---|
1933 | * @param pvUserData Pointer to a CLIPNEWVBOXFORMATS structure containing
|
---|
1934 | * information about the VBox formats available and the
|
---|
1935 | * clipboard context data. Must be freed by the worker.
|
---|
1936 | */
|
---|
1937 | static void ShClX11ReportFormatsToX11Worker(void *pvUserData, void * /* interval */)
|
---|
1938 | {
|
---|
1939 | AssertPtrReturnVoid(pvUserData);
|
---|
1940 |
|
---|
1941 | CLIPNEWVBOXFORMATS *pFormats = (CLIPNEWVBOXFORMATS *)pvUserData;
|
---|
1942 |
|
---|
1943 | PSHCLX11CTX pCtx = pFormats->pCtx;
|
---|
1944 | SHCLFORMATS fFormats = pFormats->Formats;
|
---|
1945 |
|
---|
1946 | RTMemFree(pFormats);
|
---|
1947 |
|
---|
1948 | #ifdef LOG_ENABLED
|
---|
1949 | char *pszFmts = ShClFormatsToStrA(fFormats);
|
---|
1950 | AssertPtrReturnVoid(pszFmts);
|
---|
1951 | LogRel2(("Shared Clipboard: Reported available VBox formats %s to X11\n", pszFmts));
|
---|
1952 | RTStrFree(pszFmts);
|
---|
1953 | #endif
|
---|
1954 |
|
---|
1955 | clipInvalidateClipboardCache(pCtx);
|
---|
1956 | clipGrabX11Clipboard(pCtx, fFormats);
|
---|
1957 | clipResetX11Formats(pCtx);
|
---|
1958 |
|
---|
1959 | LogFlowFuncLeave();
|
---|
1960 | }
|
---|
1961 |
|
---|
1962 | /**
|
---|
1963 | * Announces new clipboard formats to the X11 clipboard.
|
---|
1964 | *
|
---|
1965 | * @returns VBox status code.
|
---|
1966 | * @param pCtx Context data for the clipboard backend.
|
---|
1967 | * @param uFormats Clipboard formats offered.
|
---|
1968 | */
|
---|
1969 | int ShClX11ReportFormatsToX11(PSHCLX11CTX pCtx, SHCLFORMATS uFormats)
|
---|
1970 | {
|
---|
1971 | /*
|
---|
1972 | * Immediately return if we are not connected to the X server.
|
---|
1973 | */
|
---|
1974 | if (!pCtx->fHaveX11)
|
---|
1975 | return VINF_SUCCESS;
|
---|
1976 |
|
---|
1977 | int rc;
|
---|
1978 |
|
---|
1979 | /* This must be free'd by the worker callback. */
|
---|
1980 | PCLIPNEWVBOXFORMATS pFormats = (PCLIPNEWVBOXFORMATS)RTMemAlloc(sizeof(CLIPNEWVBOXFORMATS));
|
---|
1981 | if (pFormats)
|
---|
1982 | {
|
---|
1983 | pFormats->pCtx = pCtx;
|
---|
1984 | pFormats->Formats = uFormats;
|
---|
1985 | rc = clipThreadScheduleCall(pCtx, ShClX11ReportFormatsToX11Worker,
|
---|
1986 | (XtPointer)pFormats);
|
---|
1987 | if (RT_FAILURE(rc))
|
---|
1988 | RTMemFree(pFormats);
|
---|
1989 | }
|
---|
1990 | else
|
---|
1991 | rc = VERR_NO_MEMORY;
|
---|
1992 |
|
---|
1993 | LogFlowFuncLeaveRC(rc);
|
---|
1994 | return rc;
|
---|
1995 | }
|
---|
1996 |
|
---|
1997 | /**
|
---|
1998 | * Converts the data obtained from the X11 clipboard to the required format,
|
---|
1999 | * place it in the buffer supplied and signal that data has arrived.
|
---|
2000 | *
|
---|
2001 | * Converts the text obtained UTF-16LE with Windows EOLs.
|
---|
2002 | * Converts full BMP data to DIB format.
|
---|
2003 | */
|
---|
2004 | SHCL_X11_DECL(void) clipConvertDataFromX11Worker(void *pClient, void *pvSrc, unsigned cbSrc)
|
---|
2005 | {
|
---|
2006 | CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *)pClient;
|
---|
2007 | AssertPtrReturnVoid(pReq);
|
---|
2008 |
|
---|
2009 | LogFlowFunc(("pReq->uFmtVBox=%#x, pReq->idxFmtX11=%u, pReq->pCtx=%p\n", pReq->uFmtVBox, pReq->idxFmtX11, pReq->pCtx));
|
---|
2010 |
|
---|
2011 | LogRel2(("Shared Clipboard: Converting X11 format '%s' to VBox format %#x\n",
|
---|
2012 | g_aFormats[pReq->idxFmtX11].pcszAtom, pReq->uFmtVBox));
|
---|
2013 |
|
---|
2014 | AssertPtr(pReq->pCtx);
|
---|
2015 | Assert(pReq->uFmtVBox != VBOX_SHCL_FMT_NONE); /* Sanity. */
|
---|
2016 |
|
---|
2017 | int rc = VINF_SUCCESS;
|
---|
2018 |
|
---|
2019 | void *pvDst = NULL;
|
---|
2020 | size_t cbDst = 0;
|
---|
2021 |
|
---|
2022 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
|
---|
2023 | PSHCLX11CTX pCtx = pReq->pCtx;
|
---|
2024 | AssertPtr(pReq->pCtx);
|
---|
2025 | clipSetXtBusy(pCtx, false);
|
---|
2026 | if (clipGetXtNeedsUpdate(pCtx))
|
---|
2027 | clipQueryX11Targets(pCtx);
|
---|
2028 | #endif
|
---|
2029 |
|
---|
2030 | /* If X11 clipboard buffer has no data, libXt can pass to XtGetSelectionValue()
|
---|
2031 | * callback an empty string, in this case cbSrc is 0. */
|
---|
2032 | if (pvSrc == NULL || cbSrc == 0)
|
---|
2033 | {
|
---|
2034 | /* The clipboard selection may have changed before we could get it. */
|
---|
2035 | rc = VERR_NO_DATA;
|
---|
2036 | }
|
---|
2037 | else if (pReq->uFmtVBox == VBOX_SHCL_FMT_UNICODETEXT)
|
---|
2038 | {
|
---|
2039 | /* In which format is the clipboard data? */
|
---|
2040 | switch (clipRealFormatForX11Format(pReq->idxFmtX11))
|
---|
2041 | {
|
---|
2042 | case SHCLX11FMT_UTF8:
|
---|
2043 | RT_FALL_THROUGH();
|
---|
2044 | case SHCLX11FMT_TEXT:
|
---|
2045 | {
|
---|
2046 | size_t cwDst;
|
---|
2047 | /* If we are given broken UTF-8, we treat it as Latin1. */ /** @todo BUGBUG Is this acceptable? */
|
---|
2048 | if (RT_SUCCESS(RTStrValidateEncodingEx((char *)pvSrc, cbSrc, 0)))
|
---|
2049 | rc = ShClConvUtf8LFToUtf16CRLF((const char *)pvSrc, cbSrc,
|
---|
2050 | (PRTUTF16 *)&pvDst, &cwDst);
|
---|
2051 | else
|
---|
2052 | rc = ShClConvLatin1LFToUtf16CRLF((char *)pvSrc, cbSrc,
|
---|
2053 | (PRTUTF16 *)&pvDst, &cwDst);
|
---|
2054 | if (RT_SUCCESS(rc))
|
---|
2055 | {
|
---|
2056 | cwDst += 1 /* Include terminator */;
|
---|
2057 | cbDst = cwDst * sizeof(RTUTF16); /* Convert RTUTF16 units to bytes. */
|
---|
2058 | }
|
---|
2059 | break;
|
---|
2060 | }
|
---|
2061 |
|
---|
2062 | default:
|
---|
2063 | {
|
---|
2064 | rc = VERR_INVALID_PARAMETER;
|
---|
2065 | break;
|
---|
2066 | }
|
---|
2067 | }
|
---|
2068 | }
|
---|
2069 | else if (pReq->uFmtVBox == VBOX_SHCL_FMT_BITMAP)
|
---|
2070 | {
|
---|
2071 | /* In which format is the clipboard data? */
|
---|
2072 | switch (clipRealFormatForX11Format(pReq->idxFmtX11))
|
---|
2073 | {
|
---|
2074 | case SHCLX11FMT_BMP:
|
---|
2075 | {
|
---|
2076 | const void *pDib;
|
---|
2077 | size_t cbDibSize;
|
---|
2078 | rc = ShClBmpGetDib((const void *)pvSrc, cbSrc,
|
---|
2079 | &pDib, &cbDibSize);
|
---|
2080 | if (RT_SUCCESS(rc))
|
---|
2081 | {
|
---|
2082 | pvDst = RTMemAlloc(cbDibSize);
|
---|
2083 | if (!pvDst)
|
---|
2084 | rc = VERR_NO_MEMORY;
|
---|
2085 | else
|
---|
2086 | {
|
---|
2087 | memcpy(pvDst, pDib, cbDibSize);
|
---|
2088 | cbDst = cbDibSize;
|
---|
2089 | }
|
---|
2090 | }
|
---|
2091 | break;
|
---|
2092 | }
|
---|
2093 |
|
---|
2094 | default:
|
---|
2095 | {
|
---|
2096 | rc = VERR_INVALID_PARAMETER;
|
---|
2097 | break;
|
---|
2098 | }
|
---|
2099 | }
|
---|
2100 | }
|
---|
2101 | else if (pReq->uFmtVBox == VBOX_SHCL_FMT_HTML)
|
---|
2102 | {
|
---|
2103 | /* In which format is the clipboard data? */
|
---|
2104 | switch (clipRealFormatForX11Format(pReq->idxFmtX11))
|
---|
2105 | {
|
---|
2106 | case SHCLX11FMT_HTML:
|
---|
2107 | {
|
---|
2108 | /*
|
---|
2109 | * The common VBox HTML encoding will be - UTF-8
|
---|
2110 | * because it more general for HTML formats then UTF-16
|
---|
2111 | * X11 clipboard returns UTF-16, so before sending it we should
|
---|
2112 | * convert it to UTF-8.
|
---|
2113 | */
|
---|
2114 | pvDst = NULL;
|
---|
2115 | cbDst = 0;
|
---|
2116 |
|
---|
2117 | /*
|
---|
2118 | * Some applications sends data in UTF-16, some in UTF-8,
|
---|
2119 | * without indication it in MIME.
|
---|
2120 | *
|
---|
2121 | * In case of UTF-16, at least [Open|Libre] Office adds an byte order mark (0xfeff)
|
---|
2122 | * at the start of the clipboard data.
|
---|
2123 | */
|
---|
2124 | if ( cbSrc >= sizeof(RTUTF16)
|
---|
2125 | && *(PRTUTF16)pvSrc == VBOX_SHCL_UTF16LEMARKER)
|
---|
2126 | {
|
---|
2127 | rc = ShClConvUtf16ToUtf8HTML((PRTUTF16)pvSrc, cbSrc / sizeof(RTUTF16), (char**)&pvDst, &cbDst);
|
---|
2128 | if (RT_SUCCESS(rc))
|
---|
2129 | {
|
---|
2130 | LogFlowFunc(("UTF-16 Unicode source (%u bytes):\n%ls\n\n", cbSrc, pvSrc));
|
---|
2131 | LogFlowFunc(("Byte Order Mark = %hx", ((PRTUTF16)pvSrc)[0]));
|
---|
2132 | LogFlowFunc(("UTF-8 Unicode dest (%u bytes):\n%s\n\n", cbDst, pvDst));
|
---|
2133 | }
|
---|
2134 | else
|
---|
2135 | LogRel(("Shared Clipboard: Converting UTF-16 Unicode failed with %Rrc\n", rc));
|
---|
2136 | }
|
---|
2137 | else /* Raw data. */
|
---|
2138 | {
|
---|
2139 | pvDst = RTMemAllocZ(cbSrc + 1 /* '\0' */);
|
---|
2140 | if(pvDst)
|
---|
2141 | {
|
---|
2142 | memcpy(pvDst, pvSrc, cbSrc);
|
---|
2143 | cbDst = cbSrc + 1 /* '\0' */;
|
---|
2144 | }
|
---|
2145 | else
|
---|
2146 | {
|
---|
2147 | rc = VERR_NO_MEMORY;
|
---|
2148 | break;
|
---|
2149 | }
|
---|
2150 | }
|
---|
2151 |
|
---|
2152 | rc = VINF_SUCCESS;
|
---|
2153 | break;
|
---|
2154 | }
|
---|
2155 |
|
---|
2156 | default:
|
---|
2157 | {
|
---|
2158 | rc = VERR_INVALID_PARAMETER;
|
---|
2159 | break;
|
---|
2160 | }
|
---|
2161 | }
|
---|
2162 | }
|
---|
2163 | # ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
|
---|
2164 | else if (pReq->uFmtVBox == VBOX_SHCL_FMT_URI_LIST)
|
---|
2165 | {
|
---|
2166 | /* In which format is the clipboard data? */
|
---|
2167 | switch (clipRealFormatForX11Format(pReq->idxFmtX11))
|
---|
2168 | {
|
---|
2169 | case SHCLX11FMT_URI_LIST:
|
---|
2170 | {
|
---|
2171 | /* For URI lists we only accept valid UTF-8 encodings. */
|
---|
2172 | if (RT_SUCCESS(RTStrValidateEncodingEx((char *)pvSrc, cbSrc, 0)))
|
---|
2173 | {
|
---|
2174 | /* URI lists on X are strings separated with "\r\n". */
|
---|
2175 | RTCList<RTCString> lstRootEntries = RTCString((char *)pvSrc, cbSrc).split("\r\n");
|
---|
2176 | for (size_t i = 0; i < lstRootEntries.size(); ++i)
|
---|
2177 | {
|
---|
2178 | char *pszEntry = RTUriFilePath(lstRootEntries.at(i).c_str());
|
---|
2179 | AssertPtrBreakStmt(pszEntry, VERR_INVALID_PARAMETER);
|
---|
2180 |
|
---|
2181 | rc = RTStrAAppend((char **)&pvDst, "http://localhost");
|
---|
2182 | AssertRCBreakStmt(rc, VERR_NO_MEMORY);
|
---|
2183 | cbDst += (uint32_t)strlen(pszEntry);
|
---|
2184 |
|
---|
2185 |
|
---|
2186 |
|
---|
2187 | /** @todo BUGBUG Fix port! */
|
---|
2188 | /** @todo Add port + UUID (virtual path). */
|
---|
2189 |
|
---|
2190 | rc = RTStrAAppend((char **)&pvDst, pszEntry);
|
---|
2191 | AssertRCBreakStmt(rc, VERR_NO_MEMORY);
|
---|
2192 | cbDst += (uint32_t)strlen(pszEntry);
|
---|
2193 |
|
---|
2194 | LogFlowFunc(("URI list entry '%s'\n", (char *)pvDst));
|
---|
2195 |
|
---|
2196 | rc = RTStrAAppend((char **)&pvDst, "\r\n");
|
---|
2197 | AssertRCBreakStmt(rc, VERR_NO_MEMORY);
|
---|
2198 | cbDst += (uint32_t)strlen("\r\n");
|
---|
2199 |
|
---|
2200 | RTStrFree(pszEntry);
|
---|
2201 | }
|
---|
2202 |
|
---|
2203 | if (cbDst)
|
---|
2204 | cbDst++; /* Include final (zero) termination. */
|
---|
2205 |
|
---|
2206 | LogFlowFunc(("URI list: cbDst=%RU32\n", cbDst));
|
---|
2207 | }
|
---|
2208 | else
|
---|
2209 | rc = VERR_INVALID_PARAMETER;
|
---|
2210 | break;
|
---|
2211 | }
|
---|
2212 |
|
---|
2213 | default:
|
---|
2214 | {
|
---|
2215 | rc = VERR_INVALID_PARAMETER;
|
---|
2216 | break;
|
---|
2217 | }
|
---|
2218 | }
|
---|
2219 | }
|
---|
2220 | # endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
|
---|
2221 | else
|
---|
2222 | rc = VERR_NOT_SUPPORTED;
|
---|
2223 |
|
---|
2224 | if (RT_FAILURE(rc))
|
---|
2225 | LogRel(("Shared Clipboard: Converting X11 format '%s' (idxFmtX11=%u) to VBox format %#x failed, rc=%Rrc\n",
|
---|
2226 | g_aFormats[pReq->idxFmtX11].pcszAtom, pReq->idxFmtX11, pReq->uFmtVBox, rc));
|
---|
2227 |
|
---|
2228 | SHCLX11READDATAREQ SendData;
|
---|
2229 | RT_ZERO(SendData);
|
---|
2230 | SendData.pReq = pReq->pReq;
|
---|
2231 | SendData.rcCompletion = rc;
|
---|
2232 |
|
---|
2233 | pCtx->Callbacks.pfnOnSendDataToDest(pReq->pCtx->pFrontend, pvDst, cbDst, &SendData);
|
---|
2234 |
|
---|
2235 | RTMemFree(pvDst);
|
---|
2236 | RTMemFree(pReq);
|
---|
2237 |
|
---|
2238 | LogFlowFuncLeaveRC(rc);
|
---|
2239 | }
|
---|
2240 |
|
---|
2241 | /**
|
---|
2242 | * Converts the data obtained from the X11 clipboard to the required format,
|
---|
2243 | * place it in the buffer supplied and signal that data has arrived.
|
---|
2244 | *
|
---|
2245 | * Converts the text obtained UTF-16LE with Windows EOLs.
|
---|
2246 | * Converts full BMP data to DIB format.
|
---|
2247 | */
|
---|
2248 | SHCL_X11_DECL(void) clipConvertDataFromX11(Widget widget, XtPointer pClient,
|
---|
2249 | Atom * /* selection */, Atom *atomType,
|
---|
2250 | XtPointer pvSrc, long unsigned int *pcLen,
|
---|
2251 | int *piFormat)
|
---|
2252 | {
|
---|
2253 | RT_NOREF(widget);
|
---|
2254 | if (*atomType == XT_CONVERT_FAIL) /* Xt timeout */
|
---|
2255 | clipConvertDataFromX11Worker(pClient, NULL, 0);
|
---|
2256 | else
|
---|
2257 | {
|
---|
2258 | CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *)pClient;
|
---|
2259 | if (pReq->pCtx->Callbacks.pfnOnClipboardRead)
|
---|
2260 | {
|
---|
2261 | void *pvData = NULL;
|
---|
2262 | size_t cbData = 0;
|
---|
2263 | int rc = pReq->pCtx->Callbacks.pfnOnClipboardRead(pReq->pCtx->pFrontend, pReq->uFmtVBox, &pvData, &cbData, NULL);
|
---|
2264 | if (RT_SUCCESS(rc))
|
---|
2265 | {
|
---|
2266 | /* Feed to conversion worker. */
|
---|
2267 | clipConvertDataFromX11Worker(pClient, pvData, cbData);
|
---|
2268 | RTMemFree(pvData);
|
---|
2269 | }
|
---|
2270 | else
|
---|
2271 | clipConvertDataFromX11Worker(pClient, NULL, 0);
|
---|
2272 | }
|
---|
2273 | else /* Call with current data provided by X (default). */
|
---|
2274 | clipConvertDataFromX11Worker(pClient, pvSrc, (*pcLen) * (*piFormat) / 8);
|
---|
2275 | }
|
---|
2276 |
|
---|
2277 | XtFree((char *)pvSrc);
|
---|
2278 | }
|
---|
2279 |
|
---|
2280 | static int clipGetSelectionValue(PSHCLX11CTX pCtx, SHCLX11FMTIDX idxFmt,
|
---|
2281 | CLIPREADX11CBREQ *pReq)
|
---|
2282 | {
|
---|
2283 | #ifndef TESTCASE
|
---|
2284 | XtGetSelectionValue(pCtx->pWidget, clipGetAtom(pCtx, "CLIPBOARD"),
|
---|
2285 | clipAtomForX11Format(pCtx, idxFmt),
|
---|
2286 | clipConvertDataFromX11,
|
---|
2287 | reinterpret_cast<XtPointer>(pReq),
|
---|
2288 | CurrentTime);
|
---|
2289 | #else
|
---|
2290 | tstClipRequestData(pCtx, idxFmt, (void *)pReq);
|
---|
2291 | #endif
|
---|
2292 |
|
---|
2293 | return VINF_SUCCESS; /** @todo Return real rc. */
|
---|
2294 | }
|
---|
2295 |
|
---|
2296 | /**
|
---|
2297 | * Worker function for ShClX11ReadDataFromX11 which runs on the event thread.
|
---|
2298 | *
|
---|
2299 | * @param pvUserData Pointer to a CLIPREADX11CBREQ structure containing
|
---|
2300 | * information about the clipboard read request.
|
---|
2301 | * Must be free'd by the worker.
|
---|
2302 | */
|
---|
2303 | static void ShClX11ReadDataFromX11Worker(void *pvUserData, void * /* interval */)
|
---|
2304 | {
|
---|
2305 | AssertPtrReturnVoid(pvUserData);
|
---|
2306 |
|
---|
2307 | CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *)pvUserData;
|
---|
2308 | SHCLX11CTX *pCtx = pReq->pCtx;
|
---|
2309 | AssertPtrReturnVoid(pCtx);
|
---|
2310 |
|
---|
2311 | LogFlowFunc(("pReq->uFmtVBox=%#x, idxFmtX11=%#x\n", pReq->uFmtVBox, pReq->idxFmtX11));
|
---|
2312 |
|
---|
2313 | int rc = VERR_NO_DATA; /* VBox thinks we have data and we don't. */
|
---|
2314 |
|
---|
2315 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
|
---|
2316 | const bool fXtBusy = clipGetXtBusy(pCtx);
|
---|
2317 | clipSetXtBusy(pCtx, true);
|
---|
2318 | if (fXtBusy)
|
---|
2319 | {
|
---|
2320 | /* If the clipboard is busy just fend off the request. */
|
---|
2321 | rc = VERR_TRY_AGAIN;
|
---|
2322 | }
|
---|
2323 | else
|
---|
2324 | #endif
|
---|
2325 | if (pReq->uFmtVBox & VBOX_SHCL_FMT_UNICODETEXT)
|
---|
2326 | {
|
---|
2327 | pReq->idxFmtX11 = pCtx->idxFmtText;
|
---|
2328 | if (pReq->idxFmtX11 != SHCLX11FMT_INVALID)
|
---|
2329 | {
|
---|
2330 | /* Send out a request for the data to the current clipboard owner. */
|
---|
2331 | rc = clipGetSelectionValue(pCtx, pCtx->idxFmtText, pReq);
|
---|
2332 | }
|
---|
2333 | }
|
---|
2334 | else if (pReq->uFmtVBox & VBOX_SHCL_FMT_BITMAP)
|
---|
2335 | {
|
---|
2336 | pReq->idxFmtX11 = pCtx->idxFmtBmp;
|
---|
2337 | if (pReq->idxFmtX11 != SHCLX11FMT_INVALID)
|
---|
2338 | {
|
---|
2339 | /* Send out a request for the data to the current clipboard owner. */
|
---|
2340 | rc = clipGetSelectionValue(pCtx, pCtx->idxFmtBmp, pReq);
|
---|
2341 | }
|
---|
2342 | }
|
---|
2343 | else if (pReq->uFmtVBox & VBOX_SHCL_FMT_HTML)
|
---|
2344 | {
|
---|
2345 | pReq->idxFmtX11 = pCtx->idxFmtHTML;
|
---|
2346 | if (pReq->idxFmtX11 != SHCLX11FMT_INVALID)
|
---|
2347 | {
|
---|
2348 | /* Send out a request for the data to the current clipboard owner. */
|
---|
2349 | rc = clipGetSelectionValue(pCtx, pCtx->idxFmtHTML, pReq);
|
---|
2350 | }
|
---|
2351 | }
|
---|
2352 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
|
---|
2353 | else if (pReq->uFmtVBox & VBOX_SHCL_FMT_URI_LIST)
|
---|
2354 | {
|
---|
2355 | pReq->idxFmtX11 = pCtx->idxFmtURI;
|
---|
2356 | if (pReq->idxFmtX11 != SHCLX11FMT_INVALID)
|
---|
2357 | {
|
---|
2358 | /* Send out a request for the data to the current clipboard owner. */
|
---|
2359 | rc = clipGetSelectionValue(pCtx, pCtx->idxFmtURI, pReq);
|
---|
2360 | }
|
---|
2361 | }
|
---|
2362 | #endif
|
---|
2363 | else
|
---|
2364 | {
|
---|
2365 | #ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY
|
---|
2366 | clipSetXtBusy(pCtx, false);
|
---|
2367 | #endif
|
---|
2368 | rc = VERR_NOT_IMPLEMENTED;
|
---|
2369 | }
|
---|
2370 |
|
---|
2371 | if (RT_FAILURE(rc))
|
---|
2372 | {
|
---|
2373 | /* The clipboard callback was never scheduled, so we must signal
|
---|
2374 | * that the request processing is finished and clean up ourselves. */
|
---|
2375 | SHCLX11READDATAREQ SendData;
|
---|
2376 | RT_ZERO(SendData);
|
---|
2377 | SendData.pReq = pReq->pReq;
|
---|
2378 | SendData.rcCompletion = rc;
|
---|
2379 |
|
---|
2380 | pCtx->Callbacks.pfnOnSendDataToDest(pReq->pCtx->pFrontend, NULL /* pv */ ,0 /* cb */, &SendData);
|
---|
2381 | RTMemFree(pReq);
|
---|
2382 | }
|
---|
2383 |
|
---|
2384 | LogFlowFuncLeaveRC(rc);
|
---|
2385 | }
|
---|
2386 |
|
---|
2387 | /**
|
---|
2388 | * Called when VBox wants to read the X11 clipboard.
|
---|
2389 | *
|
---|
2390 | * @returns VBox status code.
|
---|
2391 | * @retval VERR_NO_DATA if format is supported but no data is available currently.
|
---|
2392 | * @retval VERR_NOT_IMPLEMENTED if the format is not implemented.
|
---|
2393 | * @param pCtx Context data for the clipboard backend.
|
---|
2394 | * @param uFmt The format that the VBox would like to receive the data in.
|
---|
2395 | * @param pReq Read callback request to use. Will be free'd in the callback on success.
|
---|
2396 | * Otherwise the caller has to free this again on error.
|
---|
2397 | *
|
---|
2398 | * @note We allocate a request structure which must be freed by the worker.
|
---|
2399 | */
|
---|
2400 | int ShClX11ReadDataFromX11(PSHCLX11CTX pCtx, SHCLFORMAT uFmt, CLIPREADCBREQ *pReq)
|
---|
2401 | {
|
---|
2402 | AssertPtrReturn(pReq, VERR_INVALID_POINTER);
|
---|
2403 | /*
|
---|
2404 | * Immediately return if we are not connected to the X server.
|
---|
2405 | */
|
---|
2406 | if (!pCtx->fHaveX11)
|
---|
2407 | return VERR_NO_DATA;
|
---|
2408 |
|
---|
2409 | int rc = VINF_SUCCESS;
|
---|
2410 |
|
---|
2411 | CLIPREADX11CBREQ *pX11Req = (CLIPREADX11CBREQ *)RTMemAllocZ(sizeof(CLIPREADX11CBREQ));
|
---|
2412 | if (pX11Req)
|
---|
2413 | {
|
---|
2414 | pX11Req->pCtx = pCtx;
|
---|
2415 | pX11Req->uFmtVBox = uFmt;
|
---|
2416 | pX11Req->pReq = pReq;
|
---|
2417 |
|
---|
2418 | /* We use this to schedule a worker function on the event thread. */
|
---|
2419 | rc = clipThreadScheduleCall(pCtx, ShClX11ReadDataFromX11Worker, (XtPointer)pX11Req);
|
---|
2420 | if (RT_FAILURE(rc))
|
---|
2421 | RTMemFree(pX11Req);
|
---|
2422 | }
|
---|
2423 | else
|
---|
2424 | rc = VERR_NO_MEMORY;
|
---|
2425 |
|
---|
2426 | LogFlowFuncLeaveRC(rc);
|
---|
2427 | return rc;
|
---|
2428 | }
|
---|