VirtualBox

source: vbox/trunk/src/VBox/Additions/x11/VBoxClient/seamless-x11.cpp@ 57019

Last change on this file since 57019 was 55401, checked in by vboxsync, 10 years ago

added a couple of missing Id headers
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 15.7 KB
Line 
1/* $Id: seamless-x11.cpp 55401 2015-04-23 10:03:17Z vboxsync $ */
2/** @file
3 * X11 Seamless mode.
4 */
5
6/*
7 * Copyright (C) 2008-2011 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18/*****************************************************************************
19* Header files *
20*****************************************************************************/
21
22#include <iprt/err.h>
23#include <iprt/assert.h>
24#include <iprt/vector.h>
25#include <VBox/log.h>
26
27#include "seamless-x11.h"
28
29#include <X11/Xatom.h>
30#include <X11/Xmu/WinUtil.h>
31
32#include <limits.h>
33
34#ifdef TESTCASE
35#undef DefaultRootWindow
36#define DefaultRootWindow XDefaultRootWindow
37#endif
38
39/*****************************************************************************
40* Static functions *
41*****************************************************************************/
42
43static unsigned char *XXGetProperty (Display *aDpy, Window aWnd, Atom aPropType,
44 const char *aPropName, unsigned long *nItems)
45{
46 LogRelFlowFunc(("\n"));
47 Atom propNameAtom = XInternAtom (aDpy, aPropName,
48 True /* only_if_exists */);
49 if (propNameAtom == None)
50 {
51 return NULL;
52 }
53
54 Atom actTypeAtom = None;
55 int actFmt = 0;
56 unsigned long nBytesAfter = 0;
57 unsigned char *propVal = 0;
58 int rc = XGetWindowProperty (aDpy, aWnd, propNameAtom,
59 0, LONG_MAX, False /* delete */,
60 aPropType, &actTypeAtom, &actFmt,
61 nItems, &nBytesAfter, &propVal);
62 if (rc != Success)
63 return NULL;
64
65 LogRelFlowFunc(("returning\n"));
66 return propVal;
67}
68
69/**
70 * Initialise the guest and ensure that it is capable of handling seamless mode
71 *
72 * @returns true if it can handle seamless, false otherwise
73 */
74int SeamlessX11::init(PFNSENDREGIONUPDATE pHostCallback)
75{
76 int rc = VINF_SUCCESS;
77
78 LogRelFlowFunc(("\n"));
79 if (mHostCallback != NULL) /* Assertion */
80 {
81 LogRel(("VBoxClient: ERROR: attempt to initialise seamless guest object twice!\n"));
82 return VERR_INTERNAL_ERROR;
83 }
84 if (!(mDisplay = XOpenDisplay(NULL)))
85 {
86 LogRel(("VBoxClient: seamless guest object failed to acquire a connection to the display.\n"));
87 return VERR_ACCESS_DENIED;
88 }
89 mHostCallback = pHostCallback;
90 LogRelFlowFunc(("returning %Rrc\n", rc));
91 return rc;
92}
93
94/**
95 * Read information about currently visible windows in the guest and subscribe to X11
96 * events about changes to this information.
97 *
98 * @note This class does not contain its own event thread, so an external thread must
99 * call nextConfigurationEvent() for as long as events are wished.
100 * @todo This function should switch the guest to fullscreen mode.
101 */
102int SeamlessX11::start(void)
103{
104 int rc = VINF_SUCCESS;
105 /** Dummy values for XShapeQueryExtension */
106 int error, event;
107
108 LogRelFlowFunc(("\n"));
109 mSupportsShape = XShapeQueryExtension(mDisplay, &event, &error);
110 mEnabled = true;
111 monitorClientList();
112 rebuildWindowTree();
113 LogRelFlowFunc(("returning %Rrc\n", rc));
114 return rc;
115}
116
117/** Stop reporting seamless events to the host. Free information about guest windows
118 and stop requesting updates. */
119void SeamlessX11::stop(void)
120{
121 LogRelFlowFunc(("\n"));
122 mEnabled = false;
123 unmonitorClientList();
124 freeWindowTree();
125 LogRelFlowFunc(("returning\n"));
126}
127
128void SeamlessX11::monitorClientList(void)
129{
130 LogRelFlowFunc(("called\n"));
131 XSelectInput(mDisplay, DefaultRootWindow(mDisplay), SubstructureNotifyMask);
132}
133
134void SeamlessX11::unmonitorClientList(void)
135{
136 LogRelFlowFunc(("called\n"));
137 XSelectInput(mDisplay, DefaultRootWindow(mDisplay), 0);
138}
139
140/**
141 * Recreate the table of toplevel windows of clients on the default root window of the
142 * X server.
143 */
144void SeamlessX11::rebuildWindowTree(void)
145{
146 LogRelFlowFunc(("called\n"));
147 freeWindowTree();
148 addClients(DefaultRootWindow(mDisplay));
149 mChanged = true;
150}
151
152
153/**
154 * Look at the list of children of a virtual root window and add them to the list of clients
155 * if they belong to a client which is not a virtual root.
156 *
157 * @param hRoot the virtual root window to be examined
158 */
159void SeamlessX11::addClients(const Window hRoot)
160{
161 /** Unused out parameters of XQueryTree */
162 Window hRealRoot, hParent;
163 /** The list of children of the root supplied, raw pointer */
164 Window *phChildrenRaw = NULL;
165 /** The list of children of the root supplied, auto-pointer */
166 Window *phChildren;
167 /** The number of children of the root supplied */
168 unsigned cChildren;
169
170 LogRelFlowFunc(("\n"));
171 if (!XQueryTree(mDisplay, hRoot, &hRealRoot, &hParent, &phChildrenRaw, &cChildren))
172 return;
173 phChildren = phChildrenRaw;
174 for (unsigned i = 0; i < cChildren; ++i)
175 addClientWindow(phChildren[i]);
176 XFree(phChildrenRaw);
177 LogRelFlowFunc(("returning\n"));
178}
179
180
181void SeamlessX11::addClientWindow(const Window hWin)
182{
183 LogRelFlowFunc(("\n"));
184 XWindowAttributes winAttrib;
185 bool fAddWin = true;
186 Window hClient = XmuClientWindow(mDisplay, hWin);
187
188 if (isVirtualRoot(hClient))
189 fAddWin = false;
190 if (fAddWin && !XGetWindowAttributes(mDisplay, hWin, &winAttrib))
191 {
192 LogRelFunc(("VBoxClient: Failed to get the window attributes for window %d\n", hWin));
193 fAddWin = false;
194 }
195 if (fAddWin && (winAttrib.map_state == IsUnmapped))
196 fAddWin = false;
197 XSizeHints dummyHints;
198 long dummyLong;
199 if (fAddWin && (!XGetWMNormalHints(mDisplay, hClient, &dummyHints,
200 &dummyLong)))
201 {
202 LogRelFlowFunc(("window %lu, client window %lu has no size hints\n",
203 hWin, hClient));
204 fAddWin = false;
205 }
206 if (fAddWin)
207 {
208 XRectangle *pRects = NULL;
209 int cRects = 0, iOrdering;
210 bool hasShape = false;
211
212 LogRelFlowFunc(("adding window %lu, client window %lu\n", hWin,
213 hClient));
214 if (mSupportsShape)
215 {
216 XShapeSelectInput(mDisplay, hWin, ShapeNotifyMask);
217 pRects = XShapeGetRectangles(mDisplay, hWin, ShapeBounding, &cRects, &iOrdering);
218 if (!pRects)
219 cRects = 0;
220 else
221 {
222 if ( (cRects > 1)
223 || (pRects[0].x != 0)
224 || (pRects[0].y != 0)
225 || (pRects[0].width != winAttrib.width)
226 || (pRects[0].height != winAttrib.height)
227 )
228 hasShape = true;
229 }
230 }
231 mGuestWindows.addWindow(hWin, hasShape, winAttrib.x, winAttrib.y,
232 winAttrib.width, winAttrib.height, cRects,
233 pRects);
234 }
235 LogRelFlowFunc(("returning\n"));
236}
237
238
239/**
240 * Checks whether a window is a virtual root.
241 * @returns true if it is, false otherwise
242 * @param hWin the window to be examined
243 */
244bool SeamlessX11::isVirtualRoot(Window hWin)
245{
246 unsigned char *windowTypeRaw = NULL;
247 Atom *windowType;
248 unsigned long ulCount;
249 bool rc = false;
250
251 LogRelFlowFunc(("\n"));
252 windowTypeRaw = XXGetProperty(mDisplay, hWin, XA_ATOM, WM_TYPE_PROP, &ulCount);
253 if (windowTypeRaw != NULL)
254 {
255 windowType = (Atom *)(windowTypeRaw);
256 if ( (ulCount != 0)
257 && (*windowType == XInternAtom(mDisplay, WM_TYPE_DESKTOP_PROP, True)))
258 rc = true;
259 }
260 if (windowTypeRaw)
261 XFree(windowTypeRaw);
262 LogRelFlowFunc(("returning %RTbool\n", rc));
263 return rc;
264}
265
266DECLCALLBACK(int) VBoxGuestWinFree(VBoxGuestWinInfo *pInfo, void *pvParam)
267{
268 Display *pDisplay = (Display *)pvParam;
269
270 XShapeSelectInput(pDisplay, pInfo->Core.Key, 0);
271 delete pInfo;
272 return VINF_SUCCESS;
273}
274
275/**
276 * Free all information in the tree of visible windows
277 */
278void SeamlessX11::freeWindowTree(void)
279{
280 /* We use post-increment in the operation to prevent the iterator from being invalidated. */
281 LogRelFlowFunc(("\n"));
282 mGuestWindows.detachAll(VBoxGuestWinFree, mDisplay);
283 LogRelFlowFunc(("returning\n"));
284}
285
286
287/**
288 * Waits for a position or shape-related event from guest windows
289 *
290 * @note Called from the guest event thread.
291 */
292void SeamlessX11::nextConfigurationEvent(void)
293{
294 XEvent event;
295
296 LogRelFlowFunc(("\n"));
297 /* Start by sending information about the current window setup to the host. We do this
298 here because we want to send all such information from a single thread. */
299 if (mChanged)
300 {
301 updateRects();
302 mHostCallback(mpRects, mcRects);
303 }
304 mChanged = false;
305 XNextEvent(mDisplay, &event);
306 switch (event.type)
307 {
308 case ConfigureNotify:
309 {
310 XConfigureEvent *pConf = &event.xconfigure;
311 LogRelFlowFunc(("configure event, window=%lu, x=%i, y=%i, w=%i, h=%i, send_event=%RTbool\n",
312 (unsigned long) pConf->window, (int) pConf->x,
313 (int) pConf->y, (int) pConf->width,
314 (int) pConf->height, pConf->send_event));
315 }
316 doConfigureEvent(event.xconfigure.window);
317 break;
318 case MapNotify:
319 LogRelFlowFunc(("map event, window=%lu, send_event=%RTbool\n",
320 (unsigned long) event.xmap.window,
321 event.xmap.send_event));
322 doMapEvent(event.xmap.window);
323 break;
324 case VBoxShapeNotify: /* This is defined wrong in my X11 header files! */
325 LogRelFlowFunc(("shape event, window=%lu, send_event=%RTbool\n",
326 (unsigned long) event.xany.window,
327 event.xany.send_event));
328 /* the window member in xany is in the same place as in the shape event */
329 doShapeEvent(event.xany.window);
330 break;
331 case UnmapNotify:
332 LogRelFlowFunc(("unmap event, window=%lu, send_event=%RTbool\n",
333 (unsigned long) event.xunmap.window,
334 event.xunmap.send_event));
335 doUnmapEvent(event.xunmap.window);
336 break;
337 default:
338 break;
339 }
340 LogRelFlowFunc(("returning\n"));
341}
342
343/**
344 * Handle a configuration event in the seamless event thread by setting the new position.
345 *
346 * @param event the X11 event structure
347 */
348void SeamlessX11::doConfigureEvent(Window hWin)
349{
350 VBoxGuestWinInfo *pInfo = mGuestWindows.find(hWin);
351 if (pInfo)
352 {
353 XWindowAttributes winAttrib;
354
355 if (!XGetWindowAttributes(mDisplay, hWin, &winAttrib))
356 return;
357 pInfo->mX = winAttrib.x;
358 pInfo->mY = winAttrib.y;
359 pInfo->mWidth = winAttrib.width;
360 pInfo->mHeight = winAttrib.height;
361 if (pInfo->mhasShape)
362 {
363 XRectangle *pRects;
364 int cRects = 0, iOrdering;
365
366 pRects = XShapeGetRectangles(mDisplay, hWin, ShapeBounding,
367 &cRects, &iOrdering);
368 if (!pRects)
369 cRects = 0;
370 if (pInfo->mpRects)
371 XFree(pInfo->mpRects);
372 pInfo->mcRects = cRects;
373 pInfo->mpRects = pRects;
374 }
375 mChanged = true;
376 }
377}
378
379/**
380 * Handle a map event in the seamless event thread.
381 *
382 * @param event the X11 event structure
383 */
384void SeamlessX11::doMapEvent(Window hWin)
385{
386 LogRelFlowFunc(("\n"));
387 VBoxGuestWinInfo *pInfo = mGuestWindows.find(hWin);
388 if (!pInfo)
389 {
390 addClientWindow(hWin);
391 mChanged = true;
392 }
393 LogRelFlowFunc(("returning\n"));
394}
395
396
397/**
398 * Handle a window shape change event in the seamless event thread.
399 *
400 * @param event the X11 event structure
401 */
402void SeamlessX11::doShapeEvent(Window hWin)
403{
404 LogRelFlowFunc(("\n"));
405 VBoxGuestWinInfo *pInfo = mGuestWindows.find(hWin);
406 if (pInfo)
407 {
408 XRectangle *pRects;
409 int cRects = 0, iOrdering;
410
411 pRects = XShapeGetRectangles(mDisplay, hWin, ShapeBounding, &cRects,
412 &iOrdering);
413 if (!pRects)
414 cRects = 0;
415 pInfo->mhasShape = true;
416 if (pInfo->mpRects)
417 XFree(pInfo->mpRects);
418 pInfo->mcRects = cRects;
419 pInfo->mpRects = pRects;
420 mChanged = true;
421 }
422 LogRelFlowFunc(("returning\n"));
423}
424
425/**
426 * Handle an unmap event in the seamless event thread.
427 *
428 * @param event the X11 event structure
429 */
430void SeamlessX11::doUnmapEvent(Window hWin)
431{
432 LogRelFlowFunc(("\n"));
433 VBoxGuestWinInfo *pInfo = mGuestWindows.removeWindow(hWin);
434 if (pInfo)
435 {
436 VBoxGuestWinFree(pInfo, mDisplay);
437 mChanged = true;
438 }
439 LogRelFlowFunc(("returning\n"));
440}
441
442/**
443 * Gets the list of visible rectangles
444 */
445RTRECT *SeamlessX11::getRects(void)
446{
447 return mpRects;
448}
449
450/**
451 * Gets the number of rectangles in the visible rectangle list
452 */
453size_t SeamlessX11::getRectCount(void)
454{
455 return mcRects;
456}
457
458RTVEC_DECL(RectList, RTRECT)
459
460DECLCALLBACK(int) getRectsCallback(VBoxGuestWinInfo *pInfo,
461 struct RectList *pRects)
462{
463 if (pInfo->mhasShape)
464 {
465 for (int i = 0; i < pInfo->mcRects; ++i)
466 {
467 RTRECT *pRect;
468
469 pRect = RectListPushBack(pRects);
470 if (!pRect)
471 return VERR_NO_MEMORY;
472 pRect->xLeft = pInfo->mX
473 + pInfo->mpRects[i].x;
474 pRect->yBottom = pInfo->mY
475 + pInfo->mpRects[i].y
476 + pInfo->mpRects[i].height;
477 pRect->xRight = pInfo->mX
478 + pInfo->mpRects[i].x
479 + pInfo->mpRects[i].width;
480 pRect->yTop = pInfo->mY
481 + pInfo->mpRects[i].y;
482 }
483 }
484 else
485 {
486 RTRECT *pRect;
487
488 pRect = RectListPushBack(pRects);
489 if (!pRect)
490 return VERR_NO_MEMORY;
491 pRect->xLeft = pInfo->mX;
492 pRect->yBottom = pInfo->mY
493 + pInfo->mHeight;
494 pRect->xRight = pInfo->mX
495 + pInfo->mWidth;
496 pRect->yTop = pInfo->mY;
497 }
498 return VINF_SUCCESS;
499}
500
501/**
502 * Updates the list of seamless rectangles
503 */
504int SeamlessX11::updateRects(void)
505{
506 LogRelFlowFunc(("\n"));
507 unsigned cRects = 0;
508 struct RectList rects = RTVEC_INITIALIZER;
509
510 if (0 != mcRects)
511 {
512 int rc = RectListReserve(&rects, mcRects * 2);
513 if (RT_FAILURE(rc))
514 return rc;
515 }
516 mGuestWindows.doWithAll((PVBOXGUESTWINCALLBACK)getRectsCallback,
517 &rects);
518 if (mpRects)
519 RTMemFree(mpRects);
520 mcRects = RectListSize(&rects);
521 mpRects = RectListDetach(&rects);
522 LogRelFlowFunc(("returning\n"));
523 return VINF_SUCCESS;
524}
525
526/**
527 * Send a client event to wake up the X11 seamless event loop prior to stopping it.
528 *
529 * @note This function should only be called from the host event thread.
530 */
531bool SeamlessX11::interruptEventWait(void)
532{
533 bool rc = false;
534
535 LogRelFlowFunc(("\n"));
536 /* Message contents set to zero. */
537 XClientMessageEvent clientMessage = { ClientMessage, 0, 0, 0, 0, 0, 8 };
538
539 if (XSendEvent(mDisplay, DefaultRootWindow(mDisplay), false,
540 SubstructureNotifyMask, (XEvent *)&clientMessage))
541 {
542 XFlush(mDisplay);
543 rc = true;
544 }
545 LogRelFlowFunc(("returning %RTbool\n", rc));
546 return rc;
547}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette