VirtualBox

source: vbox/trunk/src/VBox/Additions/x11/VBoxClient/display.cpp@ 45221

Last change on this file since 45221 was 44967, checked in by vboxsync, 12 years ago

Additions/x11/VBoxClient: log string spacing.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 11.1 KB
Line 
1/* $Id: display.cpp 44967 2013-03-11 09:07:46Z vboxsync $ */
2/** @file
3 * X11 guest client - display management.
4 */
5
6/*
7 * Copyright (C) 2006-2012 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/** @todo this should probably be replaced by something IPRT */
19/* For system() and WEXITSTATUS() */
20#include <stdlib.h>
21#include <sys/types.h>
22#include <sys/wait.h>
23#include <errno.h>
24
25#include <X11/Xlib.h>
26#include <X11/cursorfont.h>
27#include <X11/extensions/Xrandr.h>
28
29#include <iprt/assert.h>
30#include <iprt/err.h>
31#include <iprt/file.h>
32#include <iprt/string.h>
33#include <iprt/thread.h>
34#include <VBox/log.h>
35#include <VBox/VMMDev.h>
36#include <VBox/VBoxGuestLib.h>
37
38#include "VBoxClient.h"
39
40static int initDisplay(Display *pDisplay)
41{
42 int rc = VINF_SUCCESS;
43 uint32_t fMouseFeatures = 0;
44
45 LogRelFlowFunc(("testing dynamic resizing\n"));
46 int iDummy;
47 if (!XRRQueryExtension(pDisplay, &iDummy, &iDummy))
48 rc = VERR_NOT_SUPPORTED;
49 if (RT_SUCCESS(rc))
50 rc = VbglR3CtlFilterMask(VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, 0);
51 else
52 VbglR3CtlFilterMask(0, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
53 /* Log and ignore the return value, as there is not much we can do with
54 * it. */
55 LogRelFlowFunc(("dynamic resizing: result %Rrc\n", rc));
56 /* Enable support for switching between hardware and software cursors */
57 LogRelFlowFunc(("enabling relative mouse re-capturing support\n"));
58 rc = VbglR3GetMouseStatus(&fMouseFeatures, NULL, NULL);
59 if (RT_SUCCESS(rc))
60 {
61 rc = VbglR3CtlFilterMask(VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED,
62 0);
63 if (RT_SUCCESS(rc))
64 rc = VbglR3SetMouseStatus
65 ( fMouseFeatures
66 & ~VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR);
67 }
68 if (RT_FAILURE(rc))
69 {
70 VbglR3CtlFilterMask(0, VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED);
71 VbglR3SetMouseStatus( fMouseFeatures
72 | VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR);
73 }
74 LogRelFlowFunc(("mouse re-capturing support: result %Rrc\n", rc));
75 return VINF_SUCCESS;
76}
77
78void cleanupDisplay(void)
79{
80 uint32_t fMouseFeatures = 0;
81 LogRelFlowFunc(("\n"));
82 VbglR3CtlFilterMask(0, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST
83 | VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED);
84 int rc = VbglR3GetMouseStatus(&fMouseFeatures, NULL, NULL);
85 if (RT_SUCCESS(rc))
86 VbglR3SetMouseStatus( fMouseFeatures
87 | VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR);
88 LogRelFlowFunc(("returning\n"));
89}
90
91/** This thread just runs a dummy X11 event loop to be sure that we get
92 * terminated should the X server exit. */
93static int x11ConnectionMonitor(RTTHREAD, void *)
94{
95 XEvent ev;
96 Display *pDisplay = XOpenDisplay(NULL);
97 while (true)
98 XNextEvent(pDisplay, &ev);
99 return 0;
100}
101
102/**
103 * This method first resets the current resolution using RandR to wake up
104 * the graphics driver, then sets the resolution requested if it is among
105 * those offered by the driver.
106 */
107static void setSize(Display *pDisplay, uint32_t cx, uint32_t cy)
108{
109 XRRScreenConfiguration *pConfig;
110 XRRScreenSize *pSizes;
111 int cSizes;
112 pConfig = XRRGetScreenInfo(pDisplay, DefaultRootWindow(pDisplay));
113 /* Reset the current mode */
114 LogRelFlowFunc(("Setting size %ux%u\n", cx, cy));
115 if (pConfig)
116 {
117 pSizes = XRRConfigSizes(pConfig, &cSizes);
118 unsigned uDist = UINT32_MAX;
119 int iMode = -1;
120 for (int i = 0; i < cSizes; ++i)
121 {
122#define VBCL_SQUARE(x) (x) * (x)
123 unsigned uThisDist = VBCL_SQUARE(pSizes[i].width - cx)
124 + VBCL_SQUARE(pSizes[i].height - cy);
125 LogRelFlowFunc(("Found size %dx%d, distance %u\n", pSizes[i].width,
126 pSizes[i].height, uThisDist));
127#undef VBCL_SQUARE
128 if (uThisDist < uDist)
129 {
130 uDist = uThisDist;
131 iMode = i;
132 }
133 }
134 if (iMode >= 0)
135 {
136 Time config_timestamp = 0;
137 XRRConfigTimes(pConfig, &config_timestamp);
138 LogRelFlowFunc(("Setting new size %d\n", iMode));
139 XRRSetScreenConfig(pDisplay, pConfig,
140 DefaultRootWindow(pDisplay), iMode,
141 RR_Rotate_0, config_timestamp);
142 }
143 XRRFreeScreenConfigInfo(pConfig);
144 }
145}
146
147/**
148 * Display change request monitor thread function.
149 * Before entering the loop, we re-read the last request
150 * received, and if the first one received inside the
151 * loop is identical we ignore it, because it is probably
152 * stale.
153 */
154static int runDisplay(Display *pDisplay)
155{
156 LogRelFlowFunc(("\n"));
157 Cursor hClockCursor = XCreateFontCursor(pDisplay, XC_watch);
158 Cursor hArrowCursor = XCreateFontCursor(pDisplay, XC_left_ptr);
159 int RRMaj, RRMin;
160 bool fExtDispReqSupport = true;
161 if (!XRRQueryVersion(pDisplay, &RRMaj, &RRMin))
162 RRMin = 0;
163 const char *pcszXrandr = "xrandr";
164 if (RTFileExists("/usr/X11/bin/xrandr"))
165 pcszXrandr = "/usr/X11/bin/xrandr";
166 int rc = RTThreadCreate(NULL, x11ConnectionMonitor, NULL, 0,
167 RTTHREADTYPE_INFREQUENT_POLLER, 0, "X11 monitor");
168 if (RT_FAILURE(rc))
169 return rc;
170 while (true)
171 {
172 uint32_t fEvents = 0, cx = 0, cy = 0, cBits = 0, iDisplay = 0, cxOrg = 0, cyOrg = 0;
173 bool fEnabled = false;
174 rc = VbglR3WaitEvent( VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST
175 | VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED,
176 RT_INDEFINITE_WAIT, &fEvents);
177 if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED) /* VERR_NO_MEMORY? */
178 return rc;
179 /* Jiggle the mouse pointer to wake up the driver. */
180 XGrabPointer(pDisplay,
181 DefaultRootWindow(pDisplay), true, 0, GrabModeAsync,
182 GrabModeAsync, None, hClockCursor, CurrentTime);
183 XFlush(pDisplay);
184 XGrabPointer(pDisplay,
185 DefaultRootWindow(pDisplay), true, 0, GrabModeAsync,
186 GrabModeAsync, None, hArrowCursor, CurrentTime);
187 XFlush(pDisplay);
188 XUngrabPointer(pDisplay, CurrentTime);
189 XFlush(pDisplay);
190 /* And if it is a size hint, set the new size now that the video
191 * driver has had a chance to update its list. */
192 if (RT_SUCCESS(rc) && (fEvents & VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST))
193 {
194 int rc2 = VbglR3GetDisplayChangeRequestEx(&cx, &cy, &cBits,
195 &iDisplay, &cxOrg, &cyOrg, &fEnabled, true);
196 /* Extended display version not supported on host */
197 if (RT_FAILURE(rc2))
198 {
199 LogRel(("GetDisplayChangeReq Extended Version not supported. "
200 "Trying for Normal Mode with cx=%d & cy=%d\n", cx, cy));
201 fExtDispReqSupport = false;
202 rc2 = VbglR3GetDisplayChangeRequest(&cx, &cy, &cBits, &iDisplay, true);
203 }
204 else
205 LogRelFlowFunc(("Got Extended Param from Host cx=%d, cy=%d, bpp=%d, iDisp=%d, "
206 "OrgX=%d, OrgY=%d Enb=%d\n", cx, cy, cBits, iDisplay,
207 cxOrg, cyOrg, fEnabled));
208 /* If we are not stopping, sleep for a bit to avoid using up
209 too much CPU while retrying. */
210 if (RT_FAILURE(rc2))
211 RTThreadYield();
212 else
213 if (RRMin < 2)
214 setSize(pDisplay, cx, cy);
215 else
216 {
217 char szCommand[256];
218 if (fExtDispReqSupport)
219 {
220 if (fEnabled)
221 {
222 if (cx != 0 && cy != 0)
223 {
224 RTStrPrintf(szCommand, sizeof(szCommand),
225 "%s --output VBOX%u --set VBOX_MODE %dx%d",
226 pcszXrandr, iDisplay, cx, cy);
227 system(szCommand);
228 }
229 /* Extended Display support possible . Secondary monitor position supported */
230 if (cxOrg != 0 || cyOrg != 0)
231 {
232 RTStrPrintf(szCommand, sizeof(szCommand),
233 "%s --output VBOX%u --auto --pos %dx%d",
234 pcszXrandr, iDisplay, cxOrg, cyOrg);
235 system(szCommand);
236 }
237 RTStrPrintf(szCommand, sizeof(szCommand),
238 "%s --output VBOX%u --preferred",
239 pcszXrandr, iDisplay);
240 system(szCommand);
241 }
242 else /* disable the virtual monitor */
243 {
244 RTStrPrintf(szCommand, sizeof(szCommand),
245 "%s --output VBOX%u --off",
246 pcszXrandr, iDisplay);
247 system(szCommand);
248 }
249 }
250 else /* Extended display support not possible */
251 {
252 if (cx != 0 && cy != 0)
253 {
254 RTStrPrintf(szCommand, sizeof(szCommand),
255 "%s --output VBOX%u --set VBOX_MODE %dx%d",
256 pcszXrandr, iDisplay, cx, cy);
257 system(szCommand);
258 RTStrPrintf(szCommand, sizeof(szCommand),
259 "%s --output VBOX%u --preferred",
260 pcszXrandr, iDisplay);
261 system(szCommand);
262 }
263 }
264
265 }
266 }
267 }
268 return VINF_SUCCESS;
269}
270
271class DisplayService : public VBoxClient::Service
272{
273public:
274 virtual const char *getPidFilePath()
275 {
276 return ".vboxclient-display.pid";
277 }
278 virtual int run(bool fDaemonised /* = false */)
279 {
280 Display *pDisplay = XOpenDisplay(NULL);
281 if (!pDisplay)
282 return VERR_NOT_FOUND;
283 int rc = initDisplay(pDisplay);
284 if (RT_SUCCESS(rc))
285 rc = runDisplay(pDisplay);
286 XCloseDisplay(pDisplay);
287 return rc;
288 }
289 virtual void cleanup()
290 {
291 cleanupDisplay();
292 }
293};
294
295VBoxClient::Service *VBoxClient::GetDisplayService()
296{
297 return new DisplayService;
298}
Note: See TracBrowser for help on using the repository browser.

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