VBoxSDL.cpp@ 47972

Last change on this file since 47972 was 46649, checked in by vboxsync, 11 years ago
Forward ported r85941 and required build fixes (Main: Implemented new event queue to separate system's native event queue and our own. Also, XPCOM is not needed for handling our own events. On Windows this also fixes the system's queue quota limitation).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 175.0 KB

Line
1	/** @file
2	* VBox frontends: VBoxSDL (simple frontend based on SDL):
3	* Main code
4	*/
5
6	/*
7	* Copyright (C) 2006-2013 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	#define LOG_GROUP LOG_GROUP_GUI
22
23	#include <VBox/com/com.h>
24	#include <VBox/com/string.h>
25	#include <VBox/com/Guid.h>
26	#include <VBox/com/array.h>
27	#include <VBox/com/ErrorInfo.h>
28	#include <VBox/com/errorprint.h>
29
30	#include <VBox/com/NativeEventQueue.h>
31	#include <VBox/com/VirtualBox.h>
32
33	using namespace com;
34
35	#if defined(VBOXSDL_WITH_X11)
36	# include <VBox/VBoxKeyboard.h>
37
38	# include <X11/Xlib.h>
39	# include <X11/cursorfont.h> /* for XC_left_ptr */
40	# if !defined(VBOX_WITHOUT_XCURSOR)
41	# include <X11/Xcursor/Xcursor.h>
42	# endif
43	# include <unistd.h>
44	#endif
45
46	#ifndef RT_OS_DARWIN
47	#include <SDL_syswm.h> /* for SDL_GetWMInfo() */
48	#endif
49
50	#include "VBoxSDL.h"
51	#include "Framebuffer.h"
52	#include "Helper.h"
53
54	#include <VBox/types.h>
55	#include <VBox/err.h>
56	#include <VBox/param.h>
57	#include <VBox/log.h>
58	#include <VBox/version.h>
59	#include <VBox/VBoxVideo.h>
60	#include <VBox/com/listeners.h>
61
62	#include <iprt/alloca.h>
63	#include <iprt/asm.h>
64	#include <iprt/assert.h>
65	#include <iprt/ctype.h>
66	#include <iprt/env.h>
67	#include <iprt/file.h>
68	#include <iprt/ldr.h>
69	#include <iprt/initterm.h>
70	#include <iprt/message.h>
71	#include <iprt/path.h>
72	#include <iprt/process.h>
73	#include <iprt/semaphore.h>
74	#include <iprt/string.h>
75	#include <iprt/stream.h>
76	#include <iprt/uuid.h>
77
78	#include <signal.h>
79
80	#include <vector>
81	#include <list>
82
83	/* Xlib would re-define our enums */
84	#undef True
85	#undef False
86
87	/*******************************************************************************
88	* Defined Constants And Macros *
89	*******************************************************************************/
90	#ifdef VBOX_SECURELABEL
91	/** extra data key for the secure label */
92	#define VBOXSDL_SECURELABEL_EXTRADATA "VBoxSDL/SecureLabel"
93	/** label area height in pixels */
94	#define SECURE_LABEL_HEIGHT 20
95	#endif
96
97	/** Enables the rawr[0\|3], patm, and casm options. */
98	#define VBOXSDL_ADVANCED_OPTIONS
99
100	/*******************************************************************************
101	* Structures and Typedefs *
102	*******************************************************************************/
103	/** Pointer shape change event data structure */
104	struct PointerShapeChangeData
105	{
106	PointerShapeChangeData(BOOL aVisible, BOOL aAlpha, ULONG aXHot, ULONG aYHot,
107	ULONG aWidth, ULONG aHeight, ComSafeArrayIn(BYTE,pShape))
108	: visible(aVisible), alpha(aAlpha), xHot(aXHot), yHot(aYHot),
109	width(aWidth), height(aHeight)
110	{
111	// make a copy of the shape
112	com::SafeArray<BYTE> aShape(ComSafeArrayInArg(pShape));
113	size_t cbShapeSize = aShape.size();
114	if (cbShapeSize > 0)
115	{
116	shape.resize(cbShapeSize);
117	::memcpy(shape.raw(), aShape.raw(), cbShapeSize);
118	}
119	}
120
121	~PointerShapeChangeData()
122	{
123	}
124
125	const BOOL visible;
126	const BOOL alpha;
127	const ULONG xHot;
128	const ULONG yHot;
129	const ULONG width;
130	const ULONG height;
131	com::SafeArray<BYTE> shape;
132	};
133
134	enum TitlebarMode
135	{
136	TITLEBAR_NORMAL = 1,
137	TITLEBAR_STARTUP = 2,
138	TITLEBAR_SAVE = 3,
139	TITLEBAR_SNAPSHOT = 4
140	};
141
142	/*******************************************************************************
143	* Internal Functions *
144	*******************************************************************************/
145	static bool UseAbsoluteMouse(void);
146	static void ResetKeys(void);
147	static void ProcessKey(SDL_KeyboardEvent *ev);
148	static void InputGrabStart(void);
149	static void InputGrabEnd(void);
150	static void SendMouseEvent(VBoxSDLFB *fb, int dz, int button, int down);
151	static void UpdateTitlebar(TitlebarMode mode, uint32_t u32User = 0);
152	static void SetPointerShape(const PointerShapeChangeData *data);
153	static void HandleGuestCapsChanged(void);
154	static int HandleHostKey(const SDL_KeyboardEvent *pEv);
155	static Uint32 StartupTimer(Uint32 interval, void *param);
156	static Uint32 ResizeTimer(Uint32 interval, void *param);
157	static Uint32 QuitTimer(Uint32 interval, void *param);
158	static int WaitSDLEvent(SDL_Event *event);
159	static void SetFullscreen(bool enable);
160	static RTEXITCODE readPasswordFile(const char pszFilename, com::Utf8Str pPasswd);
161	static RTEXITCODE settingsPasswordFile(ComPtr<IVirtualBox> virtualBox, const char *pszFilename);
162
163	#ifdef VBOX_WITH_SDL13
164	static VBoxSDLFB * getFbFromWinId(SDL_WindowID id);
165	#endif
166
167
168	/*******************************************************************************
169	* Global Variables *
170	*******************************************************************************/
171	static int gHostKeyMod = KMOD_RCTRL;
172	static int gHostKeySym1 = SDLK_RCTRL;
173	static int gHostKeySym2 = SDLK_UNKNOWN;
174	static const char *gHostKeyDisabledCombinations = "";
175	static const char *gpszPidFile;
176	static BOOL gfGrabbed = FALSE;
177	static BOOL gfGrabOnMouseClick = TRUE;
178	static BOOL gfFullscreenResize = FALSE;
179	static BOOL gfIgnoreNextResize = FALSE;
180	static BOOL gfAllowFullscreenToggle = TRUE;
181	static BOOL gfAbsoluteMouseHost = FALSE;
182	static BOOL gfAbsoluteMouseGuest = FALSE;
183	static BOOL gfRelativeMouseGuest = TRUE;
184	static BOOL gfGuestNeedsHostCursor = FALSE;
185	static BOOL gfOffCursorActive = FALSE;
186	static BOOL gfGuestNumLockPressed = FALSE;
187	static BOOL gfGuestCapsLockPressed = FALSE;
188	static BOOL gfGuestScrollLockPressed = FALSE;
189	static BOOL gfACPITerm = FALSE;
190	static BOOL gfXCursorEnabled = FALSE;
191	static int gcGuestNumLockAdaptions = 2;
192	static int gcGuestCapsLockAdaptions = 2;
193	static uint32_t gmGuestNormalXRes;
194	static uint32_t gmGuestNormalYRes;
195
196	/** modifier keypress status (scancode as index) */
197	static uint8_t gaModifiersState[256];
198
199	static ComPtr<IMachine> gpMachine;
200	static ComPtr<IConsole> gpConsole;
201	static ComPtr<IMachineDebugger> gpMachineDebugger;
202	static ComPtr<IKeyboard> gpKeyboard;
203	static ComPtr<IMouse> gpMouse;
204	static ComPtr<IDisplay> gpDisplay;
205	static ComPtr<IVRDEServer> gpVRDEServer;
206	static ComPtr<IProgress> gpProgress;
207
208	static ULONG gcMonitors = 1;
209	static VBoxSDLFB *gpFramebuffer[64];
210	static SDL_Cursor *gpDefaultCursor = NULL;
211	#ifdef VBOXSDL_WITH_X11
212	static Cursor gpDefaultOrigX11Cursor;
213	#endif
214	static SDL_Cursor *gpCustomCursor = NULL;
215	#ifndef VBOX_WITH_SDL13
216	static WMcursor *gpCustomOrigWMcursor = NULL;
217	#endif
218	static SDL_Cursor *gpOffCursor = NULL;
219	static SDL_TimerID gSdlResizeTimer = NULL;
220	static SDL_TimerID gSdlQuitTimer = NULL;
221
222	#if defined(VBOXSDL_WITH_X11) && !defined(VBOX_WITH_SDL13)
223	static SDL_SysWMinfo gSdlInfo;
224	#endif
225
226	#ifdef VBOX_SECURELABEL
227	#ifdef RT_OS_WINDOWS
228	#define LIBSDL_TTF_NAME "SDL_ttf"
229	#else
230	#define LIBSDL_TTF_NAME "libSDL_ttf-2.0.so.0"
231	#endif
232	RTLDRMOD gLibrarySDL_ttf = NIL_RTLDRMOD;
233	#endif
234
235	static RTSEMEVENT g_EventSemSDLEvents;
236	static volatile int32_t g_cNotifyUpdateEventsPending;
237
238	/**
239	* Event handler for VirtualBoxClient events
240	*/
241	class VBoxSDLClientEventListener
242	{
243	public:
244	VBoxSDLClientEventListener()
245	{
246	}
247
248	virtual ~VBoxSDLClientEventListener()
249	{
250	}
251
252	HRESULT init()
253	{
254	return S_OK;
255	}
256
257	void uninit()
258	{
259	}
260
261	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent * aEvent)
262	{
263	switch (aType)
264	{
265	case VBoxEventType_OnVBoxSVCAvailabilityChanged:
266	{
267	ComPtr<IVBoxSVCAvailabilityChangedEvent> pVSACEv = aEvent;
268	Assert(pVSACEv);
269	BOOL fAvailable = FALSE;
270	pVSACEv->COMGETTER(Available)(&fAvailable);
271	if (!fAvailable)
272	{
273	LogRel(("VBoxSDL: VBoxSVC became unavailable, exiting.\n"));
274	RTPrintf("VBoxSVC became unavailable, exiting.\n");
275	/* Send QUIT event to terminate the VM as cleanly as possible
276	* given that VBoxSVC is no longer present. */
277	SDL_Event event = {0};
278	event.type = SDL_QUIT;
279	PushSDLEventForSure(&event);
280	}
281	break;
282	}
283
284	default:
285	AssertFailed();
286	}
287
288	return S_OK;
289	}
290	};
291
292	/**
293	* Event handler for VirtualBox (server) events
294	*/
295	class VBoxSDLEventListener
296	{
297	public:
298	VBoxSDLEventListener()
299	{
300	}
301
302	virtual ~VBoxSDLEventListener()
303	{
304	}
305
306	HRESULT init()
307	{
308	return S_OK;
309	}
310
311	void uninit()
312	{
313	}
314
315	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent * aEvent)
316	{
317	switch (aType)
318	{
319	case VBoxEventType_OnExtraDataChanged:
320	{
321	#ifdef VBOX_SECURELABEL
322	ComPtr<IExtraDataChangedEvent> pEDCEv = aEvent;
323	Assert(pEDCEv);
324	Bstr bstrMachineId;
325	pEDCEv->COMGETTER(MachineId)(bstrMachineId.asOutParam());
326	if (gpMachine)
327	{
328	/*
329	* check if we're interested in the message
330	*/
331	Bstr bstrOurId;
332	gpMachine->COMGETTER(Id)(bstrOurId.asOutParam());
333	if (bstrOurId == bstrMachineId)
334	{
335	Bstr bstrKey;
336	pEDCEv->COMGETTER(Key)(bstrKey.asOutParam());
337	if (bstrKey == VBOXSDL_SECURELABEL_EXTRADATA)
338	{
339	/*
340	* Notify SDL thread of the string update
341	*/
342	SDL_Event event = {0};
343	event.type = SDL_USEREVENT;
344	event.user.type = SDL_USER_EVENT_SECURELABEL_UPDATE;
345	PushSDLEventForSure(&event);
346	}
347	}
348	}
349	#endif
350	break;
351	}
352
353	default:
354	AssertFailed();
355	}
356
357	return S_OK;
358	}
359	};
360
361	/**
362	* Event handler for Console events
363	*/
364	class VBoxSDLConsoleEventListener
365	{
366	public:
367	VBoxSDLConsoleEventListener() : m_fIgnorePowerOffEvents(false)
368	{
369	}
370
371	virtual ~VBoxSDLConsoleEventListener()
372	{
373	}
374
375	HRESULT init()
376	{
377	return S_OK;
378	}
379
380	void uninit()
381	{
382	}
383
384	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent * aEvent)
385	{
386	// likely all this double copy is now excessive, and we can just use existing event object
387	// @todo: eliminate it
388	switch (aType)
389	{
390	case VBoxEventType_OnMousePointerShapeChanged:
391	{
392	ComPtr<IMousePointerShapeChangedEvent> pMPSCEv = aEvent;
393	Assert(pMPSCEv);
394	PointerShapeChangeData *data;
395	BOOL visible, alpha;
396	ULONG xHot, yHot, width, height;
397	com::SafeArray<BYTE> shape;
398
399	pMPSCEv->COMGETTER(Visible)(&visible);
400	pMPSCEv->COMGETTER(Alpha)(&alpha);
401	pMPSCEv->COMGETTER(Xhot)(&xHot);
402	pMPSCEv->COMGETTER(Yhot)(&yHot);
403	pMPSCEv->COMGETTER(Width)(&width);
404	pMPSCEv->COMGETTER(Height)(&height);
405	pMPSCEv->COMGETTER(Shape)(ComSafeArrayAsOutParam(shape));
406	data = new PointerShapeChangeData(visible, alpha, xHot, yHot, width, height,
407	ComSafeArrayAsInParam(shape));
408	Assert(data);
409	if (!data)
410	break;
411
412	SDL_Event event = {0};
413	event.type = SDL_USEREVENT;
414	event.user.type = SDL_USER_EVENT_POINTER_CHANGE;
415	event.user.data1 = data;
416
417	int rc = PushSDLEventForSure(&event);
418	if (rc)
419	delete data;
420
421	break;
422	}
423	case VBoxEventType_OnMouseCapabilityChanged:
424	{
425	ComPtr<IMouseCapabilityChangedEvent> pMCCEv = aEvent;
426	Assert(pMCCEv);
427	pMCCEv->COMGETTER(SupportsAbsolute)(&gfAbsoluteMouseGuest);
428	pMCCEv->COMGETTER(SupportsRelative)(&gfRelativeMouseGuest);
429	pMCCEv->COMGETTER(NeedsHostCursor)(&gfGuestNeedsHostCursor);
430	SDL_Event event = {0};
431	event.type = SDL_USEREVENT;
432	event.user.type = SDL_USER_EVENT_GUEST_CAP_CHANGED;
433
434	PushSDLEventForSure(&event);
435	break;
436	}
437	case VBoxEventType_OnKeyboardLedsChanged:
438	{
439	ComPtr<IKeyboardLedsChangedEvent> pCLCEv = aEvent;
440	Assert(pCLCEv);
441	BOOL fNumLock, fCapsLock, fScrollLock;
442	pCLCEv->COMGETTER(NumLock)(&fNumLock);
443	pCLCEv->COMGETTER(CapsLock)(&fCapsLock);
444	pCLCEv->COMGETTER(ScrollLock)(&fScrollLock);
445	/* Don't bother the guest with NumLock scancodes if he doesn't set the NumLock LED */
446	if (gfGuestNumLockPressed != fNumLock)
447	gcGuestNumLockAdaptions = 2;
448	if (gfGuestCapsLockPressed != fCapsLock)
449	gcGuestCapsLockAdaptions = 2;
450	gfGuestNumLockPressed = fNumLock;
451	gfGuestCapsLockPressed = fCapsLock;
452	gfGuestScrollLockPressed = fScrollLock;
453	break;
454	}
455
456	case VBoxEventType_OnStateChanged:
457	{
458	ComPtr<IStateChangedEvent> pSCEv = aEvent;
459	Assert(pSCEv);
460	MachineState_T machineState;
461	pSCEv->COMGETTER(State)(&machineState);
462	LogFlow(("OnStateChange: machineState = %d (%s)\n", machineState, GetStateName(machineState)));
463	SDL_Event event = {0};
464
465	if ( machineState == MachineState_Aborted
466	\|\| machineState == MachineState_Teleported
467	\|\| (machineState == MachineState_Saved && !m_fIgnorePowerOffEvents)
468	\|\| (machineState == MachineState_PoweredOff && !m_fIgnorePowerOffEvents)
469	)
470	{
471	/*
472	* We have to inform the SDL thread that the application has be terminated
473	*/
474	event.type = SDL_USEREVENT;
475	event.user.type = SDL_USER_EVENT_TERMINATE;
476	event.user.code = machineState == MachineState_Aborted
477	? VBOXSDL_TERM_ABEND
478	: VBOXSDL_TERM_NORMAL;
479	}
480	else
481	{
482	/*
483	* Inform the SDL thread to refresh the titlebar
484	*/
485	event.type = SDL_USEREVENT;
486	event.user.type = SDL_USER_EVENT_UPDATE_TITLEBAR;
487	}
488
489	PushSDLEventForSure(&event);
490	break;
491	}
492
493	case VBoxEventType_OnRuntimeError:
494	{
495	ComPtr<IRuntimeErrorEvent> pRTEEv = aEvent;
496	Assert(pRTEEv);
497	BOOL fFatal;
498
499	pRTEEv->COMGETTER(Fatal)(&fFatal);
500	MachineState_T machineState;
501	gpMachine->COMGETTER(State)(&machineState);
502	const char *pszType;
503	bool fPaused = machineState == MachineState_Paused;
504	if (fFatal)
505	pszType = "FATAL ERROR";
506	else if (machineState == MachineState_Paused)
507	pszType = "Non-fatal ERROR";
508	else
509	pszType = "WARNING";
510	Bstr bstrId, bstrMessage;
511	pRTEEv->COMGETTER(Id)(bstrId.asOutParam());
512	pRTEEv->COMGETTER(Message)(bstrMessage.asOutParam());
513	RTPrintf("\n%s: %ls \n%ls\n%s\n", pszType, bstrId.raw(), bstrMessage.raw(),
514	fPaused ? "The VM was paused. Continue with HostKey + P after you solved the problem.\n" : "");
515	break;
516	}
517
518	case VBoxEventType_OnCanShowWindow:
519	{
520	ComPtr<ICanShowWindowEvent> pCSWEv = aEvent;
521	Assert(pCSWEv);
522	#ifdef RT_OS_DARWIN
523	/* SDL feature not available on Quartz */
524	#else
525	SDL_SysWMinfo info;
526	SDL_VERSION(&info.version);
527	if (!SDL_GetWMInfo(&info))
528	pCSWEv->AddVeto(NULL);
529	#endif
530	break;
531	}
532
533	case VBoxEventType_OnShowWindow:
534	{
535	ComPtr<IShowWindowEvent> pSWEv = aEvent;
536	Assert(pSWEv);
537	#ifndef RT_OS_DARWIN
538	SDL_SysWMinfo info;
539	SDL_VERSION(&info.version);
540	if (SDL_GetWMInfo(&info))
541	{
542	#if defined(VBOXSDL_WITH_X11)
543	pSWEv->COMSETTER(WinId)((LONG64)info.info.x11.wmwindow);
544	#elif defined(RT_OS_WINDOWS)
545	pSWEv->COMSETTER(WinId)((LONG64)info.window);
546	#else
547	AssertFailed();
548	#endif
549	}
550	#endif /* !RT_OS_DARWIN */
551	break;
552	}
553
554	default:
555	AssertFailed();
556	}
557	return S_OK;
558	}
559
560	static const char *GetStateName(MachineState_T machineState)
561	{
562	switch (machineState)
563	{
564	case MachineState_Null: return "<null>";
565	case MachineState_PoweredOff: return "PoweredOff";
566	case MachineState_Saved: return "Saved";
567	case MachineState_Teleported: return "Teleported";
568	case MachineState_Aborted: return "Aborted";
569	case MachineState_Running: return "Running";
570	case MachineState_Teleporting: return "Teleporting";
571	case MachineState_LiveSnapshotting: return "LiveSnapshotting";
572	case MachineState_Paused: return "Paused";
573	case MachineState_Stuck: return "GuruMeditation";
574	case MachineState_Starting: return "Starting";
575	case MachineState_Stopping: return "Stopping";
576	case MachineState_Saving: return "Saving";
577	case MachineState_Restoring: return "Restoring";
578	case MachineState_TeleportingPausedVM: return "TeleportingPausedVM";
579	case MachineState_TeleportingIn: return "TeleportingIn";
580	case MachineState_RestoringSnapshot: return "RestoringSnapshot";
581	case MachineState_DeletingSnapshot: return "DeletingSnapshot";
582	case MachineState_SettingUp: return "SettingUp";
583	default: return "no idea";
584	}
585	}
586
587	void ignorePowerOffEvents(bool fIgnore)
588	{
589	m_fIgnorePowerOffEvents = fIgnore;
590	}
591
592	private:
593	bool m_fIgnorePowerOffEvents;
594	};
595
596	typedef ListenerImpl<VBoxSDLClientEventListener> VBoxSDLClientEventListenerImpl;
597	typedef ListenerImpl<VBoxSDLEventListener> VBoxSDLEventListenerImpl;
598	typedef ListenerImpl<VBoxSDLConsoleEventListener> VBoxSDLConsoleEventListenerImpl;
599
600	static void show_usage()
601	{
602	RTPrintf("Usage:\n"
603	" --startvm <uuid\|name> Virtual machine to start, either UUID or name\n"
604	" --hda <file> Set temporary first hard disk to file\n"
605	" --fda <file> Set temporary first floppy disk to file\n"
606	" --cdrom <file> Set temporary CDROM/DVD to file/device ('none' to unmount)\n"
607	" --boot <a\|c\|d\|n> Set temporary boot device (a = floppy, c = 1st HD, d = DVD, n = network)\n"
608	" --memory <size> Set temporary memory size in megabytes\n"
609	" --vram <size> Set temporary size of video memory in megabytes\n"
610	" --fullscreen Start VM in fullscreen mode\n"
611	" --fullscreenresize Resize the guest on fullscreen\n"
612	" --fixedmode <w> <h> <bpp> Use a fixed SDL video mode with given width, height and bits per pixel\n"
613	" --nofstoggle Forbid switching to/from fullscreen mode\n"
614	" --noresize Make the SDL frame non resizable\n"
615	" --nohostkey Disable all hostkey combinations\n"
616	" --nohostkeys ... Disable specific hostkey combinations, see below for valid keys\n"
617	" --nograbonclick Disable mouse/keyboard grabbing on mouse click w/o additions\n"
618	" --detecthostkey Get the hostkey identifier and modifier state\n"
619	" --hostkey <key> {<key2>} <mod> Set the host key to the values obtained using --detecthostkey\n"
620	" --termacpi Send an ACPI power button event when closing the window\n"
621	" --vrdp <ports> Listen for VRDP connections on one of specified ports (default if not specified)\n"
622	" --discardstate Discard saved state (if present) and revert to last snapshot (if present)\n"
623	" --settingspw <pw> Specify the settings password\n"
624	" --settingspwfile <file> Specify a file containing the settings password\n"
625	#ifdef VBOX_SECURELABEL
626	" --securelabel Display a secure VM label at the top of the screen\n"
627	" --seclabelfnt TrueType (.ttf) font file for secure session label\n"
628	" --seclabelsiz Font point size for secure session label (default 12)\n"
629	" --seclabelofs Font offset within the secure label (default 0)\n"
630	" --seclabelfgcol <rgb> Secure label text color RGB value in 6 digit hexadecimal (eg: FFFF00)\n"
631	" --seclabelbgcol <rgb> Secure label background color RGB value in 6 digit hexadecimal (eg: FF0000)\n"
632	#endif
633	#ifdef VBOXSDL_ADVANCED_OPTIONS
634	" --[no]rawr0 Enable or disable raw ring 3\n"
635	" --[no]rawr3 Enable or disable raw ring 0\n"
636	" --[no]patm Enable or disable PATM\n"
637	" --[no]csam Enable or disable CSAM\n"
638	" --[no]hwvirtex Permit or deny the usage of VT-x/AMD-V\n"
639	#endif
640	"\n"
641	"Key bindings:\n"
642	" <hostkey> + f Switch to full screen / restore to previous view\n"
643	" h Press ACPI power button\n"
644	" n Take a snapshot and continue execution\n"
645	" p Pause / resume execution\n"
646	" q Power off\n"
647	" r VM reset\n"
648	" s Save state and power off\n"
649	" <del> Send <ctrl><alt><del>\n"
650	" <F1>...<F12> Send <ctrl><alt><Fx>\n"
651	#if defined(DEBUG) \|\| defined(VBOX_WITH_STATISTICS)
652	"\n"
653	"Further key bindings useful for debugging:\n"
654	" LCtrl + Alt + F12 Reset statistics counter\n"
655	" LCtrl + Alt + F11 Dump statistics to logfile\n"
656	" Alt + F12 Toggle R0 recompiler\n"
657	" Alt + F11 Toggle R3 recompiler\n"
658	" Alt + F10 Toggle PATM\n"
659	" Alt + F9 Toggle CSAM\n"
660	" Alt + F8 Toggle single step mode\n"
661	" LCtrl/RCtrl + F12 Toggle logger\n"
662	" F12 Write log marker to logfile\n"
663	#endif
664	"\n");
665	}
666
667	static void PrintError(const char *pszName, CBSTR pwszDescr, CBSTR pwszComponent=NULL)
668	{
669	const char pszFile, pszFunc, *pszStat;
670	char pszBuffer[1024];
671	com::ErrorInfo info;
672
673	RTStrPrintf(pszBuffer, sizeof(pszBuffer), "%ls", pwszDescr);
674
675	RTPrintf("\n%s! Error info:\n", pszName);
676	if ( (pszFile = strstr(pszBuffer, "At '"))
677	&& (pszFunc = strstr(pszBuffer, ") in "))
678	&& (pszStat = strstr(pszBuffer, "VBox status code: ")))
679	RTPrintf(" %.s %.s\n In%.*s %s",
680	pszFile-pszBuffer, pszBuffer,
681	pszFunc-pszFile+1, pszFile,
682	pszStat-pszFunc-4, pszFunc+4,
683	pszStat);
684	else
685	RTPrintf("%s\n", pszBuffer);
686
687	if (pwszComponent)
688	RTPrintf("(component %ls).\n", pwszComponent);
689
690	RTPrintf("\n");
691	}
692
693	#ifdef VBOXSDL_WITH_X11
694	/**
695	* Custom signal handler. Currently it is only used to release modifier
696	* keys when receiving the USR1 signal. When switching VTs, we might not
697	* get release events for Ctrl-Alt and in case a savestate is performed
698	* on the new VT, the VM will be saved with modifier keys stuck. This is
699	* annoying enough for introducing this hack.
700	*/
701	void signal_handler_SIGUSR1(int sig, siginfo_t info, void secret)
702	{
703	/* only SIGUSR1 is interesting */
704	if (sig == SIGUSR1)
705	{
706	/* just release the modifiers */
707	ResetKeys();
708	}
709	}
710
711	/**
712	* Custom signal handler for catching exit events.
713	*/
714	void signal_handler_SIGINT(int sig)
715	{
716	if (gpszPidFile)
717	RTFileDelete(gpszPidFile);
718	signal(SIGINT, SIG_DFL);
719	signal(SIGQUIT, SIG_DFL);
720	signal(SIGSEGV, SIG_DFL);
721	kill(getpid(), sig);
722	}
723	#endif /* VBOXSDL_WITH_X11 */
724
725
726	#ifdef RT_OS_WINDOWS
727	// Required for ATL
728	static CComModule _Module;
729	#endif
730
731	/** entry point */
732	extern "C"
733	DECLEXPORT(int) TrustedMain(int argc, char argv, char envp)
734	{
735	#ifdef VBOXSDL_WITH_X11
736	/*
737	* Lock keys on SDL behave different from normal keys: A KeyPress event is generated
738	* if the lock mode gets active and a keyRelease event is generated if the lock mode
739	* gets inactive, that is KeyPress and KeyRelease are sent when pressing the lock key
740	* to change the mode. The current lock mode is reflected in SDL_GetModState().
741	*
742	* Debian patched libSDL to make the lock keys behave like normal keys generating a
743	* KeyPress/KeyRelease event if the lock key was pressed/released. But the lock status
744	* is not reflected in the mod status anymore. We disable the Debian-specific extension
745	* to ensure a defined environment and work around the missing KeyPress/KeyRelease
746	* events in ProcessKeys().
747	*/
748	RTEnvSet("SDL_DISABLE_LOCK_KEYS", "1");
749	#endif
750
751	/*
752	* the hostkey detection mode is unrelated to VM processing, so handle it before
753	* we initialize anything COM related
754	*/
755	if (argc == 2 && ( !strcmp(argv[1], "-detecthostkey")
756	\|\| !strcmp(argv[1], "--detecthostkey")))
757	{
758	int rc = SDL_InitSubSystem(SDL_INIT_VIDEO \| SDL_INIT_TIMER \| SDL_INIT_NOPARACHUTE);
759	if (rc != 0)
760	{
761	RTPrintf("Error: SDL_InitSubSystem failed with message '%s'\n", SDL_GetError());
762	return 1;
763	}
764	/* we need a video window for the keyboard stuff to work */
765	if (!SDL_SetVideoMode(640, 480, 16, SDL_SWSURFACE))
766	{
767	RTPrintf("Error: could not set SDL video mode\n");
768	return 1;
769	}
770
771	RTPrintf("Please hit one or two function key(s) to get the --hostkey value...\n");
772
773	SDL_Event event1;
774	while (SDL_WaitEvent(&event1))
775	{
776	if (event1.type == SDL_KEYDOWN)
777	{
778	SDL_Event event2;
779	unsigned mod = SDL_GetModState() & ~(KMOD_MODE \| KMOD_NUM \| KMOD_RESERVED);
780	while (SDL_WaitEvent(&event2))
781	{
782	if (event2.type == SDL_KEYDOWN \|\| event2.type == SDL_KEYUP)
783	{
784	/* pressed additional host key */
785	RTPrintf("--hostkey %d", event1.key.keysym.sym);
786	if (event2.type == SDL_KEYDOWN)
787	{
788	RTPrintf(" %d", event2.key.keysym.sym);
789	RTPrintf(" %d\n", SDL_GetModState() & ~(KMOD_MODE \| KMOD_NUM \| KMOD_RESERVED));
790	}
791	else
792	{
793	RTPrintf(" %d\n", mod);
794	}
795	/* we're done */
796	break;
797	}
798	}
799	/* we're down */
800	break;
801	}
802	}
803	SDL_Quit();
804	return 1;
805	}
806
807	HRESULT rc;
808	int vrc;
809	Guid uuidVM;
810	char *vmName = NULL;
811	DeviceType_T bootDevice = DeviceType_Null;
812	uint32_t memorySize = 0;
813	uint32_t vramSize = 0;
814	ComPtr<IEventListener> pVBoxClientListener;
815	ComPtr<IEventListener> pVBoxListener;
816	ComObjPtr<VBoxSDLConsoleEventListenerImpl> pConsoleListener;
817
818	bool fFullscreen = false;
819	bool fResizable = true;
820	#ifdef USE_XPCOM_QUEUE_THREAD
821	bool fXPCOMEventThreadSignaled = false;
822	#endif
823	const char *pcszHdaFile = NULL;
824	const char *pcszCdromFile = NULL;
825	const char *pcszFdaFile = NULL;
826	const char *pszPortVRDP = NULL;
827	bool fDiscardState = false;
828	const char *pcszSettingsPw = NULL;
829	const char *pcszSettingsPwFile = NULL;
830	#ifdef VBOX_SECURELABEL
831	BOOL fSecureLabel = false;
832	uint32_t secureLabelPointSize = 12;
833	uint32_t secureLabelFontOffs = 0;
834	char *secureLabelFontFile = NULL;
835	uint32_t secureLabelColorFG = 0x0000FF00;
836	uint32_t secureLabelColorBG = 0x00FFFF00;
837	#endif
838	#ifdef VBOXSDL_ADVANCED_OPTIONS
839	unsigned fRawR0 = ~0U;
840	unsigned fRawR3 = ~0U;
841	unsigned fPATM = ~0U;
842	unsigned fCSAM = ~0U;
843	unsigned fHWVirt = ~0U;
844	uint32_t u32WarpDrive = 0;
845	#endif
846	#ifdef VBOX_WIN32_UI
847	bool fWin32UI = true;
848	int64_t winId = 0;
849	#endif
850	bool fShowSDLConfig = false;
851	uint32_t fixedWidth = ~(uint32_t)0;
852	uint32_t fixedHeight = ~(uint32_t)0;
853	uint32_t fixedBPP = ~(uint32_t)0;
854	uint32_t uResizeWidth = ~(uint32_t)0;
855	uint32_t uResizeHeight = ~(uint32_t)0;
856
857	/* The damned GOTOs forces this to be up here - totally out of place. */
858	/*
859	* Host key handling.
860	*
861	* The golden rule is that host-key combinations should not be seen
862	* by the guest. For instance a CAD should not have any extra RCtrl down
863	* and RCtrl up around itself. Nor should a resume be followed by a Ctrl-P
864	* that could encourage applications to start printing.
865	*
866	* We must not confuse the hostkey processing into any release sequences
867	* either, the host key is supposed to be explicitly pressing one key.
868	*
869	* Quick state diagram:
870	*
871	* host key down alone
872	* (Normal) ---------------
873	* ^ ^ \|
874	* \| \| v host combination key down
875	* \| \| (Host key down) ----------------
876	* \| \| host key up v \| \|
877	* \| \|-------------- \| other key down v host combination key down
878	* \| \| (host key used) -------------
879	* \| \| \| ^ \|
880	* \| (not host key)-- \| \|---------------
881	* \| \| \| \| \|
882	* \| \| ---- other \|
883	* \| modifiers = 0 v v
884	* -----------------------------------------------
885	*/
886	enum HKEYSTATE
887	{
888	/** The initial and most common state, pass keystrokes to the guest.
889	* Next state: HKEYSTATE_DOWN
890	* Prev state: Any */
891	HKEYSTATE_NORMAL = 1,
892	/** The first host key was pressed down
893	*/
894	HKEYSTATE_DOWN_1ST,
895	/** The second host key was pressed down (if gHostKeySym2 != SDLK_UNKNOWN)
896	*/
897	HKEYSTATE_DOWN_2ND,
898	/** The host key has been pressed down.
899	* Prev state: HKEYSTATE_NORMAL
900	* Next state: HKEYSTATE_NORMAL - host key up, capture toggle.
901	* Next state: HKEYSTATE_USED - host key combination down.
902	* Next state: HKEYSTATE_NOT_IT - non-host key combination down.
903	*/
904	HKEYSTATE_DOWN,
905	/** A host key combination was pressed.
906	* Prev state: HKEYSTATE_DOWN
907	* Next state: HKEYSTATE_NORMAL - when modifiers are all 0
908	*/
909	HKEYSTATE_USED,
910	/** A non-host key combination was attempted. Send hostkey down to the
911	* guest and continue until all modifiers have been released.
912	* Prev state: HKEYSTATE_DOWN
913	* Next state: HKEYSTATE_NORMAL - when modifiers are all 0
914	*/
915	HKEYSTATE_NOT_IT
916	} enmHKeyState = HKEYSTATE_NORMAL;
917	/** The host key down event which we have been hiding from the guest.
918	* Used when going from HKEYSTATE_DOWN to HKEYSTATE_NOT_IT. */
919	SDL_Event EvHKeyDown1;
920	SDL_Event EvHKeyDown2;
921
922	LogFlow(("SDL GUI started\n"));
923	RTPrintf(VBOX_PRODUCT " SDL GUI version %s\n"
924	"(C) 2005-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
925	"All rights reserved.\n\n",
926	VBOX_VERSION_STRING);
927
928	// less than one parameter is not possible
929	if (argc < 2)
930	{
931	show_usage();
932	return 1;
933	}
934
935	// command line argument parsing stuff
936	for (int curArg = 1; curArg < argc; curArg++)
937	{
938	if ( !strcmp(argv[curArg], "--vm")
939	\|\| !strcmp(argv[curArg], "-vm")
940	\|\| !strcmp(argv[curArg], "--startvm")
941	\|\| !strcmp(argv[curArg], "-startvm")
942	\|\| !strcmp(argv[curArg], "-s")
943	)
944	{
945	if (++curArg >= argc)
946	{
947	RTPrintf("Error: VM not specified (UUID or name)!\n");
948	return 1;
949	}
950	// first check if a UUID was supplied
951	uuidVM = argv[curArg];
952
953	if (!uuidVM.isValid())
954	{
955	LogFlow(("invalid UUID format, assuming it's a VM name\n"));
956	vmName = argv[curArg];
957	}
958	else if (uuidVM.isZero())
959	{
960	RTPrintf("Error: UUID argument is zero!\n");
961	return 1;
962	}
963	}
964	else if ( !strcmp(argv[curArg], "--comment")
965	\|\| !strcmp(argv[curArg], "-comment"))
966	{
967	if (++curArg >= argc)
968	{
969	RTPrintf("Error: missing argument for comment!\n");
970	return 1;
971	}
972	}
973	else if ( !strcmp(argv[curArg], "--boot")
974	\|\| !strcmp(argv[curArg], "-boot"))
975	{
976	if (++curArg >= argc)
977	{
978	RTPrintf("Error: missing argument for boot drive!\n");
979	return 1;
980	}
981	switch (argv[curArg][0])
982	{
983	case 'a':
984	{
985	bootDevice = DeviceType_Floppy;
986	break;
987	}
988
989	case 'c':
990	{
991	bootDevice = DeviceType_HardDisk;
992	break;
993	}
994
995	case 'd':
996	{
997	bootDevice = DeviceType_DVD;
998	break;
999	}
1000
1001	case 'n':
1002	{
1003	bootDevice = DeviceType_Network;
1004	break;
1005	}
1006
1007	default:
1008	{
1009	RTPrintf("Error: wrong argument for boot drive!\n");
1010	return 1;
1011	}
1012	}
1013	}
1014	else if ( !strcmp(argv[curArg], "--detecthostkey")
1015	\|\| !strcmp(argv[curArg], "-detecthostkey"))
1016	{
1017	RTPrintf("Error: please specify \"%s\" without any additional parameters!\n",
1018	argv[curArg]);
1019	return 1;
1020	}
1021	else if ( !strcmp(argv[curArg], "--memory")
1022	\|\| !strcmp(argv[curArg], "-memory")
1023	\|\| !strcmp(argv[curArg], "-m"))
1024	{
1025	if (++curArg >= argc)
1026	{
1027	RTPrintf("Error: missing argument for memory size!\n");
1028	return 1;
1029	}
1030	memorySize = atoi(argv[curArg]);
1031	}
1032	else if ( !strcmp(argv[curArg], "--vram")
1033	\|\| !strcmp(argv[curArg], "-vram"))
1034	{
1035	if (++curArg >= argc)
1036	{
1037	RTPrintf("Error: missing argument for vram size!\n");
1038	return 1;
1039	}
1040	vramSize = atoi(argv[curArg]);
1041	}
1042	else if ( !strcmp(argv[curArg], "--fullscreen")
1043	\|\| !strcmp(argv[curArg], "-fullscreen"))
1044	{
1045	fFullscreen = true;
1046	}
1047	else if ( !strcmp(argv[curArg], "--fullscreenresize")
1048	\|\| !strcmp(argv[curArg], "-fullscreenresize"))
1049	{
1050	gfFullscreenResize = true;
1051	#ifdef VBOXSDL_WITH_X11
1052	RTEnvSet("SDL_VIDEO_X11_VIDMODE", "0");
1053	#endif
1054	}
1055	else if ( !strcmp(argv[curArg], "--fixedmode")
1056	\|\| !strcmp(argv[curArg], "-fixedmode"))
1057	{
1058	/* three parameters follow */
1059	if (curArg + 3 >= argc)
1060	{
1061	RTPrintf("Error: missing arguments for fixed video mode!\n");
1062	return 1;
1063	}
1064	fixedWidth = atoi(argv[++curArg]);
1065	fixedHeight = atoi(argv[++curArg]);
1066	fixedBPP = atoi(argv[++curArg]);
1067	}
1068	else if ( !strcmp(argv[curArg], "--nofstoggle")
1069	\|\| !strcmp(argv[curArg], "-nofstoggle"))
1070	{
1071	gfAllowFullscreenToggle = FALSE;
1072	}
1073	else if ( !strcmp(argv[curArg], "--noresize")
1074	\|\| !strcmp(argv[curArg], "-noresize"))
1075	{
1076	fResizable = false;
1077	}
1078	else if ( !strcmp(argv[curArg], "--nohostkey")
1079	\|\| !strcmp(argv[curArg], "-nohostkey"))
1080	{
1081	gHostKeyMod = 0;
1082	gHostKeySym1 = 0;
1083	}
1084	else if ( !strcmp(argv[curArg], "--nohostkeys")
1085	\|\| !strcmp(argv[curArg], "-nohostkeys"))
1086	{
1087	if (++curArg >= argc)
1088	{
1089	RTPrintf("Error: missing a string of disabled hostkey combinations\n");
1090	return 1;
1091	}
1092	gHostKeyDisabledCombinations = argv[curArg];
1093	size_t cch = strlen(gHostKeyDisabledCombinations);
1094	for (size_t i = 0; i < cch; i++)
1095	{
1096	if (!strchr("fhnpqrs", gHostKeyDisabledCombinations[i]))
1097	{
1098	RTPrintf("Error: <hostkey> + '%c' is not a valid combination\n",
1099	gHostKeyDisabledCombinations[i]);
1100	return 1;
1101	}
1102	}
1103	}
1104	else if ( !strcmp(argv[curArg], "--nograbonclick")
1105	\|\| !strcmp(argv[curArg], "-nograbonclick"))
1106	{
1107	gfGrabOnMouseClick = FALSE;
1108	}
1109	else if ( !strcmp(argv[curArg], "--termacpi")
1110	\|\| !strcmp(argv[curArg], "-termacpi"))
1111	{
1112	gfACPITerm = TRUE;
1113	}
1114	else if ( !strcmp(argv[curArg], "--pidfile")
1115	\|\| !strcmp(argv[curArg], "-pidfile"))
1116	{
1117	if (++curArg >= argc)
1118	{
1119	RTPrintf("Error: missing file name for --pidfile!\n");
1120	return 1;
1121	}
1122	gpszPidFile = argv[curArg];
1123	}
1124	else if ( !strcmp(argv[curArg], "--hda")
1125	\|\| !strcmp(argv[curArg], "-hda"))
1126	{
1127	if (++curArg >= argc)
1128	{
1129	RTPrintf("Error: missing file name for first hard disk!\n");
1130	return 1;
1131	}
1132	/* resolve it. */
1133	if (RTPathExists(argv[curArg]))
1134	pcszHdaFile = RTPathRealDup(argv[curArg]);
1135	if (!pcszHdaFile)
1136	{
1137	RTPrintf("Error: The path to the specified harddisk, '%s', could not be resolved.\n", argv[curArg]);
1138	return 1;
1139	}
1140	}
1141	else if ( !strcmp(argv[curArg], "--fda")
1142	\|\| !strcmp(argv[curArg], "-fda"))
1143	{
1144	if (++curArg >= argc)
1145	{
1146	RTPrintf("Error: missing file/device name for first floppy disk!\n");
1147	return 1;
1148	}
1149	/* resolve it. */
1150	if (RTPathExists(argv[curArg]))
1151	pcszFdaFile = RTPathRealDup(argv[curArg]);
1152	if (!pcszFdaFile)
1153	{
1154	RTPrintf("Error: The path to the specified floppy disk, '%s', could not be resolved.\n", argv[curArg]);
1155	return 1;
1156	}
1157	}
1158	else if ( !strcmp(argv[curArg], "--cdrom")
1159	\|\| !strcmp(argv[curArg], "-cdrom"))
1160	{
1161	if (++curArg >= argc)
1162	{
1163	RTPrintf("Error: missing file/device name for cdrom!\n");
1164	return 1;
1165	}
1166	/* resolve it. */
1167	if (RTPathExists(argv[curArg]))
1168	pcszCdromFile = RTPathRealDup(argv[curArg]);
1169	if (!pcszCdromFile)
1170	{
1171	RTPrintf("Error: The path to the specified cdrom, '%s', could not be resolved.\n", argv[curArg]);
1172	return 1;
1173	}
1174	}
1175	else if ( !strcmp(argv[curArg], "--vrdp")
1176	\|\| !strcmp(argv[curArg], "-vrdp"))
1177	{
1178	// start with the standard VRDP port
1179	pszPortVRDP = "0";
1180
1181	// is there another argument
1182	if (argc > (curArg + 1))
1183	{
1184	curArg++;
1185	pszPortVRDP = argv[curArg];
1186	LogFlow(("Using non standard VRDP port %s\n", pszPortVRDP));
1187	}
1188	}
1189	else if ( !strcmp(argv[curArg], "--discardstate")
1190	\|\| !strcmp(argv[curArg], "-discardstate"))
1191	{
1192	fDiscardState = true;
1193	}
1194	else if (!strcmp(argv[curArg], "--settingspw"))
1195	{
1196	if (++curArg >= argc)
1197	{
1198	RTPrintf("Error: missing password");
1199	return 1;
1200	}
1201	pcszSettingsPw = argv[curArg];
1202	}
1203	else if (!strcmp(argv[curArg], "--settingspwfile"))
1204	{
1205	if (++curArg >= argc)
1206	{
1207	RTPrintf("Error: missing password file\n");
1208	return 1;
1209	}
1210	pcszSettingsPwFile = argv[curArg];
1211	}
1212	#ifdef VBOX_SECURELABEL
1213	else if ( !strcmp(argv[curArg], "--securelabel")
1214	\|\| !strcmp(argv[curArg], "-securelabel"))
1215	{
1216	fSecureLabel = true;
1217	LogFlow(("Secure labelling turned on\n"));
1218	}
1219	else if ( !strcmp(argv[curArg], "--seclabelfnt")
1220	\|\| !strcmp(argv[curArg], "-seclabelfnt"))
1221	{
1222	if (++curArg >= argc)
1223	{
1224	RTPrintf("Error: missing font file name for secure label!\n");
1225	return 1;
1226	}
1227	secureLabelFontFile = argv[curArg];
1228	}
1229	else if ( !strcmp(argv[curArg], "--seclabelsiz")
1230	\|\| !strcmp(argv[curArg], "-seclabelsiz"))
1231	{
1232	if (++curArg >= argc)
1233	{
1234	RTPrintf("Error: missing font point size for secure label!\n");
1235	return 1;
1236	}
1237	secureLabelPointSize = atoi(argv[curArg]);
1238	}
1239	else if ( !strcmp(argv[curArg], "--seclabelofs")
1240	\|\| !strcmp(argv[curArg], "-seclabelofs"))
1241	{
1242	if (++curArg >= argc)
1243	{
1244	RTPrintf("Error: missing font pixel offset for secure label!\n");
1245	return 1;
1246	}
1247	secureLabelFontOffs = atoi(argv[curArg]);
1248	}
1249	else if ( !strcmp(argv[curArg], "--seclabelfgcol")
1250	\|\| !strcmp(argv[curArg], "-seclabelfgcol"))
1251	{
1252	if (++curArg >= argc)
1253	{
1254	RTPrintf("Error: missing text color value for secure label!\n");
1255	return 1;
1256	}
1257	sscanf(argv[curArg], "%X", &secureLabelColorFG);
1258	}
1259	else if ( !strcmp(argv[curArg], "--seclabelbgcol")
1260	\|\| !strcmp(argv[curArg], "-seclabelbgcol"))
1261	{
1262	if (++curArg >= argc)
1263	{
1264	RTPrintf("Error: missing background color value for secure label!\n");
1265	return 1;
1266	}
1267	sscanf(argv[curArg], "%X", &secureLabelColorBG);
1268	}
1269	#endif
1270	#ifdef VBOXSDL_ADVANCED_OPTIONS
1271	else if ( !strcmp(argv[curArg], "--rawr0")
1272	\|\| !strcmp(argv[curArg], "-rawr0"))
1273	fRawR0 = true;
1274	else if ( !strcmp(argv[curArg], "--norawr0")
1275	\|\| !strcmp(argv[curArg], "-norawr0"))
1276	fRawR0 = false;
1277	else if ( !strcmp(argv[curArg], "--rawr3")
1278	\|\| !strcmp(argv[curArg], "-rawr3"))
1279	fRawR3 = true;
1280	else if ( !strcmp(argv[curArg], "--norawr3")
1281	\|\| !strcmp(argv[curArg], "-norawr3"))
1282	fRawR3 = false;
1283	else if ( !strcmp(argv[curArg], "--patm")
1284	\|\| !strcmp(argv[curArg], "-patm"))
1285	fPATM = true;
1286	else if ( !strcmp(argv[curArg], "--nopatm")
1287	\|\| !strcmp(argv[curArg], "-nopatm"))
1288	fPATM = false;
1289	else if ( !strcmp(argv[curArg], "--csam")
1290	\|\| !strcmp(argv[curArg], "-csam"))
1291	fCSAM = true;
1292	else if ( !strcmp(argv[curArg], "--nocsam")
1293	\|\| !strcmp(argv[curArg], "-nocsam"))
1294	fCSAM = false;
1295	else if ( !strcmp(argv[curArg], "--hwvirtex")
1296	\|\| !strcmp(argv[curArg], "-hwvirtex"))
1297	fHWVirt = true;
1298	else if ( !strcmp(argv[curArg], "--nohwvirtex")
1299	\|\| !strcmp(argv[curArg], "-nohwvirtex"))
1300	fHWVirt = false;
1301	else if ( !strcmp(argv[curArg], "--warpdrive")
1302	\|\| !strcmp(argv[curArg], "-warpdrive"))
1303	{
1304	if (++curArg >= argc)
1305	{
1306	RTPrintf("Error: missing the rate value for the --warpdrive option!\n");
1307	return 1;
1308	}
1309	u32WarpDrive = RTStrToUInt32(argv[curArg]);
1310	if (u32WarpDrive < 2 \|\| u32WarpDrive > 20000)
1311	{
1312	RTPrintf("Error: the warp drive rate is restricted to [2..20000]. (%d)\n", u32WarpDrive);
1313	return 1;
1314	}
1315	}
1316	#endif /* VBOXSDL_ADVANCED_OPTIONS */
1317	#ifdef VBOX_WIN32_UI
1318	else if ( !strcmp(argv[curArg], "--win32ui")
1319	\|\| !strcmp(argv[curArg], "-win32ui"))
1320	fWin32UI = true;
1321	#endif
1322	else if ( !strcmp(argv[curArg], "--showsdlconfig")
1323	\|\| !strcmp(argv[curArg], "-showsdlconfig"))
1324	fShowSDLConfig = true;
1325	else if ( !strcmp(argv[curArg], "--hostkey")
1326	\|\| !strcmp(argv[curArg], "-hostkey"))
1327	{
1328	if (++curArg + 1 >= argc)
1329	{
1330	RTPrintf("Error: not enough arguments for host keys!\n");
1331	return 1;
1332	}
1333	gHostKeySym1 = atoi(argv[curArg++]);
1334	if (curArg + 1 < argc && (argv[curArg+1][0] == '0' \|\| atoi(argv[curArg+1]) > 0))
1335	{
1336	/* two-key sequence as host key specified */
1337	gHostKeySym2 = atoi(argv[curArg++]);
1338	}
1339	gHostKeyMod = atoi(argv[curArg]);
1340	}
1341	/* just show the help screen */
1342	else
1343	{
1344	if ( strcmp(argv[curArg], "-h")
1345	&& strcmp(argv[curArg], "-help")
1346	&& strcmp(argv[curArg], "--help"))
1347	RTPrintf("Error: unrecognized switch '%s'\n", argv[curArg]);
1348	show_usage();
1349	return 1;
1350	}
1351	}
1352
1353	rc = com::Initialize();
1354	#ifdef VBOX_WITH_XPCOM
1355	if (rc == NS_ERROR_FILE_ACCESS_DENIED)
1356	{
1357	char szHome[RTPATH_MAX] = "";
1358	com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome));
1359	RTPrintf("Failed to initialize COM because the global settings directory '%s' is not accessible!\n", szHome);
1360	return 1;
1361	}
1362	#endif
1363	if (FAILED(rc))
1364	{
1365	RTPrintf("Error: COM initialization failed (rc=%Rhrc)!\n", rc);
1366	return 1;
1367	}
1368
1369	/* NOTE: do not convert the following scope to a "do {} while (0);", as
1370	* this would make it all too tempting to use "break;" incorrectly - it
1371	* would skip over the cleanup. */
1372	{
1373	// scopes all the stuff till shutdown
1374	////////////////////////////////////////////////////////////////////////////
1375
1376	ComPtr<IVirtualBoxClient> pVirtualBoxClient;
1377	ComPtr<IVirtualBox> pVirtualBox;
1378	ComPtr<ISession> pSession;
1379	bool sessionOpened = false;
1380	NativeEventQueue* eventQ = com::NativeEventQueue::getMainEventQueue();
1381
1382	ComPtr<IMachine> pMachine;
1383
1384	rc = pVirtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
1385	if (FAILED(rc))
1386	{
1387	com::ErrorInfo info;
1388	if (info.isFullAvailable())
1389	PrintError("Failed to create VirtualBoxClient object",
1390	info.getText().raw(), info.getComponent().raw());
1391	else
1392	RTPrintf("Failed to create VirtualBoxClient object! No error information available (rc=%Rhrc).\n", rc);
1393	goto leave;
1394	}
1395
1396	rc = pVirtualBoxClient->COMGETTER(VirtualBox)(pVirtualBox.asOutParam());
1397	if (FAILED(rc))
1398	{
1399	RTPrintf("Failed to get VirtualBox object (rc=%Rhrc)!\n", rc);
1400	goto leave;
1401	}
1402	rc = pVirtualBoxClient->COMGETTER(Session)(pSession.asOutParam());
1403	if (FAILED(rc))
1404	{
1405	RTPrintf("Failed to get session object (rc=%Rhrc)!\n", rc);
1406	goto leave;
1407	}
1408
1409	if (pcszSettingsPw)
1410	{
1411	CHECK_ERROR(pVirtualBox, SetSettingsSecret(Bstr(pcszSettingsPw).raw()));
1412	if (FAILED(rc))
1413	goto leave;
1414	}
1415	else if (pcszSettingsPwFile)
1416	{
1417	int rcExit = settingsPasswordFile(pVirtualBox, pcszSettingsPwFile);
1418	if (rcExit != RTEXITCODE_SUCCESS)
1419	goto leave;
1420	}
1421
1422	/*
1423	* Do we have a UUID?
1424	*/
1425	if (uuidVM.isValid())
1426	{
1427	rc = pVirtualBox->FindMachine(uuidVM.toUtf16().raw(), pMachine.asOutParam());
1428	if (FAILED(rc) \|\| !pMachine)
1429	{
1430	RTPrintf("Error: machine with the given ID not found!\n");
1431	goto leave;
1432	}
1433	}
1434	else if (vmName)
1435	{
1436	/*
1437	* Do we have a name but no UUID?
1438	*/
1439	rc = pVirtualBox->FindMachine(Bstr(vmName).raw(), pMachine.asOutParam());
1440	if ((rc == S_OK) && pMachine)
1441	{
1442	Bstr bstrId;
1443	pMachine->COMGETTER(Id)(bstrId.asOutParam());
1444	uuidVM = Guid(bstrId);
1445	}
1446	else
1447	{
1448	RTPrintf("Error: machine with the given name not found!\n");
1449	RTPrintf("Check if this VM has been corrupted and is now inaccessible.");
1450	goto leave;
1451	}
1452	}
1453
1454	/* create SDL event semaphore */
1455	vrc = RTSemEventCreate(&g_EventSemSDLEvents);
1456	AssertReleaseRC(vrc);
1457
1458	rc = pVirtualBoxClient->CheckMachineError(pMachine);
1459	if (FAILED(rc))
1460	{
1461	com::ErrorInfo info;
1462	if (info.isFullAvailable())
1463	PrintError("The VM has errors",
1464	info.getText().raw(), info.getComponent().raw());
1465	else
1466	RTPrintf("Failed to check for VM errors! No error information available (rc=%Rhrc).\n", rc);
1467	goto leave;
1468	}
1469
1470	rc = pMachine->LockMachine(pSession, LockType_VM);
1471	if (FAILED(rc))
1472	{
1473	com::ErrorInfo info;
1474	if (info.isFullAvailable())
1475	PrintError("Could not open VirtualBox session",
1476	info.getText().raw(), info.getComponent().raw());
1477	goto leave;
1478	}
1479	if (!pSession)
1480	{
1481	RTPrintf("Could not open VirtualBox session!\n");
1482	goto leave;
1483	}
1484	sessionOpened = true;
1485	// get the mutable VM we're dealing with
1486	pSession->COMGETTER(Machine)(gpMachine.asOutParam());
1487	if (!gpMachine)
1488	{
1489	com::ErrorInfo info;
1490	if (info.isFullAvailable())
1491	PrintError("Cannot start VM!",
1492	info.getText().raw(), info.getComponent().raw());
1493	else
1494	RTPrintf("Error: given machine not found!\n");
1495	goto leave;
1496	}
1497	// get the VM console
1498	pSession->COMGETTER(Console)(gpConsole.asOutParam());
1499	if (!gpConsole)
1500	{
1501	RTPrintf("Given console not found!\n");
1502	goto leave;
1503	}
1504
1505	/*
1506	* Are we supposed to use a different hard disk file?
1507	*/
1508	if (pcszHdaFile)
1509	{
1510	ComPtr<IMedium> pMedium;
1511
1512	/*
1513	* Strategy: if any registered hard disk points to the same file,
1514	* assign it. If not, register a new image and assign it to the VM.
1515	*/
1516	Bstr bstrHdaFile(pcszHdaFile);
1517	pVirtualBox->OpenMedium(bstrHdaFile.raw(), DeviceType_HardDisk,
1518	AccessMode_ReadWrite, FALSE /* fForceNewUuid */,
1519	pMedium.asOutParam());
1520	if (!pMedium)
1521	{
1522	/* we've not found the image */
1523	RTPrintf("Adding hard disk '%s'...\n", pcszHdaFile);
1524	pVirtualBox->OpenMedium(bstrHdaFile.raw(), DeviceType_HardDisk,
1525	AccessMode_ReadWrite, FALSE /* fForceNewUuid */,
1526	pMedium.asOutParam());
1527	}
1528	/* do we have the right image now? */
1529	if (pMedium)
1530	{
1531	Bstr bstrSCName;
1532
1533	/* get the first IDE controller to attach the harddisk to
1534	* and if there is none, add one temporarily */
1535	{
1536	ComPtr<IStorageController> pStorageCtl;
1537	com::SafeIfaceArray<IStorageController> aStorageControllers;
1538	CHECK_ERROR(gpMachine, COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(aStorageControllers)));
1539	for (size_t i = 0; i < aStorageControllers.size(); ++ i)
1540	{
1541	StorageBus_T storageBus = StorageBus_Null;
1542
1543	CHECK_ERROR(aStorageControllers[i], COMGETTER(Bus)(&storageBus));
1544	if (storageBus == StorageBus_IDE)
1545	{
1546	pStorageCtl = aStorageControllers[i];
1547	break;
1548	}
1549	}
1550
1551	if (pStorageCtl)
1552	{
1553	CHECK_ERROR(pStorageCtl, COMGETTER(Name)(bstrSCName.asOutParam()));
1554	gpMachine->DetachDevice(bstrSCName.raw(), 0, 0);
1555	}
1556	else
1557	{
1558	bstrSCName = "IDE Controller";
1559	CHECK_ERROR(gpMachine, AddStorageController(bstrSCName.raw(),
1560	StorageBus_IDE,
1561	pStorageCtl.asOutParam()));
1562	}
1563	}
1564
1565	CHECK_ERROR(gpMachine, AttachDevice(bstrSCName.raw(), 0, 0,
1566	DeviceType_HardDisk, pMedium));
1567	/// @todo why is this attachment saved?
1568	}
1569	else
1570	{
1571	RTPrintf("Error: failed to mount the specified hard disk image!\n");
1572	goto leave;
1573	}
1574	}
1575
1576	/*
1577	* Mount a floppy if requested.
1578	*/
1579	if (pcszFdaFile)
1580	do
1581	{
1582	ComPtr<IMedium> pMedium;
1583
1584	/* unmount? */
1585	if (!strcmp(pcszFdaFile, "none"))
1586	{
1587	/* nothing to do, NULL object will cause unmount */
1588	}
1589	else
1590	{
1591	Bstr bstrFdaFile(pcszFdaFile);
1592
1593	/* Assume it's a host drive name */
1594	ComPtr<IHost> pHost;
1595	CHECK_ERROR_BREAK(pVirtualBox, COMGETTER(Host)(pHost.asOutParam()));
1596	rc = pHost->FindHostFloppyDrive(bstrFdaFile.raw(),
1597	pMedium.asOutParam());
1598	if (FAILED(rc))
1599	{
1600	/* try to find an existing one */
1601	rc = pVirtualBox->OpenMedium(bstrFdaFile.raw(),
1602	DeviceType_Floppy,
1603	AccessMode_ReadWrite,
1604	FALSE /* fForceNewUuid */,
1605	pMedium.asOutParam());
1606	if (FAILED(rc))
1607	{
1608	/* try to add to the list */
1609	RTPrintf("Adding floppy image '%s'...\n", pcszFdaFile);
1610	CHECK_ERROR_BREAK(pVirtualBox,
1611	OpenMedium(bstrFdaFile.raw(),
1612	DeviceType_Floppy,
1613	AccessMode_ReadWrite,
1614	FALSE /* fForceNewUuid */,
1615	pMedium.asOutParam()));
1616	}
1617	}
1618	}
1619
1620	Bstr bstrSCName;
1621
1622	/* get the first floppy controller to attach the floppy to
1623	* and if there is none, add one temporarily */
1624	{
1625	ComPtr<IStorageController> pStorageCtl;
1626	com::SafeIfaceArray<IStorageController> aStorageControllers;
1627	CHECK_ERROR(gpMachine, COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(aStorageControllers)));
1628	for (size_t i = 0; i < aStorageControllers.size(); ++ i)
1629	{
1630	StorageBus_T storageBus = StorageBus_Null;
1631
1632	CHECK_ERROR(aStorageControllers[i], COMGETTER(Bus)(&storageBus));
1633	if (storageBus == StorageBus_Floppy)
1634	{
1635	pStorageCtl = aStorageControllers[i];
1636	break;
1637	}
1638	}
1639
1640	if (pStorageCtl)
1641	{
1642	CHECK_ERROR(pStorageCtl, COMGETTER(Name)(bstrSCName.asOutParam()));
1643	gpMachine->DetachDevice(bstrSCName.raw(), 0, 0);
1644	}
1645	else
1646	{
1647	bstrSCName = "Floppy Controller";
1648	CHECK_ERROR(gpMachine, AddStorageController(bstrSCName.raw(),
1649	StorageBus_Floppy,
1650	pStorageCtl.asOutParam()));
1651	}
1652	}
1653
1654	CHECK_ERROR(gpMachine, AttachDevice(bstrSCName.raw(), 0, 0,
1655	DeviceType_Floppy, pMedium));
1656	}
1657	while (0);
1658	if (FAILED(rc))
1659	goto leave;
1660
1661	/*
1662	* Mount a CD-ROM if requested.
1663	*/
1664	if (pcszCdromFile)
1665	do
1666	{
1667	ComPtr<IMedium> pMedium;
1668
1669	/* unmount? */
1670	if (!strcmp(pcszCdromFile, "none"))
1671	{
1672	/* nothing to do, NULL object will cause unmount */
1673	}
1674	else
1675	{
1676	Bstr bstrCdromFile(pcszCdromFile);
1677
1678	/* Assume it's a host drive name */
1679	ComPtr<IHost> pHost;
1680	CHECK_ERROR_BREAK(pVirtualBox, COMGETTER(Host)(pHost.asOutParam()));
1681	rc = pHost->FindHostDVDDrive(bstrCdromFile.raw(), pMedium.asOutParam());
1682	if (FAILED(rc))
1683	{
1684	/* try to find an existing one */
1685	rc = pVirtualBox->OpenMedium(bstrCdromFile.raw(),
1686	DeviceType_DVD,
1687	AccessMode_ReadWrite,
1688	FALSE /* fForceNewUuid */,
1689	pMedium.asOutParam());
1690	if (FAILED(rc))
1691	{
1692	/* try to add to the list */
1693	RTPrintf("Adding ISO image '%s'...\n", pcszCdromFile);
1694	CHECK_ERROR_BREAK(pVirtualBox,
1695	OpenMedium(bstrCdromFile.raw(),
1696	DeviceType_DVD,
1697	AccessMode_ReadWrite,
1698	FALSE /* fForceNewUuid */,
1699	pMedium.asOutParam()));
1700	}
1701	}
1702	}
1703
1704	Bstr bstrSCName;
1705
1706	/* get the first IDE controller to attach the DVD drive to
1707	* and if there is none, add one temporarily */
1708	{
1709	ComPtr<IStorageController> pStorageCtl;
1710	com::SafeIfaceArray<IStorageController> aStorageControllers;
1711	CHECK_ERROR(gpMachine, COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(aStorageControllers)));
1712	for (size_t i = 0; i < aStorageControllers.size(); ++ i)
1713	{
1714	StorageBus_T storageBus = StorageBus_Null;
1715
1716	CHECK_ERROR(aStorageControllers[i], COMGETTER(Bus)(&storageBus));
1717	if (storageBus == StorageBus_IDE)
1718	{
1719	pStorageCtl = aStorageControllers[i];
1720	break;
1721	}
1722	}
1723
1724	if (pStorageCtl)
1725	{
1726	CHECK_ERROR(pStorageCtl, COMGETTER(Name)(bstrSCName.asOutParam()));
1727	gpMachine->DetachDevice(bstrSCName.raw(), 1, 0);
1728	}
1729	else
1730	{
1731	bstrSCName = "IDE Controller";
1732	CHECK_ERROR(gpMachine, AddStorageController(bstrSCName.raw(),
1733	StorageBus_IDE,
1734	pStorageCtl.asOutParam()));
1735	}
1736	}
1737
1738	CHECK_ERROR(gpMachine, AttachDevice(bstrSCName.raw(), 1, 0,
1739	DeviceType_DVD, pMedium));
1740	}
1741	while (0);
1742	if (FAILED(rc))
1743	goto leave;
1744
1745	if (fDiscardState)
1746	{
1747	/*
1748	* If the machine is currently saved,
1749	* discard the saved state first.
1750	*/
1751	MachineState_T machineState;
1752	gpMachine->COMGETTER(State)(&machineState);
1753	if (machineState == MachineState_Saved)
1754	{
1755	CHECK_ERROR(gpConsole, DiscardSavedState(true /* fDeleteFile */));
1756	}
1757	/*
1758	* If there are snapshots, discard the current state,
1759	* i.e. revert to the last snapshot.
1760	*/
1761	ULONG cSnapshots;
1762	gpMachine->COMGETTER(SnapshotCount)(&cSnapshots);
1763	if (cSnapshots)
1764	{
1765	gpProgress = NULL;
1766
1767	ComPtr<ISnapshot> pCurrentSnapshot;
1768	CHECK_ERROR(gpMachine, COMGETTER(CurrentSnapshot)(pCurrentSnapshot.asOutParam()));
1769	if (FAILED(rc))
1770	goto leave;
1771
1772	CHECK_ERROR(gpConsole, RestoreSnapshot(pCurrentSnapshot, gpProgress.asOutParam()));
1773	rc = gpProgress->WaitForCompletion(-1);
1774	}
1775	}
1776
1777	// get the machine debugger (does not have to be there)
1778	gpConsole->COMGETTER(Debugger)(gpMachineDebugger.asOutParam());
1779	if (gpMachineDebugger)
1780	{
1781	Log(("Machine debugger available!\n"));
1782	}
1783	gpConsole->COMGETTER(Display)(gpDisplay.asOutParam());
1784	if (!gpDisplay)
1785	{
1786	RTPrintf("Error: could not get display object!\n");
1787	goto leave;
1788	}
1789
1790	// set the boot drive
1791	if (bootDevice != DeviceType_Null)
1792	{
1793	rc = gpMachine->SetBootOrder(1, bootDevice);
1794	if (rc != S_OK)
1795	{
1796	RTPrintf("Error: could not set boot device, using default.\n");
1797	}
1798	}
1799
1800	// set the memory size if not default
1801	if (memorySize)
1802	{
1803	rc = gpMachine->COMSETTER(MemorySize)(memorySize);
1804	if (rc != S_OK)
1805	{
1806	ULONG ramSize = 0;
1807	gpMachine->COMGETTER(MemorySize)(&ramSize);
1808	RTPrintf("Error: could not set memory size, using current setting of %d MBytes\n", ramSize);
1809	}
1810	}
1811
1812	if (vramSize)
1813	{
1814	rc = gpMachine->COMSETTER(VRAMSize)(vramSize);
1815	if (rc != S_OK)
1816	{
1817	gpMachine->COMGETTER(VRAMSize)((ULONG*)&vramSize);
1818	RTPrintf("Error: could not set VRAM size, using current setting of %d MBytes\n", vramSize);
1819	}
1820	}
1821
1822	// we're always able to process absolute mouse events and we prefer that
1823	gfAbsoluteMouseHost = TRUE;
1824
1825	#ifdef VBOX_WIN32_UI
1826	if (fWin32UI)
1827	{
1828	/* initialize the Win32 user interface inside which SDL will be embedded */
1829	if (initUI(fResizable, winId))
1830	return 1;
1831	}
1832	#endif
1833
1834	/* static initialization of the SDL stuff */
1835	if (!VBoxSDLFB::init(fShowSDLConfig))
1836	goto leave;
1837
1838	gpMachine->COMGETTER(MonitorCount)(&gcMonitors);
1839	if (gcMonitors > 64)
1840	gcMonitors = 64;
1841
1842	for (unsigned i = 0; i < gcMonitors; i++)
1843	{
1844	// create our SDL framebuffer instance
1845	gpFramebuffer[i] = new VBoxSDLFB(i, fFullscreen, fResizable, fShowSDLConfig, false,
1846	fixedWidth, fixedHeight, fixedBPP);
1847
1848	if (!gpFramebuffer[i])
1849	{
1850	RTPrintf("Error: could not create framebuffer object!\n");
1851	goto leave;
1852	}
1853	}
1854
1855	#ifdef VBOX_WIN32_UI
1856	gpFramebuffer[0]->setWinId(winId);
1857	#endif
1858
1859	for (unsigned i = 0; i < gcMonitors; i++)
1860	{
1861	if (!gpFramebuffer[i]->initialized())
1862	goto leave;
1863	gpFramebuffer[i]->AddRef();
1864	if (fFullscreen)
1865	SetFullscreen(true);
1866	}
1867
1868	#ifdef VBOX_SECURELABEL
1869	if (fSecureLabel)
1870	{
1871	if (!secureLabelFontFile)
1872	{
1873	RTPrintf("Error: no font file specified for secure label!\n");
1874	goto leave;
1875	}
1876	/* load the SDL_ttf library and get the required imports */
1877	vrc = RTLdrLoad(LIBSDL_TTF_NAME, &gLibrarySDL_ttf);
1878	if (RT_SUCCESS(vrc))
1879	vrc = RTLdrGetSymbol(gLibrarySDL_ttf, "TTF_Init", (void**)&pTTF_Init);
1880	if (RT_SUCCESS(vrc))
1881	vrc = RTLdrGetSymbol(gLibrarySDL_ttf, "TTF_OpenFont", (void**)&pTTF_OpenFont);
1882	if (RT_SUCCESS(vrc))
1883	vrc = RTLdrGetSymbol(gLibrarySDL_ttf, "TTF_RenderUTF8_Solid", (void**)&pTTF_RenderUTF8_Solid);
1884	if (RT_SUCCESS(vrc))
1885	{
1886	/* silently ignore errors here */
1887	vrc = RTLdrGetSymbol(gLibrarySDL_ttf, "TTF_RenderUTF8_Blended", (void**)&pTTF_RenderUTF8_Blended);
1888	if (RT_FAILURE(vrc))
1889	pTTF_RenderUTF8_Blended = NULL;
1890	vrc = VINF_SUCCESS;
1891	}
1892	if (RT_SUCCESS(vrc))
1893	vrc = RTLdrGetSymbol(gLibrarySDL_ttf, "TTF_CloseFont", (void**)&pTTF_CloseFont);
1894	if (RT_SUCCESS(vrc))
1895	vrc = RTLdrGetSymbol(gLibrarySDL_ttf, "TTF_Quit", (void**)&pTTF_Quit);
1896	if (RT_SUCCESS(vrc))
1897	vrc = gpFramebuffer[0]->initSecureLabel(SECURE_LABEL_HEIGHT, secureLabelFontFile, secureLabelPointSize, secureLabelFontOffs);
1898	if (RT_FAILURE(vrc))
1899	{
1900	RTPrintf("Error: could not initialize secure labeling: rc = %Rrc\n", vrc);
1901	goto leave;
1902	}
1903	Bstr bstrLabel;
1904	gpMachine->GetExtraData(Bstr(VBOXSDL_SECURELABEL_EXTRADATA).raw(), bstrLabel.asOutParam());
1905	Utf8Str labelUtf8(bstrLabel);
1906	/*
1907	* Now update the label
1908	*/
1909	gpFramebuffer[0]->setSecureLabelColor(secureLabelColorFG, secureLabelColorBG);
1910	gpFramebuffer[0]->setSecureLabelText(labelUtf8.c_str());
1911	}
1912	#endif
1913
1914	#ifdef VBOXSDL_WITH_X11
1915	/* NOTE1: We still want Ctrl-C to work, so we undo the SDL redirections.
1916	* NOTE2: We have to remove the PidFile if this file exists. */
1917	signal(SIGINT, signal_handler_SIGINT);
1918	signal(SIGQUIT, signal_handler_SIGINT);
1919	signal(SIGSEGV, signal_handler_SIGINT);
1920	#endif
1921
1922
1923	for (ULONG i = 0; i < gcMonitors; i++)
1924	{
1925	// register our framebuffer
1926	rc = gpDisplay->SetFramebuffer(i, gpFramebuffer[i]);
1927	if (FAILED(rc))
1928	{
1929	RTPrintf("Error: could not register framebuffer object!\n");
1930	goto leave;
1931	}
1932	IFramebuffer *dummyFb;
1933	LONG xOrigin, yOrigin;
1934	rc = gpDisplay->GetFramebuffer(i, &dummyFb, &xOrigin, &yOrigin);
1935	gpFramebuffer[i]->setOrigin(xOrigin, yOrigin);
1936	}
1937
1938	{
1939	// register listener for VirtualBoxClient events
1940	ComPtr<IEventSource> pES;
1941	CHECK_ERROR(pVirtualBoxClient, COMGETTER(EventSource)(pES.asOutParam()));
1942	ComObjPtr<VBoxSDLClientEventListenerImpl> listener;
1943	listener.createObject();
1944	listener->init(new VBoxSDLClientEventListener());
1945	pVBoxClientListener = listener;
1946	com::SafeArray<VBoxEventType_T> eventTypes;
1947	eventTypes.push_back(VBoxEventType_OnVBoxSVCAvailabilityChanged);
1948	CHECK_ERROR(pES, RegisterListener(pVBoxClientListener, ComSafeArrayAsInParam(eventTypes), true));
1949	}
1950
1951	{
1952	// register listener for VirtualBox (server) events
1953	ComPtr<IEventSource> pES;
1954	CHECK_ERROR(pVirtualBox, COMGETTER(EventSource)(pES.asOutParam()));
1955	ComObjPtr<VBoxSDLEventListenerImpl> listener;
1956	listener.createObject();
1957	listener->init(new VBoxSDLEventListener());
1958	pVBoxListener = listener;
1959	com::SafeArray<VBoxEventType_T> eventTypes;
1960	eventTypes.push_back(VBoxEventType_OnExtraDataChanged);
1961	CHECK_ERROR(pES, RegisterListener(pVBoxListener, ComSafeArrayAsInParam(eventTypes), true));
1962	}
1963
1964	{
1965	// register listener for Console events
1966	ComPtr<IEventSource> pES;
1967	CHECK_ERROR(gpConsole, COMGETTER(EventSource)(pES.asOutParam()));
1968	pConsoleListener.createObject();
1969	pConsoleListener->init(new VBoxSDLConsoleEventListener());
1970	com::SafeArray<VBoxEventType_T> eventTypes;
1971	eventTypes.push_back(VBoxEventType_OnMousePointerShapeChanged);
1972	eventTypes.push_back(VBoxEventType_OnMouseCapabilityChanged);
1973	eventTypes.push_back(VBoxEventType_OnKeyboardLedsChanged);
1974	eventTypes.push_back(VBoxEventType_OnStateChanged);
1975	eventTypes.push_back(VBoxEventType_OnRuntimeError);
1976	eventTypes.push_back(VBoxEventType_OnCanShowWindow);
1977	eventTypes.push_back(VBoxEventType_OnShowWindow);
1978	CHECK_ERROR(pES, RegisterListener(pConsoleListener, ComSafeArrayAsInParam(eventTypes), true));
1979	// until we've tried to to start the VM, ignore power off events
1980	pConsoleListener->getWrapped()->ignorePowerOffEvents(true);
1981	}
1982
1983	if (pszPortVRDP)
1984	{
1985	rc = gpMachine->COMGETTER(VRDEServer)(gpVRDEServer.asOutParam());
1986	AssertMsg((rc == S_OK) && gpVRDEServer, ("Could not get VRDP Server! rc = 0x%x\n", rc));
1987	if (gpVRDEServer)
1988	{
1989	// has a non standard VRDP port been requested?
1990	if (strcmp(pszPortVRDP, "0"))
1991	{
1992	rc = gpVRDEServer->SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr(pszPortVRDP).raw());
1993	if (rc != S_OK)
1994	{
1995	RTPrintf("Error: could not set VRDP port! rc = 0x%x\n", rc);
1996	goto leave;
1997	}
1998	}
1999	// now enable VRDP
2000	rc = gpVRDEServer->COMSETTER(Enabled)(TRUE);
2001	if (rc != S_OK)
2002	{
2003	RTPrintf("Error: could not enable VRDP server! rc = 0x%x\n", rc);
2004	goto leave;
2005	}
2006	}
2007	}
2008
2009	rc = E_FAIL;
2010	#ifdef VBOXSDL_ADVANCED_OPTIONS
2011	if (fRawR0 != ~0U)
2012	{
2013	if (!gpMachineDebugger)
2014	{
2015	RTPrintf("Error: No debugger object; -%srawr0 cannot be executed!\n", fRawR0 ? "" : "no");
2016	goto leave;
2017	}
2018	gpMachineDebugger->COMSETTER(RecompileSupervisor)(!fRawR0);
2019	}
2020	if (fRawR3 != ~0U)
2021	{
2022	if (!gpMachineDebugger)
2023	{
2024	RTPrintf("Error: No debugger object; -%srawr3 cannot be executed!\n", fRawR3 ? "" : "no");
2025	goto leave;
2026	}
2027	gpMachineDebugger->COMSETTER(RecompileUser)(!fRawR3);
2028	}
2029	if (fPATM != ~0U)
2030	{
2031	if (!gpMachineDebugger)
2032	{
2033	RTPrintf("Error: No debugger object; -%spatm cannot be executed!\n", fPATM ? "" : "no");
2034	goto leave;
2035	}
2036	gpMachineDebugger->COMSETTER(PATMEnabled)(fPATM);
2037	}
2038	if (fCSAM != ~0U)
2039	{
2040	if (!gpMachineDebugger)
2041	{
2042	RTPrintf("Error: No debugger object; -%scsam cannot be executed!\n", fCSAM ? "" : "no");
2043	goto leave;
2044	}
2045	gpMachineDebugger->COMSETTER(CSAMEnabled)(fCSAM);
2046	}
2047	if (fHWVirt != ~0U)
2048	{
2049	gpMachine->SetHWVirtExProperty(HWVirtExPropertyType_Enabled, fHWVirt);
2050	}
2051	if (u32WarpDrive != 0)
2052	{
2053	if (!gpMachineDebugger)
2054	{
2055	RTPrintf("Error: No debugger object; --warpdrive %d cannot be executed!\n", u32WarpDrive);
2056	goto leave;
2057	}
2058	gpMachineDebugger->COMSETTER(VirtualTimeRate)(u32WarpDrive);
2059	}
2060	#endif /* VBOXSDL_ADVANCED_OPTIONS */
2061
2062	/* start with something in the titlebar */
2063	UpdateTitlebar(TITLEBAR_NORMAL);
2064
2065	/* memorize the default cursor */
2066	gpDefaultCursor = SDL_GetCursor();
2067
2068	#if !defined(VBOX_WITH_SDL13)
2069	# if defined(VBOXSDL_WITH_X11)
2070	/* Get Window Manager info. We only need the X11 display. */
2071	SDL_VERSION(&gSdlInfo.version);
2072	if (!SDL_GetWMInfo(&gSdlInfo))
2073	RTPrintf("Error: could not get SDL Window Manager info -- no Xcursor support!\n");
2074	else
2075	gfXCursorEnabled = TRUE;
2076
2077	# if !defined(VBOX_WITHOUT_XCURSOR)
2078	/* SDL uses its own (plain) default cursor. Use the left arrow cursor instead which might look
2079	* much better if a mouse cursor theme is installed. */
2080	if (gfXCursorEnabled)
2081	{
2082	gpDefaultOrigX11Cursor = (Cursor)gpDefaultCursor->wm_cursor;
2083	(Cursor)gpDefaultCursor->wm_cursor = XCreateFontCursor(gSdlInfo.info.x11.display, XC_left_ptr);
2084	SDL_SetCursor(gpDefaultCursor);
2085	}
2086	# endif
2087	/* Initialise the keyboard */
2088	X11DRV_InitKeyboard(gSdlInfo.info.x11.display, NULL, NULL, NULL, NULL);
2089	# endif /* VBOXSDL_WITH_X11 */
2090
2091	/* create a fake empty cursor */
2092	{
2093	uint8_t cursorData[1] = {0};
2094	gpCustomCursor = SDL_CreateCursor(cursorData, cursorData, 8, 1, 0, 0);
2095	gpCustomOrigWMcursor = gpCustomCursor->wm_cursor;
2096	gpCustomCursor->wm_cursor = NULL;
2097	}
2098	#endif /* !VBOX_WITH_SDL13 */
2099
2100	/*
2101	* Register our user signal handler.
2102	*/
2103	#ifdef VBOXSDL_WITH_X11
2104	struct sigaction sa;
2105	sa.sa_sigaction = signal_handler_SIGUSR1;
2106	sigemptyset(&sa.sa_mask);
2107	sa.sa_flags = SA_RESTART \| SA_SIGINFO;
2108	sigaction(SIGUSR1, &sa, NULL);
2109	#endif /* VBOXSDL_WITH_X11 */
2110
2111	/*
2112	* Start the VM execution thread. This has to be done
2113	* asynchronously as powering up can take some time
2114	* (accessing devices such as the host DVD drive). In
2115	* the meantime, we have to service the SDL event loop.
2116	*/
2117	SDL_Event event;
2118
2119	LogFlow(("Powering up the VM...\n"));
2120	rc = gpConsole->PowerUp(gpProgress.asOutParam());
2121	if (rc != S_OK)
2122	{
2123	com::ErrorInfo info(gpConsole, COM_IIDOF(IConsole));
2124	if (info.isBasicAvailable())
2125	PrintError("Failed to power up VM", info.getText().raw());
2126	else
2127	RTPrintf("Error: failed to power up VM! No error text available.\n");
2128	goto leave;
2129	}
2130
2131	#ifdef USE_XPCOM_QUEUE_THREAD
2132	/*
2133	* Before we starting to do stuff, we have to launch the XPCOM
2134	* event queue thread. It will wait for events and send messages
2135	* to the SDL thread. After having done this, we should fairly
2136	* quickly start to process the SDL event queue as an XPCOM
2137	* event storm might arrive. Stupid SDL has a ridiculously small
2138	* event queue buffer!
2139	*/
2140	startXPCOMEventQueueThread(eventQ->getSelectFD());
2141	#endif /* USE_XPCOM_QUEUE_THREAD */
2142
2143	/* termination flag */
2144	bool fTerminateDuringStartup;
2145	fTerminateDuringStartup = false;
2146
2147	LogRel(("VBoxSDL: NUM lock initially %s, CAPS lock initially %s\n",
2148	!!(SDL_GetModState() & KMOD_NUM) ? "ON" : "OFF",
2149	!!(SDL_GetModState() & KMOD_CAPS) ? "ON" : "OFF"));
2150
2151	/* start regular timer so we don't starve in the event loop */
2152	SDL_TimerID sdlTimer;
2153	sdlTimer = SDL_AddTimer(100, StartupTimer, NULL);
2154
2155	/* loop until the powerup processing is done */
2156	MachineState_T machineState;
2157	do
2158	{
2159	rc = gpMachine->COMGETTER(State)(&machineState);
2160	if ( rc == S_OK
2161	&& ( machineState == MachineState_Starting
2162	\|\| machineState == MachineState_Restoring
2163	\|\| machineState == MachineState_TeleportingIn
2164	)
2165	)
2166	{
2167	/*
2168	* wait for the next event. This is uncritical as
2169	* power up guarantees to change the machine state
2170	* to either running or aborted and a machine state
2171	* change will send us an event. However, we have to
2172	* service the XPCOM event queue!
2173	*/
2174	#ifdef USE_XPCOM_QUEUE_THREAD
2175	if (!fXPCOMEventThreadSignaled)
2176	{
2177	signalXPCOMEventQueueThread();
2178	fXPCOMEventThreadSignaled = true;
2179	}
2180	#endif
2181	/*
2182	* Wait for SDL events.
2183	*/
2184	if (WaitSDLEvent(&event))
2185	{
2186	switch (event.type)
2187	{
2188	/*
2189	* Timer event. Used to have the titlebar updated.
2190	*/
2191	case SDL_USER_EVENT_TIMER:
2192	{
2193	/*
2194	* Update the title bar.
2195	*/
2196	UpdateTitlebar(TITLEBAR_STARTUP);
2197	break;
2198	}
2199
2200	/*
2201	* User specific resize event.
2202	*/
2203	case SDL_USER_EVENT_RESIZE:
2204	{
2205	LogFlow(("SDL_USER_EVENT_RESIZE\n"));
2206	IFramebuffer *dummyFb;
2207	LONG xOrigin, yOrigin;
2208	gpFramebuffer[event.user.code]->resizeGuest();
2209	/* update xOrigin, yOrigin -> mouse */
2210	rc = gpDisplay->GetFramebuffer(event.user.code, &dummyFb, &xOrigin, &yOrigin);
2211	gpFramebuffer[event.user.code]->setOrigin(xOrigin, yOrigin);
2212	/* notify the display that the resize has been completed */
2213	gpDisplay->ResizeCompleted(event.user.code);
2214	break;
2215	}
2216
2217	#ifdef USE_XPCOM_QUEUE_THREAD
2218	/*
2219	* User specific XPCOM event queue event
2220	*/
2221	case SDL_USER_EVENT_XPCOM_EVENTQUEUE:
2222	{
2223	LogFlow(("SDL_USER_EVENT_XPCOM_EVENTQUEUE: processing XPCOM event queue...\n"));
2224	eventQ->processEventQueue(0);
2225	signalXPCOMEventQueueThread();
2226	break;
2227	}
2228	#endif /* USE_XPCOM_QUEUE_THREAD */
2229
2230	/*
2231	* Termination event from the on state change callback.
2232	*/
2233	case SDL_USER_EVENT_TERMINATE:
2234	{
2235	if (event.user.code != VBOXSDL_TERM_NORMAL)
2236	{
2237	com::ProgressErrorInfo info(gpProgress);
2238	if (info.isBasicAvailable())
2239	PrintError("Failed to power up VM", info.getText().raw());
2240	else
2241	RTPrintf("Error: failed to power up VM! No error text available.\n");
2242	}
2243	fTerminateDuringStartup = true;
2244	break;
2245	}
2246
2247	default:
2248	{
2249	LogBird(("VBoxSDL: Unknown SDL event %d (pre)\n", event.type));
2250	break;
2251	}
2252	}
2253
2254	}
2255	}
2256	eventQ->processEventQueue(0);
2257	} while ( rc == S_OK
2258	&& ( machineState == MachineState_Starting
2259	\|\| machineState == MachineState_Restoring
2260	\|\| machineState == MachineState_TeleportingIn
2261	)
2262	);
2263
2264	/* kill the timer again */
2265	SDL_RemoveTimer(sdlTimer);
2266	sdlTimer = 0;
2267
2268	/* are we supposed to terminate the process? */
2269	if (fTerminateDuringStartup)
2270	goto leave;
2271
2272	/* did the power up succeed? */
2273	if (machineState != MachineState_Running)
2274	{
2275	com::ProgressErrorInfo info(gpProgress);
2276	if (info.isBasicAvailable())
2277	PrintError("Failed to power up VM", info.getText().raw());
2278	else
2279	RTPrintf("Error: failed to power up VM! No error text available (rc = 0x%x state = %d)\n", rc, machineState);
2280	goto leave;
2281	}
2282
2283	// accept power off events from now on because we're running
2284	// note that there's a possible race condition here...
2285	pConsoleListener->getWrapped()->ignorePowerOffEvents(false);
2286
2287	rc = gpConsole->COMGETTER(Keyboard)(gpKeyboard.asOutParam());
2288	if (!gpKeyboard)
2289	{
2290	RTPrintf("Error: could not get keyboard object!\n");
2291	goto leave;
2292	}
2293	gpConsole->COMGETTER(Mouse)(gpMouse.asOutParam());
2294	if (!gpMouse)
2295	{
2296	RTPrintf("Error: could not get mouse object!\n");
2297	goto leave;
2298	}
2299
2300	UpdateTitlebar(TITLEBAR_NORMAL);
2301
2302	/*
2303	* Enable keyboard repeats
2304	*/
2305	SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
2306
2307	/*
2308	* Create PID file.
2309	*/
2310	if (gpszPidFile)
2311	{
2312	char szBuf[32];
2313	const char *pcszLf = "\n";
2314	RTFILE PidFile;
2315	RTFileOpen(&PidFile, gpszPidFile, RTFILE_O_WRITE \| RTFILE_O_CREATE_REPLACE \| RTFILE_O_DENY_NONE);
2316	RTStrFormatNumber(szBuf, RTProcSelf(), 10, 0, 0, 0);
2317	RTFileWrite(PidFile, szBuf, strlen(szBuf), NULL);
2318	RTFileWrite(PidFile, pcszLf, strlen(pcszLf), NULL);
2319	RTFileClose(PidFile);
2320	}
2321
2322	/*
2323	* Main event loop
2324	*/
2325	#ifdef USE_XPCOM_QUEUE_THREAD
2326	if (!fXPCOMEventThreadSignaled)
2327	{
2328	signalXPCOMEventQueueThread();
2329	}
2330	#endif
2331	LogFlow(("VBoxSDL: Entering big event loop\n"));
2332	while (WaitSDLEvent(&event))
2333	{
2334	switch (event.type)
2335	{
2336	/*
2337	* The screen needs to be repainted.
2338	*/
2339	#ifdef VBOX_WITH_SDL13
2340	case SDL_WINDOWEVENT:
2341	{
2342	switch (event.window.event)
2343	{
2344	case SDL_WINDOWEVENT_EXPOSED:
2345	{
2346	VBoxSDLFB *fb = getFbFromWinId(event.window.windowID);
2347	if (fb)
2348	fb->repaint();
2349	break;
2350	}
2351	case SDL_WINDOWEVENT_FOCUS_GAINED:
2352	{
2353	break;
2354	}
2355	default:
2356	break;
2357	}
2358	}
2359	#else
2360	case SDL_VIDEOEXPOSE:
2361	{
2362	gpFramebuffer[0]->repaint();
2363	break;
2364	}
2365	#endif
2366
2367	/*
2368	* Keyboard events.
2369	*/
2370	case SDL_KEYDOWN:
2371	case SDL_KEYUP:
2372	{
2373	SDLKey ksym = event.key.keysym.sym;
2374
2375	switch (enmHKeyState)
2376	{
2377	case HKEYSTATE_NORMAL:
2378	{
2379	if ( event.type == SDL_KEYDOWN
2380	&& ksym != SDLK_UNKNOWN
2381	&& (ksym == gHostKeySym1 \|\| ksym == gHostKeySym2))
2382	{
2383	EvHKeyDown1 = event;
2384	enmHKeyState = ksym == gHostKeySym1 ? HKEYSTATE_DOWN_1ST
2385	: HKEYSTATE_DOWN_2ND;
2386	break;
2387	}
2388	ProcessKey(&event.key);
2389	break;
2390	}
2391
2392	case HKEYSTATE_DOWN_1ST:
2393	case HKEYSTATE_DOWN_2ND:
2394	{
2395	if (gHostKeySym2 != SDLK_UNKNOWN)
2396	{
2397	if ( event.type == SDL_KEYDOWN
2398	&& ksym != SDLK_UNKNOWN
2399	&& ( (enmHKeyState == HKEYSTATE_DOWN_1ST && ksym == gHostKeySym2)
2400	\|\| (enmHKeyState == HKEYSTATE_DOWN_2ND && ksym == gHostKeySym1)))
2401	{
2402	EvHKeyDown2 = event;
2403	enmHKeyState = HKEYSTATE_DOWN;
2404	break;
2405	}
2406	enmHKeyState = event.type == SDL_KEYUP ? HKEYSTATE_NORMAL
2407	: HKEYSTATE_NOT_IT;
2408	ProcessKey(&EvHKeyDown1.key);
2409	/* ugly hack: Some guests (e.g. mstsc.exe on Windows XP)
2410	* expect a small delay between two key events. 5ms work
2411	* reliable here so use 10ms to be on the safe side. A
2412	* better but more complicated fix would be to introduce
2413	* a new state and don't wait here. */
2414	RTThreadSleep(10);
2415	ProcessKey(&event.key);
2416	break;
2417	}
2418	/* fall through if no two-key sequence is used */
2419	}
2420
2421	case HKEYSTATE_DOWN:
2422	{
2423	if (event.type == SDL_KEYDOWN)
2424	{
2425	/* potential host key combination, try execute it */
2426	int irc = HandleHostKey(&event.key);
2427	if (irc == VINF_SUCCESS)
2428	{
2429	enmHKeyState = HKEYSTATE_USED;
2430	break;
2431	}
2432	if (RT_SUCCESS(irc))
2433	goto leave;
2434	}
2435	else /* SDL_KEYUP */
2436	{
2437	if ( ksym != SDLK_UNKNOWN
2438	&& (ksym == gHostKeySym1 \|\| ksym == gHostKeySym2))
2439	{
2440	/* toggle grabbing state */
2441	if (!gfGrabbed)
2442	InputGrabStart();
2443	else
2444	InputGrabEnd();
2445
2446	/* SDL doesn't always reset the keystates, correct it */
2447	ResetKeys();
2448	enmHKeyState = HKEYSTATE_NORMAL;
2449	break;
2450	}
2451	}
2452
2453	/* not host key */
2454	enmHKeyState = HKEYSTATE_NOT_IT;
2455	ProcessKey(&EvHKeyDown1.key);
2456	/* see the comment for the 2-key case above */
2457	RTThreadSleep(10);
2458	if (gHostKeySym2 != SDLK_UNKNOWN)
2459	{
2460	ProcessKey(&EvHKeyDown2.key);
2461	/* see the comment for the 2-key case above */
2462	RTThreadSleep(10);
2463	}
2464	ProcessKey(&event.key);
2465	break;
2466	}
2467
2468	case HKEYSTATE_USED:
2469	{
2470	if ((SDL_GetModState() & ~(KMOD_MODE \| KMOD_NUM \| KMOD_RESERVED)) == 0)
2471	enmHKeyState = HKEYSTATE_NORMAL;
2472	if (event.type == SDL_KEYDOWN)
2473	{
2474	int irc = HandleHostKey(&event.key);
2475	if (RT_SUCCESS(irc) && irc != VINF_SUCCESS)
2476	goto leave;
2477	}
2478	break;
2479	}
2480
2481	default:
2482	AssertMsgFailed(("enmHKeyState=%d\n", enmHKeyState));
2483	/* fall thru */
2484	case HKEYSTATE_NOT_IT:
2485	{
2486	if ((SDL_GetModState() & ~(KMOD_MODE \| KMOD_NUM \| KMOD_RESERVED)) == 0)
2487	enmHKeyState = HKEYSTATE_NORMAL;
2488	ProcessKey(&event.key);
2489	break;
2490	}
2491	} /* state switch */
2492	break;
2493	}
2494
2495	/*
2496	* The window was closed.
2497	*/
2498	case SDL_QUIT:
2499	{
2500	if (!gfACPITerm \|\| gSdlQuitTimer)
2501	goto leave;
2502	if (gpConsole)
2503	gpConsole->PowerButton();
2504	gSdlQuitTimer = SDL_AddTimer(1000, QuitTimer, NULL);
2505	break;
2506	}
2507
2508	/*
2509	* The mouse has moved
2510	*/
2511	case SDL_MOUSEMOTION:
2512	{
2513	if (gfGrabbed \|\| UseAbsoluteMouse())
2514	{
2515	VBoxSDLFB *fb;
2516	#ifdef VBOX_WITH_SDL13
2517	fb = getFbFromWinId(event.motion.windowID);
2518	#else
2519	fb = gpFramebuffer[0];
2520	#endif
2521	SendMouseEvent(fb, 0, 0, 0);
2522	}
2523	break;
2524	}
2525
2526	/*
2527	* A mouse button has been clicked or released.
2528	*/
2529	case SDL_MOUSEBUTTONDOWN:
2530	case SDL_MOUSEBUTTONUP:
2531	{
2532	SDL_MouseButtonEvent *bev = &event.button;
2533	/* don't grab on mouse click if we have guest additions */
2534	if (!gfGrabbed && !UseAbsoluteMouse() && gfGrabOnMouseClick)
2535	{
2536	if (event.type == SDL_MOUSEBUTTONDOWN && (bev->state & SDL_BUTTON_LMASK))
2537	{
2538	/* start grabbing all events */
2539	InputGrabStart();
2540	}
2541	}
2542	else if (gfGrabbed \|\| UseAbsoluteMouse())
2543	{
2544	int dz = bev->button == SDL_BUTTON_WHEELUP
2545	? -1
2546	: bev->button == SDL_BUTTON_WHEELDOWN
2547	? +1
2548	: 0;
2549
2550	/* end host key combination (CTRL+MouseButton) */
2551	switch (enmHKeyState)
2552	{
2553	case HKEYSTATE_DOWN_1ST:
2554	case HKEYSTATE_DOWN_2ND:
2555	enmHKeyState = HKEYSTATE_NOT_IT;
2556	ProcessKey(&EvHKeyDown1.key);
2557	/* ugly hack: small delay to ensure that the key event is
2558	* actually handled _prior_ to the mouse click event */
2559	RTThreadSleep(20);
2560	break;
2561	case HKEYSTATE_DOWN:
2562	enmHKeyState = HKEYSTATE_NOT_IT;
2563	ProcessKey(&EvHKeyDown1.key);
2564	if (gHostKeySym2 != SDLK_UNKNOWN)
2565	ProcessKey(&EvHKeyDown2.key);
2566	/* ugly hack: small delay to ensure that the key event is
2567	* actually handled _prior_ to the mouse click event */
2568	RTThreadSleep(20);
2569	break;
2570	default:
2571	break;
2572	}
2573
2574	VBoxSDLFB *fb;
2575	#ifdef VBOX_WITH_SDL13
2576	fb = getFbFromWinId(event.button.windowID);
2577	#else
2578	fb = gpFramebuffer[0];
2579	#endif
2580	SendMouseEvent(fb, dz, event.type == SDL_MOUSEBUTTONDOWN, bev->button);
2581	}
2582	break;
2583	}
2584
2585	/*
2586	* The window has gained or lost focus.
2587	*/
2588	case SDL_ACTIVEEVENT:
2589	{
2590	/*
2591	* There is a strange behaviour in SDL when running without a window
2592	* manager: When SDL_WM_GrabInput(SDL_GRAB_ON) is called we receive two
2593	* consecutive events SDL_ACTIVEEVENTs (input lost, input gained).
2594	* Asking SDL_GetAppState() seems the better choice.
2595	*/
2596	if (gfGrabbed && (SDL_GetAppState() & SDL_APPINPUTFOCUS) == 0)
2597	{
2598	/*
2599	* another window has stolen the (keyboard) input focus
2600	*/
2601	InputGrabEnd();
2602	}
2603	break;
2604	}
2605
2606	/*
2607	* The SDL window was resized
2608	*/
2609	case SDL_VIDEORESIZE:
2610	{
2611	if (gpDisplay)
2612	{
2613	if (gfIgnoreNextResize)
2614	{
2615	gfIgnoreNextResize = FALSE;
2616	break;
2617	}
2618	uResizeWidth = event.resize.w;
2619	#ifdef VBOX_SECURELABEL
2620	if (fSecureLabel)
2621	uResizeHeight = RT_MAX(0, event.resize.h - SECURE_LABEL_HEIGHT);
2622	else
2623	#endif
2624	uResizeHeight = event.resize.h;
2625	if (gSdlResizeTimer)
2626	SDL_RemoveTimer(gSdlResizeTimer);
2627	gSdlResizeTimer = SDL_AddTimer(300, ResizeTimer, NULL);
2628	}
2629	break;
2630	}
2631
2632	/*
2633	* User specific update event.
2634	*/
2635	/** @todo use a common user event handler so that SDL_PeepEvents() won't
2636	* possibly remove other events in the queue!
2637	*/
2638	case SDL_USER_EVENT_UPDATERECT:
2639	{
2640	/*
2641	* Decode event parameters.
2642	*/
2643	ASMAtomicDecS32(&g_cNotifyUpdateEventsPending);
2644	#define DECODEX(event) (int)((intptr_t)(event).user.data1 >> 16)
2645	#define DECODEY(event) (int)((intptr_t)(event).user.data1 & 0xFFFF)
2646	#define DECODEW(event) (int)((intptr_t)(event).user.data2 >> 16)
2647	#define DECODEH(event) (int)((intptr_t)(event).user.data2 & 0xFFFF)
2648	int x = DECODEX(event);
2649	int y = DECODEY(event);
2650	int w = DECODEW(event);
2651	int h = DECODEH(event);
2652	LogFlow(("SDL_USER_EVENT_UPDATERECT: x = %d, y = %d, w = %d, h = %d\n",
2653	x, y, w, h));
2654
2655	Assert(gpFramebuffer[event.user.code]);
2656	gpFramebuffer[event.user.code]->update(x, y, w, h, true /* fGuestRelative */);
2657
2658	#undef DECODEX
2659	#undef DECODEY
2660	#undef DECODEW
2661	#undef DECODEH
2662	break;
2663	}
2664
2665	/*
2666	* User event: Window resize done
2667	*/
2668	case SDL_USER_EVENT_WINDOW_RESIZE_DONE:
2669	{
2670	/**
2671	* @todo This is a workaround for synchronization problems between EMT and the
2672	* SDL main thread. It can happen that the SDL thread already starts a
2673	* new resize operation while the EMT is still busy with the old one
2674	* leading to a deadlock. Therefore we call SetVideoModeHint only once
2675	* when the mouse button was released.
2676	*/
2677	/* communicate the resize event to the guest */
2678	gpDisplay->SetVideoModeHint(0 /=display/, true /=enabled/, false /=changeOrigin/,
2679	0 /=originX/, 0 /=originY/,
2680	uResizeWidth, uResizeHeight, 0 /=don't change bpp/);
2681	break;
2682
2683	}
2684
2685	/*
2686	* User specific resize event.
2687	*/
2688	case SDL_USER_EVENT_RESIZE:
2689	{
2690	LogFlow(("SDL_USER_EVENT_RESIZE\n"));
2691	IFramebuffer *dummyFb;
2692	LONG xOrigin, yOrigin;
2693	gpFramebuffer[event.user.code]->resizeGuest();
2694	/* update xOrigin, yOrigin -> mouse */
2695	rc = gpDisplay->GetFramebuffer(event.user.code, &dummyFb, &xOrigin, &yOrigin);
2696	gpFramebuffer[event.user.code]->setOrigin(xOrigin, yOrigin);
2697	/* notify the display that the resize has been completed */
2698	gpDisplay->ResizeCompleted(event.user.code);
2699	break;
2700	}
2701
2702	#ifdef USE_XPCOM_QUEUE_THREAD
2703	/*
2704	* User specific XPCOM event queue event
2705	*/
2706	case SDL_USER_EVENT_XPCOM_EVENTQUEUE:
2707	{
2708	LogFlow(("SDL_USER_EVENT_XPCOM_EVENTQUEUE: processing XPCOM event queue...\n"));
2709	eventQ->processEventQueue(0);
2710	signalXPCOMEventQueueThread();
2711	break;
2712	}
2713	#endif /* USE_XPCOM_QUEUE_THREAD */
2714
2715	/*
2716	* User specific update title bar notification event
2717	*/
2718	case SDL_USER_EVENT_UPDATE_TITLEBAR:
2719	{
2720	UpdateTitlebar(TITLEBAR_NORMAL);
2721	break;
2722	}
2723
2724	/*
2725	* User specific termination event
2726	*/
2727	case SDL_USER_EVENT_TERMINATE:
2728	{
2729	if (event.user.code != VBOXSDL_TERM_NORMAL)
2730	RTPrintf("Error: VM terminated abnormally!\n");
2731	goto leave;
2732	}
2733
2734	#ifdef VBOX_SECURELABEL
2735	/*
2736	* User specific secure label update event
2737	*/
2738	case SDL_USER_EVENT_SECURELABEL_UPDATE:
2739	{
2740	/*
2741	* Query the new label text
2742	*/
2743	Bstr bstrLabel;
2744	gpMachine->GetExtraData(Bstr(VBOXSDL_SECURELABEL_EXTRADATA).raw(), bstrLabel.asOutParam());
2745	Utf8Str labelUtf8(bstrLabel);
2746	/*
2747	* Now update the label
2748	*/
2749	gpFramebuffer[0]->setSecureLabelText(labelUtf8.c_str());
2750	break;
2751	}
2752	#endif /* VBOX_SECURELABEL */
2753
2754	/*
2755	* User specific pointer shape change event
2756	*/
2757	case SDL_USER_EVENT_POINTER_CHANGE:
2758	{
2759	PointerShapeChangeData data = (PointerShapeChangeData )event.user.data1;
2760	SetPointerShape (data);
2761	delete data;
2762	break;
2763	}
2764
2765	/*
2766	* User specific guest capabilities changed
2767	*/
2768	case SDL_USER_EVENT_GUEST_CAP_CHANGED:
2769	{
2770	HandleGuestCapsChanged();
2771	break;
2772	}
2773
2774	default:
2775	{
2776	LogBird(("unknown SDL event %d\n", event.type));
2777	break;
2778	}
2779	}
2780	}
2781
2782	leave:
2783	if (gpszPidFile)
2784	RTFileDelete(gpszPidFile);
2785
2786	LogFlow(("leaving...\n"));
2787	#if defined(VBOX_WITH_XPCOM) && !defined(RT_OS_DARWIN) && !defined(RT_OS_OS2)
2788	/* make sure the XPCOM event queue thread doesn't do anything harmful */
2789	terminateXPCOMQueueThread();
2790	#endif /* VBOX_WITH_XPCOM */
2791
2792	if (gpVRDEServer)
2793	rc = gpVRDEServer->COMSETTER(Enabled)(FALSE);
2794
2795	/*
2796	* Get the machine state.
2797	*/
2798	if (gpMachine)
2799	gpMachine->COMGETTER(State)(&machineState);
2800	else
2801	machineState = MachineState_Aborted;
2802
2803	/*
2804	* Turn off the VM if it's running
2805	*/
2806	if ( gpConsole
2807	&& ( machineState == MachineState_Running
2808	\|\| machineState == MachineState_Teleporting
2809	\|\| machineState == MachineState_LiveSnapshotting
2810	/** @todo power off paused VMs too? */
2811	)
2812	)
2813	do
2814	{
2815	pConsoleListener->getWrapped()->ignorePowerOffEvents(true);
2816	ComPtr<IProgress> pProgress;
2817	CHECK_ERROR_BREAK(gpConsole, PowerDown(pProgress.asOutParam()));
2818	CHECK_ERROR_BREAK(pProgress, WaitForCompletion(-1));
2819	BOOL completed;
2820	CHECK_ERROR_BREAK(pProgress, COMGETTER(Completed)(&completed));
2821	ASSERT(completed);
2822	LONG hrc;
2823	CHECK_ERROR_BREAK(pProgress, COMGETTER(ResultCode)(&hrc));
2824	if (FAILED(hrc))
2825	{
2826	com::ErrorInfo info;
2827	if (info.isFullAvailable())
2828	PrintError("Failed to power down VM",
2829	info.getText().raw(), info.getComponent().raw());
2830	else
2831	RTPrintf("Failed to power down virtual machine! No error information available (rc = 0x%x).\n", hrc);
2832	break;
2833	}
2834	} while (0);
2835
2836	/* unregister Console listener */
2837	if (pConsoleListener)
2838	{
2839	ComPtr<IEventSource> pES;
2840	CHECK_ERROR(gpConsole, COMGETTER(EventSource)(pES.asOutParam()));
2841	if (!pES.isNull())
2842	CHECK_ERROR(pES, UnregisterListener(pConsoleListener));
2843	pConsoleListener.setNull();
2844	}
2845
2846	/*
2847	* Now we discard all settings so that our changes will
2848	* not be flushed to the permanent configuration
2849	*/
2850	if ( gpMachine
2851	&& machineState != MachineState_Saved)
2852	{
2853	rc = gpMachine->DiscardSettings();
2854	AssertComRC(rc);
2855	}
2856
2857	/* close the session */
2858	if (sessionOpened)
2859	{
2860	rc = pSession->UnlockMachine();
2861	AssertComRC(rc);
2862	}
2863
2864	#ifndef VBOX_WITH_SDL13
2865	/* restore the default cursor and free the custom one if any */
2866	if (gpDefaultCursor)
2867	{
2868	# ifdef VBOXSDL_WITH_X11
2869	Cursor pDefaultTempX11Cursor = 0;
2870	if (gfXCursorEnabled)
2871	{
2872	pDefaultTempX11Cursor = (Cursor)gpDefaultCursor->wm_cursor;
2873	(Cursor)gpDefaultCursor->wm_cursor = gpDefaultOrigX11Cursor;
2874	}
2875	# endif /* VBOXSDL_WITH_X11 */
2876	SDL_SetCursor(gpDefaultCursor);
2877	# if defined(VBOXSDL_WITH_X11) && !defined(VBOX_WITHOUT_XCURSOR)
2878	if (gfXCursorEnabled)
2879	XFreeCursor(gSdlInfo.info.x11.display, pDefaultTempX11Cursor);
2880	# endif /* VBOXSDL_WITH_X11 && !VBOX_WITHOUT_XCURSOR */
2881	}
2882
2883	if (gpCustomCursor)
2884	{
2885	WMcursor *pCustomTempWMCursor = gpCustomCursor->wm_cursor;
2886	gpCustomCursor->wm_cursor = gpCustomOrigWMcursor;
2887	SDL_FreeCursor(gpCustomCursor);
2888	if (pCustomTempWMCursor)
2889	{
2890	# if defined(RT_OS_WINDOWS)
2891	::DestroyCursor((HCURSOR )pCustomTempWMCursor);
2892	# elif defined(VBOXSDL_WITH_X11) && !defined(VBOX_WITHOUT_XCURSOR)
2893	if (gfXCursorEnabled)
2894	XFreeCursor(gSdlInfo.info.x11.display, (Cursor )pCustomTempWMCursor);
2895	# endif /* VBOXSDL_WITH_X11 && !VBOX_WITHOUT_XCURSOR */
2896	free(pCustomTempWMCursor);
2897	}
2898	}
2899	#endif
2900
2901	LogFlow(("Releasing mouse, keyboard, remote desktop server, display, console...\n"));
2902	if (gpDisplay)
2903	{
2904	for (unsigned i = 0; i < gcMonitors; i++)
2905	gpDisplay->SetFramebuffer(i, NULL);
2906	}
2907
2908	gpMouse = NULL;
2909	gpKeyboard = NULL;
2910	gpVRDEServer = NULL;
2911	gpDisplay = NULL;
2912	gpConsole = NULL;
2913	gpMachineDebugger = NULL;
2914	gpProgress = NULL;
2915	// we can only uninitialize SDL here because it is not threadsafe
2916
2917	for (unsigned i = 0; i < gcMonitors; i++)
2918	{
2919	if (gpFramebuffer[i])
2920	{
2921	LogFlow(("Releasing framebuffer...\n"));
2922	gpFramebuffer[i]->Release();
2923	gpFramebuffer[i] = NULL;
2924	}
2925	}
2926
2927	VBoxSDLFB::uninit();
2928
2929	#ifdef VBOX_SECURELABEL
2930	/* must do this after destructing the framebuffer */
2931	if (gLibrarySDL_ttf)
2932	RTLdrClose(gLibrarySDL_ttf);
2933	#endif
2934
2935	/* VirtualBox (server) listener unregistration. */
2936	if (pVBoxListener)
2937	{
2938	ComPtr<IEventSource> pES;
2939	CHECK_ERROR(pVirtualBox, COMGETTER(EventSource)(pES.asOutParam()));
2940	if (!pES.isNull())
2941	CHECK_ERROR(pES, UnregisterListener(pVBoxListener));
2942	pVBoxListener.setNull();
2943	}
2944
2945	/* VirtualBoxClient listener unregistration. */
2946	if (pVBoxClientListener)
2947	{
2948	ComPtr<IEventSource> pES;
2949	CHECK_ERROR(pVirtualBoxClient, COMGETTER(EventSource)(pES.asOutParam()));
2950	if (!pES.isNull())
2951	CHECK_ERROR(pES, UnregisterListener(pVBoxClientListener));
2952	pVBoxClientListener.setNull();
2953	}
2954
2955	LogFlow(("Releasing machine, session...\n"));
2956	gpMachine = NULL;
2957	pSession = NULL;
2958	LogFlow(("Releasing VirtualBox object...\n"));
2959	pVirtualBox = NULL;
2960	LogFlow(("Releasing VirtualBoxClient object...\n"));
2961	pVirtualBoxClient = NULL;
2962
2963	// end "all-stuff" scope
2964	////////////////////////////////////////////////////////////////////////////
2965	}
2966
2967	/* Must be before com::Shutdown() */
2968	LogFlow(("Uninitializing COM...\n"));
2969	com::Shutdown();
2970
2971	LogFlow(("Returning from main()!\n"));
2972	RTLogFlush(NULL);
2973	return FAILED(rc) ? 1 : 0;
2974	}
2975
2976	static RTEXITCODE readPasswordFile(const char pszFilename, com::Utf8Str pPasswd)
2977	{
2978	size_t cbFile;
2979	char szPasswd[512];
2980	int vrc = VINF_SUCCESS;
2981	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
2982	bool fStdIn = !strcmp(pszFilename, "stdin");
2983	PRTSTREAM pStrm;
2984	if (!fStdIn)
2985	vrc = RTStrmOpen(pszFilename, "r", &pStrm);
2986	else
2987	pStrm = g_pStdIn;
2988	if (RT_SUCCESS(vrc))
2989	{
2990	vrc = RTStrmReadEx(pStrm, szPasswd, sizeof(szPasswd)-1, &cbFile);
2991	if (RT_SUCCESS(vrc))
2992	{
2993	if (cbFile >= sizeof(szPasswd)-1)
2994	{
2995	RTPrintf("Provided password in file '%s' is too long\n", pszFilename);
2996	rcExit = RTEXITCODE_FAILURE;
2997	}
2998	else
2999	{
3000	unsigned i;
3001	for (i = 0; i < cbFile && !RT_C_IS_CNTRL(szPasswd[i]); i++)
3002	;
3003	szPasswd[i] = '\0';
3004	*pPasswd = szPasswd;
3005	}
3006	}
3007	else
3008	{
3009	RTPrintf("Cannot read password from file '%s': %Rrc\n", pszFilename, vrc);
3010	rcExit = RTEXITCODE_FAILURE;
3011	}
3012	if (!fStdIn)
3013	RTStrmClose(pStrm);
3014	}
3015	else
3016	{
3017	RTPrintf("Cannot open password file '%s' (%Rrc)\n", pszFilename, vrc);
3018	rcExit = RTEXITCODE_FAILURE;
3019	}
3020
3021	return rcExit;
3022	}
3023
3024	static RTEXITCODE settingsPasswordFile(ComPtr<IVirtualBox> virtualBox, const char *pszFilename)
3025	{
3026	com::Utf8Str passwd;
3027	RTEXITCODE rcExit = readPasswordFile(pszFilename, &passwd);
3028	if (rcExit == RTEXITCODE_SUCCESS)
3029	{
3030	int rc;
3031	CHECK_ERROR(virtualBox, SetSettingsSecret(com::Bstr(passwd).raw()));
3032	if (FAILED(rc))
3033	rcExit = RTEXITCODE_FAILURE;
3034	}
3035
3036	return rcExit;
3037	}
3038
3039	#ifndef VBOX_WITH_HARDENING
3040	/**
3041	* Main entry point
3042	*/
3043	int main(int argc, char **argv)
3044	{
3045	/*
3046	* Before we do anything, we initialize the runtime.
3047	*/
3048	int rc = RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_SUPLIB);
3049	if (RT_FAILURE(rc))
3050	return RTMsgInitFailure(rc);
3051	return TrustedMain(argc, argv, NULL);
3052	}
3053	#endif /* !VBOX_WITH_HARDENING */
3054
3055
3056	/**
3057	* Returns whether the absolute mouse is in use, i.e. both host
3058	* and guest have opted to enable it.
3059	*
3060	* @returns bool Flag whether the absolute mouse is in use
3061	*/
3062	static bool UseAbsoluteMouse(void)
3063	{
3064	return (gfAbsoluteMouseHost && gfAbsoluteMouseGuest);
3065	}
3066
3067	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_OS2)
3068	/**
3069	* Fallback keycode conversion using SDL symbols.
3070	*
3071	* This is used to catch keycodes that's missing from the translation table.
3072	*
3073	* @returns XT scancode
3074	* @param ev SDL scancode
3075	*/
3076	static uint16_t Keyevent2KeycodeFallback(const SDL_KeyboardEvent *ev)
3077	{
3078	const SDLKey sym = ev->keysym.sym;
3079	Log(("SDL key event: sym=%d scancode=%#x unicode=%#x\n",
3080	sym, ev->keysym.scancode, ev->keysym.unicode));
3081	switch (sym)
3082	{ /* set 1 scan code */
3083	case SDLK_ESCAPE: return 0x01;
3084	case SDLK_EXCLAIM:
3085	case SDLK_1: return 0x02;
3086	case SDLK_AT:
3087	case SDLK_2: return 0x03;
3088	case SDLK_HASH:
3089	case SDLK_3: return 0x04;
3090	case SDLK_DOLLAR:
3091	case SDLK_4: return 0x05;
3092	/* % */
3093	case SDLK_5: return 0x06;
3094	case SDLK_CARET:
3095	case SDLK_6: return 0x07;
3096	case SDLK_AMPERSAND:
3097	case SDLK_7: return 0x08;
3098	case SDLK_ASTERISK:
3099	case SDLK_8: return 0x09;
3100	case SDLK_LEFTPAREN:
3101	case SDLK_9: return 0x0a;
3102	case SDLK_RIGHTPAREN:
3103	case SDLK_0: return 0x0b;
3104	case SDLK_UNDERSCORE:
3105	case SDLK_MINUS: return 0x0c;
3106	case SDLK_EQUALS:
3107	case SDLK_PLUS: return 0x0d;
3108	case SDLK_BACKSPACE: return 0x0e;
3109	case SDLK_TAB: return 0x0f;
3110	case SDLK_q: return 0x10;
3111	case SDLK_w: return 0x11;
3112	case SDLK_e: return 0x12;
3113	case SDLK_r: return 0x13;
3114	case SDLK_t: return 0x14;
3115	case SDLK_y: return 0x15;
3116	case SDLK_u: return 0x16;
3117	case SDLK_i: return 0x17;
3118	case SDLK_o: return 0x18;
3119	case SDLK_p: return 0x19;
3120	case SDLK_LEFTBRACKET: return 0x1a;
3121	case SDLK_RIGHTBRACKET: return 0x1b;
3122	case SDLK_RETURN: return 0x1c;
3123	case SDLK_KP_ENTER: return 0x1c \| 0x100;
3124	case SDLK_LCTRL: return 0x1d;
3125	case SDLK_RCTRL: return 0x1d \| 0x100;
3126	case SDLK_a: return 0x1e;
3127	case SDLK_s: return 0x1f;
3128	case SDLK_d: return 0x20;
3129	case SDLK_f: return 0x21;
3130	case SDLK_g: return 0x22;
3131	case SDLK_h: return 0x23;
3132	case SDLK_j: return 0x24;
3133	case SDLK_k: return 0x25;
3134	case SDLK_l: return 0x26;
3135	case SDLK_COLON:
3136	case SDLK_SEMICOLON: return 0x27;
3137	case SDLK_QUOTEDBL:
3138	case SDLK_QUOTE: return 0x28;
3139	case SDLK_BACKQUOTE: return 0x29;
3140	case SDLK_LSHIFT: return 0x2a;
3141	case SDLK_BACKSLASH: return 0x2b;
3142	case SDLK_z: return 0x2c;
3143	case SDLK_x: return 0x2d;
3144	case SDLK_c: return 0x2e;
3145	case SDLK_v: return 0x2f;
3146	case SDLK_b: return 0x30;
3147	case SDLK_n: return 0x31;
3148	case SDLK_m: return 0x32;
3149	case SDLK_LESS:
3150	case SDLK_COMMA: return 0x33;
3151	case SDLK_GREATER:
3152	case SDLK_PERIOD: return 0x34;
3153	case SDLK_KP_DIVIDE: /??/
3154	case SDLK_QUESTION:
3155	case SDLK_SLASH: return 0x35;
3156	case SDLK_RSHIFT: return 0x36;
3157	case SDLK_KP_MULTIPLY:
3158	case SDLK_PRINT: return 0x37; /* fixme */
3159	case SDLK_LALT: return 0x38;
3160	case SDLK_MODE: /* alt gr*/
3161	case SDLK_RALT: return 0x38 \| 0x100;
3162	case SDLK_SPACE: return 0x39;
3163	case SDLK_CAPSLOCK: return 0x3a;
3164	case SDLK_F1: return 0x3b;
3165	case SDLK_F2: return 0x3c;
3166	case SDLK_F3: return 0x3d;
3167	case SDLK_F4: return 0x3e;
3168	case SDLK_F5: return 0x3f;
3169	case SDLK_F6: return 0x40;
3170	case SDLK_F7: return 0x41;
3171	case SDLK_F8: return 0x42;
3172	case SDLK_F9: return 0x43;
3173	case SDLK_F10: return 0x44;
3174	case SDLK_PAUSE: return 0x45; /* not right */
3175	case SDLK_NUMLOCK: return 0x45;
3176	case SDLK_SCROLLOCK: return 0x46;
3177	case SDLK_KP7: return 0x47;
3178	case SDLK_HOME: return 0x47 \| 0x100;
3179	case SDLK_KP8: return 0x48;
3180	case SDLK_UP: return 0x48 \| 0x100;
3181	case SDLK_KP9: return 0x49;
3182	case SDLK_PAGEUP: return 0x49 \| 0x100;
3183	case SDLK_KP_MINUS: return 0x4a;
3184	case SDLK_KP4: return 0x4b;
3185	case SDLK_LEFT: return 0x4b \| 0x100;
3186	case SDLK_KP5: return 0x4c;
3187	case SDLK_KP6: return 0x4d;
3188	case SDLK_RIGHT: return 0x4d \| 0x100;
3189	case SDLK_KP_PLUS: return 0x4e;
3190	case SDLK_KP1: return 0x4f;
3191	case SDLK_END: return 0x4f \| 0x100;
3192	case SDLK_KP2: return 0x50;
3193	case SDLK_DOWN: return 0x50 \| 0x100;
3194	case SDLK_KP3: return 0x51;
3195	case SDLK_PAGEDOWN: return 0x51 \| 0x100;
3196	case SDLK_KP0: return 0x52;
3197	case SDLK_INSERT: return 0x52 \| 0x100;
3198	case SDLK_KP_PERIOD: return 0x53;
3199	case SDLK_DELETE: return 0x53 \| 0x100;
3200	case SDLK_SYSREQ: return 0x54;
3201	case SDLK_F11: return 0x57;
3202	case SDLK_F12: return 0x58;
3203	case SDLK_F13: return 0x5b;
3204	case SDLK_LMETA:
3205	case SDLK_LSUPER: return 0x5b \| 0x100;
3206	case SDLK_F14: return 0x5c;
3207	case SDLK_RMETA:
3208	case SDLK_RSUPER: return 0x5c \| 0x100;
3209	case SDLK_F15: return 0x5d;
3210	case SDLK_MENU: return 0x5d \| 0x100;
3211	#if 0
3212	case SDLK_CLEAR: return 0x;
3213	case SDLK_KP_EQUALS: return 0x;
3214	case SDLK_COMPOSE: return 0x;
3215	case SDLK_HELP: return 0x;
3216	case SDLK_BREAK: return 0x;
3217	case SDLK_POWER: return 0x;
3218	case SDLK_EURO: return 0x;
3219	case SDLK_UNDO: return 0x;
3220	#endif
3221	default:
3222	Log(("Unhandled sdl key event: sym=%d scancode=%#x unicode=%#x\n",
3223	ev->keysym.sym, ev->keysym.scancode, ev->keysym.unicode));
3224	return 0;
3225	}
3226	}
3227	#endif /* RT_OS_DARWIN */
3228
3229	/**
3230	* Converts an SDL keyboard eventcode to a XT scancode.
3231	*
3232	* @returns XT scancode
3233	* @param ev SDL scancode
3234	*/
3235	static uint16_t Keyevent2Keycode(const SDL_KeyboardEvent *ev)
3236	{
3237	// start with the scancode determined by SDL
3238	int keycode = ev->keysym.scancode;
3239
3240	#ifdef VBOXSDL_WITH_X11
3241	# ifdef VBOX_WITH_SDL13
3242
3243	switch (ev->keysym.sym)
3244	{
3245	case SDLK_ESCAPE: return 0x01;
3246	case SDLK_EXCLAIM:
3247	case SDLK_1: return 0x02;
3248	case SDLK_AT:
3249	case SDLK_2: return 0x03;
3250	case SDLK_HASH:
3251	case SDLK_3: return 0x04;
3252	case SDLK_DOLLAR:
3253	case SDLK_4: return 0x05;
3254	/* % */
3255	case SDLK_5: return 0x06;
3256	case SDLK_CARET:
3257	case SDLK_6: return 0x07;
3258	case SDLK_AMPERSAND:
3259	case SDLK_7: return 0x08;
3260	case SDLK_ASTERISK:
3261	case SDLK_8: return 0x09;
3262	case SDLK_LEFTPAREN:
3263	case SDLK_9: return 0x0a;
3264	case SDLK_RIGHTPAREN:
3265	case SDLK_0: return 0x0b;
3266	case SDLK_UNDERSCORE:
3267	case SDLK_MINUS: return 0x0c;
3268	case SDLK_PLUS: return 0x0d;
3269	case SDLK_BACKSPACE: return 0x0e;
3270	case SDLK_TAB: return 0x0f;
3271	case SDLK_q: return 0x10;
3272	case SDLK_w: return 0x11;
3273	case SDLK_e: return 0x12;
3274	case SDLK_r: return 0x13;
3275	case SDLK_t: return 0x14;
3276	case SDLK_y: return 0x15;
3277	case SDLK_u: return 0x16;
3278	case SDLK_i: return 0x17;
3279	case SDLK_o: return 0x18;
3280	case SDLK_p: return 0x19;
3281	case SDLK_RETURN: return 0x1c;
3282	case SDLK_KP_ENTER: return 0x1c \| 0x100;
3283	case SDLK_LCTRL: return 0x1d;
3284	case SDLK_RCTRL: return 0x1d \| 0x100;
3285	case SDLK_a: return 0x1e;
3286	case SDLK_s: return 0x1f;
3287	case SDLK_d: return 0x20;
3288	case SDLK_f: return 0x21;
3289	case SDLK_g: return 0x22;
3290	case SDLK_h: return 0x23;
3291	case SDLK_j: return 0x24;
3292	case SDLK_k: return 0x25;
3293	case SDLK_l: return 0x26;
3294	case SDLK_COLON: return 0x27;
3295	case SDLK_QUOTEDBL:
3296	case SDLK_QUOTE: return 0x28;
3297	case SDLK_BACKQUOTE: return 0x29;
3298	case SDLK_LSHIFT: return 0x2a;
3299	case SDLK_z: return 0x2c;
3300	case SDLK_x: return 0x2d;
3301	case SDLK_c: return 0x2e;
3302	case SDLK_v: return 0x2f;
3303	case SDLK_b: return 0x30;
3304	case SDLK_n: return 0x31;
3305	case SDLK_m: return 0x32;
3306	case SDLK_LESS: return 0x33;
3307	case SDLK_GREATER: return 0x34;
3308	case SDLK_KP_DIVIDE: /??/
3309	case SDLK_QUESTION: return 0x35;
3310	case SDLK_RSHIFT: return 0x36;
3311	case SDLK_KP_MULTIPLY:
3312	case SDLK_PRINT: return 0x37; /* fixme */
3313	case SDLK_LALT: return 0x38;
3314	case SDLK_MODE: /* alt gr*/
3315	case SDLK_RALT: return 0x38 \| 0x100;
3316	case SDLK_SPACE: return 0x39;
3317	case SDLK_CAPSLOCK: return 0x3a;
3318	case SDLK_F1: return 0x3b;
3319	case SDLK_F2: return 0x3c;
3320	case SDLK_F3: return 0x3d;
3321	case SDLK_F4: return 0x3e;
3322	case SDLK_F5: return 0x3f;
3323	case SDLK_F6: return 0x40;
3324	case SDLK_F7: return 0x41;
3325	case SDLK_F8: return 0x42;
3326	case SDLK_F9: return 0x43;
3327	case SDLK_F10: return 0x44;
3328	case SDLK_PAUSE: return 0x45; /* not right */
3329	case SDLK_NUMLOCK: return 0x45;
3330	case SDLK_SCROLLOCK: return 0x46;
3331	case SDLK_KP7: return 0x47;
3332	case SDLK_HOME: return 0x47 \| 0x100;
3333	case SDLK_KP8: return 0x48;
3334	case SDLK_UP: return 0x48 \| 0x100;
3335	case SDLK_KP9: return 0x49;
3336	case SDLK_PAGEUP: return 0x49 \| 0x100;
3337	case SDLK_KP_MINUS: return 0x4a;
3338	case SDLK_KP4: return 0x4b;
3339	case SDLK_LEFT: return 0x4b \| 0x100;
3340	case SDLK_KP5: return 0x4c;
3341	case SDLK_KP6: return 0x4d;
3342	case SDLK_RIGHT: return 0x4d \| 0x100;
3343	case SDLK_KP_PLUS: return 0x4e;
3344	case SDLK_KP1: return 0x4f;
3345	case SDLK_END: return 0x4f \| 0x100;
3346	case SDLK_KP2: return 0x50;
3347	case SDLK_DOWN: return 0x50 \| 0x100;
3348	case SDLK_KP3: return 0x51;
3349	case SDLK_PAGEDOWN: return 0x51 \| 0x100;
3350	case SDLK_KP0: return 0x52;
3351	case SDLK_INSERT: return 0x52 \| 0x100;
3352	case SDLK_KP_PERIOD: return 0x53;
3353	case SDLK_DELETE: return 0x53 \| 0x100;
3354	case SDLK_SYSREQ: return 0x54;
3355	case SDLK_F11: return 0x57;
3356	case SDLK_F12: return 0x58;
3357	case SDLK_F13: return 0x5b;
3358	case SDLK_F14: return 0x5c;
3359	case SDLK_F15: return 0x5d;
3360	case SDLK_MENU: return 0x5d \| 0x100;
3361	default:
3362	return 0;
3363	}
3364	# else
3365	keycode = X11DRV_KeyEvent(gSdlInfo.info.x11.display, keycode);
3366	# endif
3367	#elif defined(RT_OS_DARWIN)
3368	/* This is derived partially from SDL_QuartzKeys.h and partially from testing. */
3369	static const uint16_t s_aMacToSet1[] =
3370	{
3371	/* set-1 SDL_QuartzKeys.h */
3372	0x1e, /* QZ_a 0x00 */
3373	0x1f, /* QZ_s 0x01 */
3374	0x20, /* QZ_d 0x02 */
3375	0x21, /* QZ_f 0x03 */
3376	0x23, /* QZ_h 0x04 */
3377	0x22, /* QZ_g 0x05 */
3378	0x2c, /* QZ_z 0x06 */
3379	0x2d, /* QZ_x 0x07 */
3380	0x2e, /* QZ_c 0x08 */
3381	0x2f, /* QZ_v 0x09 */
3382	0x56, /* between lshift and z. 'INT 1'? */
3383	0x30, /* QZ_b 0x0B */
3384	0x10, /* QZ_q 0x0C */
3385	0x11, /* QZ_w 0x0D */
3386	0x12, /* QZ_e 0x0E */
3387	0x13, /* QZ_r 0x0F */
3388	0x15, /* QZ_y 0x10 */
3389	0x14, /* QZ_t 0x11 */
3390	0x02, /* QZ_1 0x12 */
3391	0x03, /* QZ_2 0x13 */
3392	0x04, /* QZ_3 0x14 */
3393	0x05, /* QZ_4 0x15 */
3394	0x07, /* QZ_6 0x16 */
3395	0x06, /* QZ_5 0x17 */
3396	0x0d, /* QZ_EQUALS 0x18 */
3397	0x0a, /* QZ_9 0x19 */
3398	0x08, /* QZ_7 0x1A */
3399	0x0c, /* QZ_MINUS 0x1B */
3400	0x09, /* QZ_8 0x1C */
3401	0x0b, /* QZ_0 0x1D */
3402	0x1b, /* QZ_RIGHTBRACKET 0x1E */
3403	0x18, /* QZ_o 0x1F */
3404	0x16, /* QZ_u 0x20 */
3405	0x1a, /* QZ_LEFTBRACKET 0x21 */
3406	0x17, /* QZ_i 0x22 */
3407	0x19, /* QZ_p 0x23 */
3408	0x1c, /* QZ_RETURN 0x24 */
3409	0x26, /* QZ_l 0x25 */
3410	0x24, /* QZ_j 0x26 */
3411	0x28, /* QZ_QUOTE 0x27 */
3412	0x25, /* QZ_k 0x28 */
3413	0x27, /* QZ_SEMICOLON 0x29 */
3414	0x2b, /* QZ_BACKSLASH 0x2A */
3415	0x33, /* QZ_COMMA 0x2B */
3416	0x35, /* QZ_SLASH 0x2C */
3417	0x31, /* QZ_n 0x2D */
3418	0x32, /* QZ_m 0x2E */
3419	0x34, /* QZ_PERIOD 0x2F */
3420	0x0f, /* QZ_TAB 0x30 */
3421	0x39, /* QZ_SPACE 0x31 */
3422	0x29, /* QZ_BACKQUOTE 0x32 */
3423	0x0e, /* QZ_BACKSPACE 0x33 */
3424	0x9c, /* QZ_IBOOK_ENTER 0x34 */
3425	0x01, /* QZ_ESCAPE 0x35 */
3426	0x5c\|0x100, /* QZ_RMETA 0x36 */
3427	0x5b\|0x100, /* QZ_LMETA 0x37 */
3428	0x2a, /* QZ_LSHIFT 0x38 */
3429	0x3a, /* QZ_CAPSLOCK 0x39 */
3430	0x38, /* QZ_LALT 0x3A */
3431	0x1d, /* QZ_LCTRL 0x3B */
3432	0x36, /* QZ_RSHIFT 0x3C */
3433	0x38\|0x100, /* QZ_RALT 0x3D */
3434	0x1d\|0x100, /* QZ_RCTRL 0x3E */
3435	0, /* */
3436	0, /* */
3437	0x53, /* QZ_KP_PERIOD 0x41 */
3438	0, /* */
3439	0x37, /* QZ_KP_MULTIPLY 0x43 */
3440	0, /* */
3441	0x4e, /* QZ_KP_PLUS 0x45 */
3442	0, /* */
3443	0x45, /* QZ_NUMLOCK 0x47 */
3444	0, /* */
3445	0, /* */
3446	0, /* */
3447	0x35\|0x100, /* QZ_KP_DIVIDE 0x4B */
3448	0x1c\|0x100, /* QZ_KP_ENTER 0x4C */
3449	0, /* */
3450	0x4a, /* QZ_KP_MINUS 0x4E */
3451	0, /* */
3452	0, /* */
3453	0x0d/?/, /* QZ_KP_EQUALS 0x51 */
3454	0x52, /* QZ_KP0 0x52 */
3455	0x4f, /* QZ_KP1 0x53 */
3456	0x50, /* QZ_KP2 0x54 */
3457	0x51, /* QZ_KP3 0x55 */
3458	0x4b, /* QZ_KP4 0x56 */
3459	0x4c, /* QZ_KP5 0x57 */
3460	0x4d, /* QZ_KP6 0x58 */
3461	0x47, /* QZ_KP7 0x59 */
3462	0, /* */
3463	0x48, /* QZ_KP8 0x5B */
3464	0x49, /* QZ_KP9 0x5C */
3465	0, /* */
3466	0, /* */
3467	0, /* */
3468	0x3f, /* QZ_F5 0x60 */
3469	0x40, /* QZ_F6 0x61 */
3470	0x41, /* QZ_F7 0x62 */
3471	0x3d, /* QZ_F3 0x63 */
3472	0x42, /* QZ_F8 0x64 */
3473	0x43, /* QZ_F9 0x65 */
3474	0, /* */
3475	0x57, /* QZ_F11 0x67 */
3476	0, /* */
3477	0x37\|0x100, /* QZ_PRINT / F13 0x69 */
3478	0x63, /* QZ_F16 0x6A */
3479	0x46, /* QZ_SCROLLOCK 0x6B */
3480	0, /* */
3481	0x44, /* QZ_F10 0x6D */
3482	0x5d\|0x100, /* */
3483	0x58, /* QZ_F12 0x6F */
3484	0, /* */
3485	0/* 0xe1,0x1d,0x45/, / QZ_PAUSE 0x71 */
3486	0x52\|0x100, /* QZ_INSERT / HELP 0x72 */
3487	0x47\|0x100, /* QZ_HOME 0x73 */
3488	0x49\|0x100, /* QZ_PAGEUP 0x74 */
3489	0x53\|0x100, /* QZ_DELETE 0x75 */
3490	0x3e, /* QZ_F4 0x76 */
3491	0x4f\|0x100, /* QZ_END 0x77 */
3492	0x3c, /* QZ_F2 0x78 */
3493	0x51\|0x100, /* QZ_PAGEDOWN 0x79 */
3494	0x3b, /* QZ_F1 0x7A */
3495	0x4b\|0x100, /* QZ_LEFT 0x7B */
3496	0x4d\|0x100, /* QZ_RIGHT 0x7C */
3497	0x50\|0x100, /* QZ_DOWN 0x7D */
3498	0x48\|0x100, /* QZ_UP 0x7E */
3499	0x5e\|0x100, /* QZ_POWER 0x7F / / have different break key! */
3500	};
3501
3502	if (keycode == 0)
3503	{
3504	/* This could be a modifier or it could be 'a'. */
3505	switch (ev->keysym.sym)
3506	{
3507	case SDLK_LSHIFT: keycode = 0x2a; break;
3508	case SDLK_RSHIFT: keycode = 0x36; break;
3509	case SDLK_LCTRL: keycode = 0x1d; break;
3510	case SDLK_RCTRL: keycode = 0x1d \| 0x100; break;
3511	case SDLK_LALT: keycode = 0x38; break;
3512	case SDLK_MODE: /* alt gr */
3513	case SDLK_RALT: keycode = 0x38 \| 0x100; break;
3514	case SDLK_RMETA:
3515	case SDLK_RSUPER: keycode = 0x5c \| 0x100; break;
3516	case SDLK_LMETA:
3517	case SDLK_LSUPER: keycode = 0x5b \| 0x100; break;
3518	/* Assumes normal key. */
3519	default: keycode = s_aMacToSet1[keycode]; break;
3520	}
3521	}
3522	else
3523	{
3524	if ((unsigned)keycode < RT_ELEMENTS(s_aMacToSet1))
3525	keycode = s_aMacToSet1[keycode];
3526	else
3527	keycode = 0;
3528	if (!keycode)
3529	{
3530	#ifdef DEBUG_bird
3531	RTPrintf("Untranslated: keycode=%#x (%d)\n", keycode, keycode);
3532	#endif
3533	keycode = Keyevent2KeycodeFallback(ev);
3534	}
3535	}
3536	#ifdef DEBUG_bird
3537	RTPrintf("scancode=%#x -> %#x\n", ev->keysym.scancode, keycode);
3538	#endif
3539
3540	#elif RT_OS_OS2
3541	keycode = Keyevent2KeycodeFallback(ev);
3542	#endif /* RT_OS_DARWIN */
3543	return keycode;
3544	}
3545
3546	/**
3547	* Releases any modifier keys that are currently in pressed state.
3548	*/
3549	static void ResetKeys(void)
3550	{
3551	int i;
3552
3553	if (!gpKeyboard)
3554	return;
3555
3556	for(i = 0; i < 256; i++)
3557	{
3558	if (gaModifiersState[i])
3559	{
3560	if (i & 0x80)
3561	gpKeyboard->PutScancode(0xe0);
3562	gpKeyboard->PutScancode(i \| 0x80);
3563	gaModifiersState[i] = 0;
3564	}
3565	}
3566	}
3567
3568	/**
3569	* Keyboard event handler.
3570	*
3571	* @param ev SDL keyboard event.
3572	*/
3573	static void ProcessKey(SDL_KeyboardEvent *ev)
3574	{
3575	#if (defined(DEBUG) \|\| defined(VBOX_WITH_STATISTICS)) && !defined(VBOX_WITH_SDL13)
3576	if (gpMachineDebugger && ev->type == SDL_KEYDOWN)
3577	{
3578	// first handle the debugger hotkeys
3579	uint8_t *keystate = SDL_GetKeyState(NULL);
3580	#if 0
3581	// CTRL+ALT+Fn is not free on Linux hosts with Xorg ..
3582	if (keystate[SDLK_LALT] && !keystate[SDLK_LCTRL])
3583	#else
3584	if (keystate[SDLK_LALT] && keystate[SDLK_LCTRL])
3585	#endif
3586	{
3587	switch (ev->keysym.sym)
3588	{
3589	// pressing CTRL+ALT+F11 dumps the statistics counter
3590	case SDLK_F12:
3591	RTPrintf("ResetStats\n"); /* Visual feedback in console window */
3592	gpMachineDebugger->ResetStats(NULL);
3593	break;
3594	// pressing CTRL+ALT+F12 resets all statistics counter
3595	case SDLK_F11:
3596	gpMachineDebugger->DumpStats(NULL);
3597	RTPrintf("DumpStats\n"); /* Vistual feedback in console window */
3598	break;
3599	default:
3600	break;
3601	}
3602	}
3603	#if 1
3604	else if (keystate[SDLK_LALT] && !keystate[SDLK_LCTRL])
3605	{
3606	switch (ev->keysym.sym)
3607	{
3608	// pressing Alt-F12 toggles the supervisor recompiler
3609	case SDLK_F12:
3610	{
3611	BOOL recompileSupervisor;
3612	gpMachineDebugger->COMGETTER(RecompileSupervisor)(&recompileSupervisor);
3613	gpMachineDebugger->COMSETTER(RecompileSupervisor)(!recompileSupervisor);
3614	break;
3615	}
3616	// pressing Alt-F11 toggles the user recompiler
3617	case SDLK_F11:
3618	{
3619	BOOL recompileUser;
3620	gpMachineDebugger->COMGETTER(RecompileUser)(&recompileUser);
3621	gpMachineDebugger->COMSETTER(RecompileUser)(!recompileUser);
3622	break;
3623	}
3624	// pressing Alt-F10 toggles the patch manager
3625	case SDLK_F10:
3626	{
3627	BOOL patmEnabled;
3628	gpMachineDebugger->COMGETTER(PATMEnabled)(&patmEnabled);
3629	gpMachineDebugger->COMSETTER(PATMEnabled)(!patmEnabled);
3630	break;
3631	}
3632	// pressing Alt-F9 toggles CSAM
3633	case SDLK_F9:
3634	{
3635	BOOL csamEnabled;
3636	gpMachineDebugger->COMGETTER(CSAMEnabled)(&csamEnabled);
3637	gpMachineDebugger->COMSETTER(CSAMEnabled)(!csamEnabled);
3638	break;
3639	}
3640	// pressing Alt-F8 toggles singlestepping mode
3641	case SDLK_F8:
3642	{
3643	BOOL singlestepEnabled;
3644	gpMachineDebugger->COMGETTER(SingleStep)(&singlestepEnabled);
3645	gpMachineDebugger->COMSETTER(SingleStep)(!singlestepEnabled);
3646	break;
3647	}
3648	default:
3649	break;
3650	}
3651	}
3652	#endif
3653	// pressing Ctrl-F12 toggles the logger
3654	else if ((keystate[SDLK_RCTRL] \|\| keystate[SDLK_LCTRL]) && ev->keysym.sym == SDLK_F12)
3655	{
3656	BOOL logEnabled = TRUE;
3657	gpMachineDebugger->COMGETTER(LogEnabled)(&logEnabled);
3658	gpMachineDebugger->COMSETTER(LogEnabled)(!logEnabled);
3659	#ifdef DEBUG_bird
3660	return;
3661	#endif
3662	}
3663	// pressing F12 sets a logmark
3664	else if (ev->keysym.sym == SDLK_F12)
3665	{
3666	RTLogPrintf("**** LOGGING MARK ****\n");
3667	RTLogFlush(NULL);
3668	}
3669	// now update the titlebar flags
3670	UpdateTitlebar(TITLEBAR_NORMAL);
3671	}
3672	#endif // DEBUG \|\| VBOX_WITH_STATISTICS
3673
3674	// the pause key is the weirdest, needs special handling
3675	if (ev->keysym.sym == SDLK_PAUSE)
3676	{
3677	int v = 0;
3678	if (ev->type == SDL_KEYUP)
3679	v \|= 0x80;
3680	gpKeyboard->PutScancode(0xe1);
3681	gpKeyboard->PutScancode(0x1d \| v);
3682	gpKeyboard->PutScancode(0x45 \| v);
3683	return;
3684	}
3685
3686	/*
3687	* Perform SDL key event to scancode conversion
3688	*/
3689	int keycode = Keyevent2Keycode(ev);
3690
3691	switch(keycode)
3692	{
3693	case 0x00:
3694	{
3695	/* sent when leaving window: reset the modifiers state */
3696	ResetKeys();
3697	return;
3698	}
3699
3700	case 0x2a: /* Left Shift */
3701	case 0x36: /* Right Shift */
3702	case 0x1d: /* Left CTRL */
3703	case 0x1d\|0x100: /* Right CTRL */
3704	case 0x38: /* Left ALT */
3705	case 0x38\|0x100: /* Right ALT */
3706	{
3707	if (ev->type == SDL_KEYUP)
3708	gaModifiersState[keycode & ~0x100] = 0;
3709	else
3710	gaModifiersState[keycode & ~0x100] = 1;
3711	break;
3712	}
3713
3714	case 0x45: /* Num Lock */
3715	case 0x3a: /* Caps Lock */
3716	{
3717	/*
3718	* SDL generates a KEYDOWN event if the lock key is active and a KEYUP event
3719	* if the lock key is inactive. See SDL_DISABLE_LOCK_KEYS.
3720	*/
3721	if (ev->type == SDL_KEYDOWN \|\| ev->type == SDL_KEYUP)
3722	{
3723	gpKeyboard->PutScancode(keycode);
3724	gpKeyboard->PutScancode(keycode \| 0x80);
3725	}
3726	return;
3727	}
3728	}
3729
3730	if (ev->type != SDL_KEYDOWN)
3731	{
3732	/*
3733	* Some keyboards (e.g. the one of mine T60) don't send a NumLock scan code on every
3734	* press of the key. Both the guest and the host should agree on the NumLock state.
3735	* If they differ, we try to alter the guest NumLock state by sending the NumLock key
3736	* scancode. We will get a feedback through the KBD_CMD_SET_LEDS command if the guest
3737	* tries to set/clear the NumLock LED. If a (silly) guest doesn't change the LED, don't
3738	* bother him with NumLock scancodes. At least our BIOS, Linux and Windows handle the
3739	* NumLock LED well.
3740	*/
3741	if ( gcGuestNumLockAdaptions
3742	&& (gfGuestNumLockPressed ^ !!(SDL_GetModState() & KMOD_NUM)))
3743	{
3744	gcGuestNumLockAdaptions--;
3745	gpKeyboard->PutScancode(0x45);
3746	gpKeyboard->PutScancode(0x45 \| 0x80);
3747	}
3748	if ( gcGuestCapsLockAdaptions
3749	&& (gfGuestCapsLockPressed ^ !!(SDL_GetModState() & KMOD_CAPS)))
3750	{
3751	gcGuestCapsLockAdaptions--;
3752	gpKeyboard->PutScancode(0x3a);
3753	gpKeyboard->PutScancode(0x3a \| 0x80);
3754	}
3755	}
3756
3757	/*
3758	* Now we send the event. Apply extended and release prefixes.
3759	*/
3760	if (keycode & 0x100)
3761	gpKeyboard->PutScancode(0xe0);
3762
3763	gpKeyboard->PutScancode(ev->type == SDL_KEYUP ? (keycode & 0x7f) \| 0x80
3764	: (keycode & 0x7f));
3765	}
3766
3767	#ifdef RT_OS_DARWIN
3768	#include <Carbon/Carbon.h>
3769	RT_C_DECLS_BEGIN
3770	/* Private interface in 10.3 and later. */
3771	typedef int CGSConnection;
3772	typedef enum
3773	{
3774	kCGSGlobalHotKeyEnable = 0,
3775	kCGSGlobalHotKeyDisable,
3776	kCGSGlobalHotKeyInvalid = -1 /* bird */
3777	} CGSGlobalHotKeyOperatingMode;
3778	extern CGSConnection _CGSDefaultConnection(void);
3779	extern CGError CGSGetGlobalHotKeyOperatingMode(CGSConnection Connection, CGSGlobalHotKeyOperatingMode *enmMode);
3780	extern CGError CGSSetGlobalHotKeyOperatingMode(CGSConnection Connection, CGSGlobalHotKeyOperatingMode enmMode);
3781	RT_C_DECLS_END
3782
3783	/** Keeping track of whether we disabled the hotkeys or not. */
3784	static bool g_fHotKeysDisabled = false;
3785	/** Whether we've connected or not. */
3786	static bool g_fConnectedToCGS = false;
3787	/** Cached connection. */
3788	static CGSConnection g_CGSConnection;
3789
3790	/**
3791	* Disables or enabled global hot keys.
3792	*/
3793	static void DisableGlobalHotKeys(bool fDisable)
3794	{
3795	if (!g_fConnectedToCGS)
3796	{
3797	g_CGSConnection = _CGSDefaultConnection();
3798	g_fConnectedToCGS = true;
3799	}
3800
3801	/* get current mode. */
3802	CGSGlobalHotKeyOperatingMode enmMode = kCGSGlobalHotKeyInvalid;
3803	CGSGetGlobalHotKeyOperatingMode(g_CGSConnection, &enmMode);
3804
3805	/* calc new mode. */
3806	if (fDisable)
3807	{
3808	if (enmMode != kCGSGlobalHotKeyEnable)
3809	return;
3810	enmMode = kCGSGlobalHotKeyDisable;
3811	}
3812	else
3813	{
3814	if ( enmMode != kCGSGlobalHotKeyDisable
3815	/\|\| !g_fHotKeysDisabled/)
3816	return;
3817	enmMode = kCGSGlobalHotKeyEnable;
3818	}
3819
3820	/* try set it and check the actual result. */
3821	CGSSetGlobalHotKeyOperatingMode(g_CGSConnection, enmMode);
3822	CGSGlobalHotKeyOperatingMode enmNewMode = kCGSGlobalHotKeyInvalid;
3823	CGSGetGlobalHotKeyOperatingMode(g_CGSConnection, &enmNewMode);
3824	if (enmNewMode == enmMode)
3825	g_fHotKeysDisabled = enmMode == kCGSGlobalHotKeyDisable;
3826	}
3827	#endif /* RT_OS_DARWIN */
3828
3829	/**
3830	* Start grabbing the mouse.
3831	*/
3832	static void InputGrabStart(void)
3833	{
3834	#ifdef RT_OS_DARWIN
3835	DisableGlobalHotKeys(true);
3836	#endif
3837	if (!gfGuestNeedsHostCursor && gfRelativeMouseGuest)
3838	SDL_ShowCursor(SDL_DISABLE);
3839	SDL_WM_GrabInput(SDL_GRAB_ON);
3840	// dummy read to avoid moving the mouse
3841	SDL_GetRelativeMouseState(
3842	#ifdef VBOX_WITH_SDL13
3843	0,
3844	#endif
3845	NULL, NULL);
3846	gfGrabbed = TRUE;
3847	UpdateTitlebar(TITLEBAR_NORMAL);
3848	}
3849
3850	/**
3851	* End mouse grabbing.
3852	*/
3853	static void InputGrabEnd(void)
3854	{
3855	SDL_WM_GrabInput(SDL_GRAB_OFF);
3856	if (!gfGuestNeedsHostCursor && gfRelativeMouseGuest)
3857	SDL_ShowCursor(SDL_ENABLE);
3858	#ifdef RT_OS_DARWIN
3859	DisableGlobalHotKeys(false);
3860	#endif
3861	gfGrabbed = FALSE;
3862	UpdateTitlebar(TITLEBAR_NORMAL);
3863	}
3864
3865	/**
3866	* Query mouse position and button state from SDL and send to the VM
3867	*
3868	* @param dz Relative mouse wheel movement
3869	*/
3870	static void SendMouseEvent(VBoxSDLFB *fb, int dz, int down, int button)
3871	{
3872	int x, y, state, buttons;
3873	bool abs;
3874
3875	#ifdef VBOX_WITH_SDL13
3876	if (!fb)
3877	{
3878	SDL_GetMouseState(0, &x, &y);
3879	RTPrintf("MouseEvent: Cannot find fb mouse = %d,%d\n", x, y);
3880	return;
3881	}
3882	#else
3883	AssertRelease(fb != NULL);
3884	#endif
3885
3886	/*
3887	* If supported and we're not in grabbed mode, we'll use the absolute mouse.
3888	* If we are in grabbed mode and the guest is not able to draw the mouse cursor
3889	* itself, or can't handle relative reporting, we have to use absolute
3890	* coordinates, otherwise the host cursor and
3891	* the coordinates the guest thinks the mouse is at could get out-of-sync. From
3892	* the SDL mailing list:
3893	*
3894	* "The event processing is usually asynchronous and so somewhat delayed, and
3895	* SDL_GetMouseState is returning the immediate mouse state. So at the time you
3896	* call SDL_GetMouseState, the "button" is already up."
3897	*/
3898	abs = (UseAbsoluteMouse() && !gfGrabbed)
3899	\|\| gfGuestNeedsHostCursor
3900	\|\| !gfRelativeMouseGuest;
3901
3902	/* only used if abs == TRUE */
3903	int xOrigin = fb->getOriginX();
3904	int yOrigin = fb->getOriginY();
3905	int xMin = fb->getXOffset() + xOrigin;
3906	int yMin = fb->getYOffset() + yOrigin;
3907	int xMax = xMin + (int)fb->getGuestXRes();
3908	int yMax = yMin + (int)fb->getGuestYRes();
3909
3910	state = abs ? SDL_GetMouseState(
3911	#ifdef VBOX_WITH_SDL13
3912	0,
3913	#endif
3914	&x, &y)
3915	: SDL_GetRelativeMouseState(
3916	#ifdef VBOX_WITH_SDL13
3917	0,
3918	#endif
3919	&x, &y);
3920
3921	/*
3922	* process buttons
3923	*/
3924	buttons = 0;
3925	if (state & SDL_BUTTON(SDL_BUTTON_LEFT))
3926	buttons \|= MouseButtonState_LeftButton;
3927	if (state & SDL_BUTTON(SDL_BUTTON_RIGHT))
3928	buttons \|= MouseButtonState_RightButton;
3929	if (state & SDL_BUTTON(SDL_BUTTON_MIDDLE))
3930	buttons \|= MouseButtonState_MiddleButton;
3931
3932	if (abs)
3933	{
3934	x += xOrigin;
3935	y += yOrigin;
3936
3937	/*
3938	* Check if the mouse event is inside the guest area. This solves the
3939	* following problem: Some guests switch off the VBox hardware mouse
3940	* cursor and draw the mouse cursor itself instead. Moving the mouse
3941	* outside the guest area then leads to annoying mouse hangs if we
3942	* don't pass mouse motion events into the guest.
3943	*/
3944	if (x < xMin \|\| y < yMin \|\| x > xMax \|\| y > yMax)
3945	{
3946	/*
3947	* Cursor outside of valid guest area (outside window or in secure
3948	* label area. Don't allow any mouse button press.
3949	*/
3950	button = 0;
3951
3952	/*
3953	* Release any pressed button.
3954	*/
3955	#if 0
3956	/* disabled on customers request */
3957	buttons &= ~(MouseButtonState_LeftButton \|
3958	MouseButtonState_MiddleButton \|
3959	MouseButtonState_RightButton);
3960	#endif
3961
3962	/*
3963	* Prevent negative coordinates.
3964	*/
3965	if (x < xMin) x = xMin;
3966	if (x > xMax) x = xMax;
3967	if (y < yMin) y = yMin;
3968	if (y > yMax) y = yMax;
3969
3970	if (!gpOffCursor)
3971	{
3972	gpOffCursor = SDL_GetCursor(); /* Cursor image */
3973	gfOffCursorActive = SDL_ShowCursor(-1); /* enabled / disabled */
3974	SDL_SetCursor(gpDefaultCursor);
3975	SDL_ShowCursor(SDL_ENABLE);
3976	}
3977	}
3978	else
3979	{
3980	if (gpOffCursor)
3981	{
3982	/*
3983	* We just entered the valid guest area. Restore the guest mouse
3984	* cursor.
3985	*/
3986	SDL_SetCursor(gpOffCursor);
3987	SDL_ShowCursor(gfOffCursorActive ? SDL_ENABLE : SDL_DISABLE);
3988	gpOffCursor = NULL;
3989	}
3990	}
3991	}
3992
3993	/*
3994	* Button was pressed but that press is not reflected in the button state?
3995	*/
3996	if (down && !(state & SDL_BUTTON(button)))
3997	{
3998	/*
3999	* It can happen that a mouse up event follows a mouse down event immediately
4000	* and we see the events when the bit in the button state is already cleared
4001	* again. In that case we simulate the mouse down event.
4002	*/
4003	int tmp_button = 0;
4004	switch (button)
4005	{
4006	case SDL_BUTTON_LEFT: tmp_button = MouseButtonState_LeftButton; break;
4007	case SDL_BUTTON_MIDDLE: tmp_button = MouseButtonState_MiddleButton; break;
4008	case SDL_BUTTON_RIGHT: tmp_button = MouseButtonState_RightButton; break;
4009	}
4010
4011	if (abs)
4012	{
4013	/**
4014	* @todo
4015	* PutMouseEventAbsolute() expects x and y starting from 1,1.
4016	* should we do the increment internally in PutMouseEventAbsolute()
4017	* or state it in PutMouseEventAbsolute() docs?
4018	*/
4019	gpMouse->PutMouseEventAbsolute(x + 1 - xMin + xOrigin,
4020	y + 1 - yMin + yOrigin,
4021	dz, 0 /* horizontal scroll wheel */,
4022	buttons \| tmp_button);
4023	}
4024	else
4025	{
4026	gpMouse->PutMouseEvent(0, 0, dz,
4027	0 /* horizontal scroll wheel */,
4028	buttons \| tmp_button);
4029	}
4030	}
4031
4032	// now send the mouse event
4033	if (abs)
4034	{
4035	/**
4036	* @todo
4037	* PutMouseEventAbsolute() expects x and y starting from 1,1.
4038	* should we do the increment internally in PutMouseEventAbsolute()
4039	* or state it in PutMouseEventAbsolute() docs?
4040	*/
4041	gpMouse->PutMouseEventAbsolute(x + 1 - xMin + xOrigin,
4042	y + 1 - yMin + yOrigin,
4043	dz, 0 /* Horizontal wheel */, buttons);
4044	}
4045	else
4046	{
4047	gpMouse->PutMouseEvent(x, y, dz, 0 /* Horizontal wheel */, buttons);
4048	}
4049	}
4050
4051	/**
4052	* Resets the VM
4053	*/
4054	void ResetVM(void)
4055	{
4056	if (gpConsole)
4057	gpConsole->Reset();
4058	}
4059
4060	/**
4061	* Initiates a saved state and updates the titlebar with progress information
4062	*/
4063	void SaveState(void)
4064	{
4065	ResetKeys();
4066	RTThreadYield();
4067	if (gfGrabbed)
4068	InputGrabEnd();
4069	RTThreadYield();
4070	UpdateTitlebar(TITLEBAR_SAVE);
4071	gpProgress = NULL;
4072	HRESULT rc = gpConsole->SaveState(gpProgress.asOutParam());
4073	if (FAILED(rc))
4074	{
4075	RTPrintf("Error saving state! rc = 0x%x\n", rc);
4076	return;
4077	}
4078	Assert(gpProgress);
4079
4080	/*
4081	* Wait for the operation to be completed and work
4082	* the title bar in the mean while.
4083	*/
4084	ULONG cPercent = 0;
4085	#ifndef RT_OS_DARWIN /* don't break the other guys yet. */
4086	for (;;)
4087	{
4088	BOOL fCompleted = false;
4089	rc = gpProgress->COMGETTER(Completed)(&fCompleted);
4090	if (FAILED(rc) \|\| fCompleted)
4091	break;
4092	ULONG cPercentNow;
4093	rc = gpProgress->COMGETTER(Percent)(&cPercentNow);
4094	if (FAILED(rc))
4095	break;
4096	if (cPercentNow != cPercent)
4097	{
4098	UpdateTitlebar(TITLEBAR_SAVE, cPercent);
4099	cPercent = cPercentNow;
4100	}
4101
4102	/* wait */
4103	rc = gpProgress->WaitForCompletion(100);
4104	if (FAILED(rc))
4105	break;
4106	/// @todo process gui events.
4107	}
4108
4109	#else /* new loop which processes GUI events while saving. */
4110
4111	/* start regular timer so we don't starve in the event loop */
4112	SDL_TimerID sdlTimer;
4113	sdlTimer = SDL_AddTimer(100, StartupTimer, NULL);
4114
4115	for (;;)
4116	{
4117	/*
4118	* Check for completion.
4119	*/
4120	BOOL fCompleted = false;
4121	rc = gpProgress->COMGETTER(Completed)(&fCompleted);
4122	if (FAILED(rc) \|\| fCompleted)
4123	break;
4124	ULONG cPercentNow;
4125	rc = gpProgress->COMGETTER(Percent)(&cPercentNow);
4126	if (FAILED(rc))
4127	break;
4128	if (cPercentNow != cPercent)
4129	{
4130	UpdateTitlebar(TITLEBAR_SAVE, cPercent);
4131	cPercent = cPercentNow;
4132	}
4133
4134	/*
4135	* Wait for and process GUI a event.
4136	* This is necessary for XPCOM IPC and for updating the
4137	* title bar on the Mac.
4138	*/
4139	SDL_Event event;
4140	if (WaitSDLEvent(&event))
4141	{
4142	switch (event.type)
4143	{
4144	/*
4145	* Timer event preventing us from getting stuck.
4146	*/
4147	case SDL_USER_EVENT_TIMER:
4148	break;
4149
4150	#ifdef USE_XPCOM_QUEUE_THREAD
4151	/*
4152	* User specific XPCOM event queue event
4153	*/
4154	case SDL_USER_EVENT_XPCOM_EVENTQUEUE:
4155	{
4156	LogFlow(("SDL_USER_EVENT_XPCOM_EVENTQUEUE: processing XPCOM event queue...\n"));
4157	eventQ->ProcessPendingEvents();
4158	signalXPCOMEventQueueThread();
4159	break;
4160	}
4161	#endif /* USE_XPCOM_QUEUE_THREAD */
4162
4163
4164	/*
4165	* Ignore all other events.
4166	*/
4167	case SDL_USER_EVENT_RESIZE:
4168	case SDL_USER_EVENT_TERMINATE:
4169	default:
4170	break;
4171	}
4172	}
4173	}
4174
4175	/* kill the timer */
4176	SDL_RemoveTimer(sdlTimer);
4177	sdlTimer = 0;
4178
4179	#endif /* RT_OS_DARWIN */
4180
4181	/*
4182	* What's the result of the operation?
4183	*/
4184	LONG lrc;
4185	rc = gpProgress->COMGETTER(ResultCode)(&lrc);
4186	if (FAILED(rc))
4187	lrc = ~0;
4188	if (!lrc)
4189	{
4190	UpdateTitlebar(TITLEBAR_SAVE, 100);
4191	RTThreadYield();
4192	RTPrintf("Saved the state successfully.\n");
4193	}
4194	else
4195	RTPrintf("Error saving state, lrc=%d (%#x)\n", lrc, lrc);
4196	}
4197
4198	/**
4199	* Build the titlebar string
4200	*/
4201	static void UpdateTitlebar(TitlebarMode mode, uint32_t u32User)
4202	{
4203	static char szTitle[1024] = {0};
4204
4205	/* back up current title */
4206	char szPrevTitle[1024];
4207	strcpy(szPrevTitle, szTitle);
4208
4209	Bstr bstrName;
4210	gpMachine->COMGETTER(Name)(bstrName.asOutParam());
4211
4212	RTStrPrintf(szTitle, sizeof(szTitle), "%s - " VBOX_PRODUCT,
4213	!bstrName.isEmpty() ? Utf8Str(bstrName).c_str() : "<noname>");
4214
4215	/* which mode are we in? */
4216	switch (mode)
4217	{
4218	case TITLEBAR_NORMAL:
4219	{
4220	MachineState_T machineState;
4221	gpMachine->COMGETTER(State)(&machineState);
4222	if (machineState == MachineState_Paused)
4223	RTStrPrintf(szTitle + strlen(szTitle), sizeof(szTitle) - strlen(szTitle), " - [Paused]");
4224
4225	if (gfGrabbed)
4226	RTStrPrintf(szTitle + strlen(szTitle), sizeof(szTitle) - strlen(szTitle), " - [Input captured]");
4227
4228	#if defined(DEBUG) \|\| defined(VBOX_WITH_STATISTICS)
4229	// do we have a debugger interface
4230	if (gpMachineDebugger)
4231	{
4232	// query the machine state
4233	BOOL recompileSupervisor = FALSE;
4234	BOOL recompileUser = FALSE;
4235	BOOL patmEnabled = FALSE;
4236	BOOL csamEnabled = FALSE;
4237	BOOL singlestepEnabled = FALSE;
4238	BOOL logEnabled = FALSE;
4239	BOOL hwVirtEnabled = FALSE;
4240	ULONG virtualTimeRate = 100;
4241	gpMachineDebugger->COMGETTER(RecompileSupervisor)(&recompileSupervisor);
4242	gpMachineDebugger->COMGETTER(RecompileUser)(&recompileUser);
4243	gpMachineDebugger->COMGETTER(PATMEnabled)(&patmEnabled);
4244	gpMachineDebugger->COMGETTER(CSAMEnabled)(&csamEnabled);
4245	gpMachineDebugger->COMGETTER(LogEnabled)(&logEnabled);
4246	gpMachineDebugger->COMGETTER(SingleStep)(&singlestepEnabled);
4247	gpMachineDebugger->COMGETTER(HWVirtExEnabled)(&hwVirtEnabled);
4248	gpMachineDebugger->COMGETTER(VirtualTimeRate)(&virtualTimeRate);
4249	RTStrPrintf(szTitle + strlen(szTitle), sizeof(szTitle) - strlen(szTitle),
4250	" [STEP=%d CS=%d PAT=%d RR0=%d RR3=%d LOG=%d HWVirt=%d",
4251	singlestepEnabled == TRUE, csamEnabled == TRUE, patmEnabled == TRUE,
4252	recompileSupervisor == FALSE, recompileUser == FALSE,
4253	logEnabled == TRUE, hwVirtEnabled == TRUE);
4254	char *psz = strchr(szTitle, '\0');
4255	if (virtualTimeRate != 100)
4256	RTStrPrintf(psz, &szTitle[sizeof(szTitle)] - psz, " WD=%d%%]", virtualTimeRate);
4257	else
4258	RTStrPrintf(psz, &szTitle[sizeof(szTitle)] - psz, "]");
4259	}
4260	#endif /* DEBUG \|\| VBOX_WITH_STATISTICS */
4261	break;
4262	}
4263
4264	case TITLEBAR_STARTUP:
4265	{
4266	/*
4267	* Format it.
4268	*/
4269	MachineState_T machineState;
4270	gpMachine->COMGETTER(State)(&machineState);
4271	if (machineState == MachineState_Starting)
4272	RTStrPrintf(szTitle + strlen(szTitle), sizeof(szTitle) - strlen(szTitle),
4273	" - Starting...");
4274	else if (machineState == MachineState_Restoring)
4275	{
4276	ULONG cPercentNow;
4277	HRESULT rc = gpProgress->COMGETTER(Percent)(&cPercentNow);
4278	if (SUCCEEDED(rc))
4279	RTStrPrintf(szTitle + strlen(szTitle), sizeof(szTitle) - strlen(szTitle),
4280	" - Restoring %d%%...", (int)cPercentNow);
4281	else
4282	RTStrPrintf(szTitle + strlen(szTitle), sizeof(szTitle) - strlen(szTitle),
4283	" - Restoring...");
4284	}
4285	else if (machineState == MachineState_TeleportingIn)
4286	{
4287	ULONG cPercentNow;
4288	HRESULT rc = gpProgress->COMGETTER(Percent)(&cPercentNow);
4289	if (SUCCEEDED(rc))
4290	RTStrPrintf(szTitle + strlen(szTitle), sizeof(szTitle) - strlen(szTitle),
4291	" - Teleporting %d%%...", (int)cPercentNow);
4292	else
4293	RTStrPrintf(szTitle + strlen(szTitle), sizeof(szTitle) - strlen(szTitle),
4294	" - Teleporting...");
4295	}
4296	/* ignore other states, we could already be in running or aborted state */
4297	break;
4298	}
4299
4300	case TITLEBAR_SAVE:
4301	{
4302	AssertMsg(u32User <= 100, ("%d\n", u32User));
4303	RTStrPrintf(szTitle + strlen(szTitle), sizeof(szTitle) - strlen(szTitle),
4304	" - Saving %d%%...", u32User);
4305	break;
4306	}
4307
4308	case TITLEBAR_SNAPSHOT:
4309	{
4310	AssertMsg(u32User <= 100, ("%d\n", u32User));
4311	RTStrPrintf(szTitle + strlen(szTitle), sizeof(szTitle) - strlen(szTitle),
4312	" - Taking snapshot %d%%...", u32User);
4313	break;
4314	}
4315
4316	default:
4317	RTPrintf("Error: Invalid title bar mode %d!\n", mode);
4318	return;
4319	}
4320
4321	/*
4322	* Don't update if it didn't change.
4323	*/
4324	if (!strcmp(szTitle, szPrevTitle))
4325	return;
4326
4327	/*
4328	* Set the new title
4329	*/
4330	#ifdef VBOX_WIN32_UI
4331	setUITitle(szTitle);
4332	#else
4333	SDL_WM_SetCaption(szTitle, VBOX_PRODUCT);
4334	#endif
4335	}
4336
4337	#if 0
4338	static void vbox_show_shape(unsigned short w, unsigned short h,
4339	uint32_t bg, const uint8_t *image)
4340	{
4341	size_t x, y;
4342	unsigned short pitch;
4343	const uint32_t *color;
4344	const uint8_t *mask;
4345	size_t size_mask;
4346
4347	mask = image;
4348	pitch = (w + 7) / 8;
4349	size_mask = (pitch * h + 3) & ~3;
4350
4351	color = (const uint32_t *)(image + size_mask);
4352
4353	printf("show_shape %dx%d pitch %d size mask %d\n",
4354	w, h, pitch, size_mask);
4355	for (y = 0; y < h; ++y, mask += pitch, color += w)
4356	{
4357	for (x = 0; x < w; ++x) {
4358	if (mask[x / 8] & (1 << (7 - (x % 8))))
4359	printf(" ");
4360	else
4361	{
4362	uint32_t c = color[x];
4363	if (c == bg)
4364	printf("Y");
4365	else
4366	printf("X");
4367	}
4368	}
4369	printf("\n");
4370	}
4371	}
4372	#endif
4373
4374	/**
4375	* Sets the pointer shape according to parameters.
4376	* Must be called only from the main SDL thread.
4377	*/
4378	static void SetPointerShape(const PointerShapeChangeData *data)
4379	{
4380	/*
4381	* don't allow to change the pointer shape if we are outside the valid
4382	* guest area. In that case set standard mouse pointer is set and should
4383	* not get overridden.
4384	*/
4385	if (gpOffCursor)
4386	return;
4387
4388	if (data->shape.size() > 0)
4389	{
4390	bool ok = false;
4391
4392	uint32_t andMaskSize = (data->width + 7) / 8 * data->height;
4393	uint32_t srcShapePtrScan = data->width * 4;
4394
4395	const uint8_t* shape = data->shape.raw();
4396	const uint8_t *srcAndMaskPtr = shape;
4397	const uint8_t *srcShapePtr = shape + ((andMaskSize + 3) & ~3);
4398
4399	#if 0
4400	/* pointer debugging code */
4401	// vbox_show_shape(data->width, data->height, 0, data->shape);
4402	uint32_t shapeSize = ((((data->width + 7) / 8) * data->height + 3) & ~3) + data->width * 4 * data->height;
4403	printf("visible: %d\n", data->visible);
4404	printf("width = %d\n", data->width);
4405	printf("height = %d\n", data->height);
4406	printf("alpha = %d\n", data->alpha);
4407	printf("xhot = %d\n", data->xHot);
4408	printf("yhot = %d\n", data->yHot);
4409	printf("uint8_t pointerdata[] = { ");
4410	for (uint32_t i = 0; i < shapeSize; i++)
4411	{
4412	printf("0x%x, ", data->shape[i]);
4413	}
4414	printf("};\n");
4415	#endif
4416
4417	#if defined(RT_OS_WINDOWS)
4418
4419	BITMAPV5HEADER bi;
4420	HBITMAP hBitmap;
4421	void *lpBits;
4422	HCURSOR hAlphaCursor = NULL;
4423
4424	::ZeroMemory(&bi, sizeof(BITMAPV5HEADER));
4425	bi.bV5Size = sizeof(BITMAPV5HEADER);
4426	bi.bV5Width = data->width;
4427	bi.bV5Height = -(LONG)data->height;
4428	bi.bV5Planes = 1;
4429	bi.bV5BitCount = 32;
4430	bi.bV5Compression = BI_BITFIELDS;
4431	// specify a supported 32 BPP alpha format for Windows XP
4432	bi.bV5RedMask = 0x00FF0000;
4433	bi.bV5GreenMask = 0x0000FF00;
4434	bi.bV5BlueMask = 0x000000FF;
4435	if (data->alpha)
4436	bi.bV5AlphaMask = 0xFF000000;
4437	else
4438	bi.bV5AlphaMask = 0;
4439
4440	HDC hdc = ::GetDC(NULL);
4441
4442	// create the DIB section with an alpha channel
4443	hBitmap = ::CreateDIBSection(hdc, (BITMAPINFO *)&bi, DIB_RGB_COLORS,
4444	(void **)&lpBits, NULL, (DWORD)0);
4445
4446	::ReleaseDC(NULL, hdc);
4447
4448	HBITMAP hMonoBitmap = NULL;
4449	if (data->alpha)
4450	{
4451	// create an empty mask bitmap
4452	hMonoBitmap = ::CreateBitmap(data->width, data->height, 1, 1, NULL);
4453	}
4454	else
4455	{
4456	/* Word aligned AND mask. Will be allocated and created if necessary. */
4457	uint8_t *pu8AndMaskWordAligned = NULL;
4458
4459	/* Width in bytes of the original AND mask scan line. */
4460	uint32_t cbAndMaskScan = (data->width + 7) / 8;
4461
4462	if (cbAndMaskScan & 1)
4463	{
4464	/* Original AND mask is not word aligned. */
4465
4466	/* Allocate memory for aligned AND mask. */
4467	pu8AndMaskWordAligned = (uint8_t )RTMemTmpAllocZ((cbAndMaskScan + 1) data->height);
4468
4469	Assert(pu8AndMaskWordAligned);
4470
4471	if (pu8AndMaskWordAligned)
4472	{
4473	/* According to MSDN the padding bits must be 0.
4474	* Compute the bit mask to set padding bits to 0 in the last byte of original AND mask.
4475	*/
4476	uint32_t u32PaddingBits = cbAndMaskScan * 8 - data->width;
4477	Assert(u32PaddingBits < 8);
4478	uint8_t u8LastBytesPaddingMask = (uint8_t)(0xFF << u32PaddingBits);
4479
4480	Log(("u8LastBytesPaddingMask = %02X, aligned w = %d, width = %d, cbAndMaskScan = %d\n",
4481	u8LastBytesPaddingMask, (cbAndMaskScan + 1) * 8, data->width, cbAndMaskScan));
4482
4483	uint8_t src = (uint8_t )srcAndMaskPtr;
4484	uint8_t *dst = pu8AndMaskWordAligned;
4485
4486	unsigned i;
4487	for (i = 0; i < data->height; i++)
4488	{
4489	memcpy(dst, src, cbAndMaskScan);
4490
4491	dst[cbAndMaskScan - 1] &= u8LastBytesPaddingMask;
4492
4493	src += cbAndMaskScan;
4494	dst += cbAndMaskScan + 1;
4495	}
4496	}
4497	}
4498
4499	// create the AND mask bitmap
4500	hMonoBitmap = ::CreateBitmap(data->width, data->height, 1, 1,
4501	pu8AndMaskWordAligned? pu8AndMaskWordAligned: srcAndMaskPtr);
4502
4503	if (pu8AndMaskWordAligned)
4504	{
4505	RTMemTmpFree(pu8AndMaskWordAligned);
4506	}
4507	}
4508
4509	Assert(hBitmap);
4510	Assert(hMonoBitmap);
4511	if (hBitmap && hMonoBitmap)
4512	{
4513	DWORD dstShapePtr = (DWORD )lpBits;
4514
4515	for (uint32_t y = 0; y < data->height; y ++)
4516	{
4517	memcpy(dstShapePtr, srcShapePtr, srcShapePtrScan);
4518	srcShapePtr += srcShapePtrScan;
4519	dstShapePtr += data->width;
4520	}
4521
4522	ICONINFO ii;
4523	ii.fIcon = FALSE;
4524	ii.xHotspot = data->xHot;
4525	ii.yHotspot = data->yHot;
4526	ii.hbmMask = hMonoBitmap;
4527	ii.hbmColor = hBitmap;
4528
4529	hAlphaCursor = ::CreateIconIndirect(&ii);
4530	Assert(hAlphaCursor);
4531	if (hAlphaCursor)
4532	{
4533	// here we do a dirty trick by substituting a Window Manager's
4534	// cursor handle with the handle we created
4535
4536	WMcursor *pCustomTempWMCursor = gpCustomCursor->wm_cursor;
4537
4538	// see SDL12/src/video/wincommon/SDL_sysmouse.c
4539	void wm_cursor = malloc(sizeof(HCURSOR) + sizeof(uint8_t ) * 2);
4540	(HCURSOR )wm_cursor = hAlphaCursor;
4541
4542	gpCustomCursor->wm_cursor = (WMcursor *)wm_cursor;
4543	SDL_SetCursor(gpCustomCursor);
4544	SDL_ShowCursor(SDL_ENABLE);
4545
4546	if (pCustomTempWMCursor)
4547	{
4548	::DestroyCursor((HCURSOR )pCustomTempWMCursor);
4549	free(pCustomTempWMCursor);
4550	}
4551
4552	ok = true;
4553	}
4554	}
4555
4556	if (hMonoBitmap)
4557	::DeleteObject(hMonoBitmap);
4558	if (hBitmap)
4559	::DeleteObject(hBitmap);
4560
4561	#elif defined(VBOXSDL_WITH_X11) && !defined(VBOX_WITHOUT_XCURSOR)
4562
4563	if (gfXCursorEnabled)
4564	{
4565	XcursorImage *img = XcursorImageCreate(data->width, data->height);
4566	Assert(img);
4567	if (img)
4568	{
4569	img->xhot = data->xHot;
4570	img->yhot = data->yHot;
4571
4572	XcursorPixel *dstShapePtr = img->pixels;
4573
4574	for (uint32_t y = 0; y < data->height; y ++)
4575	{
4576	memcpy(dstShapePtr, srcShapePtr, srcShapePtrScan);
4577
4578	if (!data->alpha)
4579	{
4580	// convert AND mask to the alpha channel
4581	uint8_t byte = 0;
4582	for (uint32_t x = 0; x < data->width; x ++)
4583	{
4584	if (!(x % 8))
4585	byte = *(srcAndMaskPtr ++);
4586	else
4587	byte <<= 1;
4588
4589	if (byte & 0x80)
4590	{
4591	// Linux doesn't support inverted pixels (XOR ops,
4592	// to be exact) in cursor shapes, so we detect such
4593	// pixels and always replace them with black ones to
4594	// make them visible at least over light colors
4595	if (dstShapePtr [x] & 0x00FFFFFF)
4596	dstShapePtr [x] = 0xFF000000;
4597	else
4598	dstShapePtr [x] = 0x00000000;
4599	}
4600	else
4601	dstShapePtr [x] \|= 0xFF000000;
4602	}
4603	}
4604
4605	srcShapePtr += srcShapePtrScan;
4606	dstShapePtr += data->width;
4607	}
4608
4609	#ifndef VBOX_WITH_SDL13
4610	Cursor cur = XcursorImageLoadCursor(gSdlInfo.info.x11.display, img);
4611	Assert(cur);
4612	if (cur)
4613	{
4614	// here we do a dirty trick by substituting a Window Manager's
4615	// cursor handle with the handle we created
4616
4617	WMcursor *pCustomTempWMCursor = gpCustomCursor->wm_cursor;
4618
4619	// see SDL12/src/video/x11/SDL_x11mouse.c
4620	void *wm_cursor = malloc(sizeof(Cursor));
4621	(Cursor )wm_cursor = cur;
4622
4623	gpCustomCursor->wm_cursor = (WMcursor *)wm_cursor;
4624	SDL_SetCursor(gpCustomCursor);
4625	SDL_ShowCursor(SDL_ENABLE);
4626
4627	if (pCustomTempWMCursor)
4628	{
4629	XFreeCursor(gSdlInfo.info.x11.display, (Cursor )pCustomTempWMCursor);
4630	free(pCustomTempWMCursor);
4631	}
4632
4633	ok = true;
4634	}
4635	#endif
4636	}
4637	XcursorImageDestroy(img);
4638	}
4639
4640	#endif /* VBOXSDL_WITH_X11 && !VBOX_WITHOUT_XCURSOR */
4641
4642	if (!ok)
4643	{
4644	SDL_SetCursor(gpDefaultCursor);
4645	SDL_ShowCursor(SDL_ENABLE);
4646	}
4647	}
4648	else
4649	{
4650	if (data->visible)
4651	SDL_ShowCursor(SDL_ENABLE);
4652	else if (gfAbsoluteMouseGuest)
4653	/* Don't disable the cursor if the guest additions are not active (anymore) */
4654	SDL_ShowCursor(SDL_DISABLE);
4655	}
4656	}
4657
4658	/**
4659	* Handle changed mouse capabilities
4660	*/
4661	static void HandleGuestCapsChanged(void)
4662	{
4663	if (!gfAbsoluteMouseGuest)
4664	{
4665	// Cursor could be overwritten by the guest tools
4666	SDL_SetCursor(gpDefaultCursor);
4667	SDL_ShowCursor(SDL_ENABLE);
4668	gpOffCursor = NULL;
4669	}
4670	if (gpMouse && UseAbsoluteMouse())
4671	{
4672	// Actually switch to absolute coordinates
4673	if (gfGrabbed)
4674	InputGrabEnd();
4675	gpMouse->PutMouseEventAbsolute(-1, -1, 0, 0, 0);
4676	}
4677	}
4678
4679	/**
4680	* Handles a host key down event
4681	*/
4682	static int HandleHostKey(const SDL_KeyboardEvent *pEv)
4683	{
4684	/*
4685	* Revalidate the host key modifier
4686	*/
4687	if ((SDL_GetModState() & ~(KMOD_MODE \| KMOD_NUM \| KMOD_RESERVED)) != gHostKeyMod)
4688	return VERR_NOT_SUPPORTED;
4689
4690	/*
4691	* What was pressed?
4692	*/
4693	switch (pEv->keysym.sym)
4694	{
4695	/* Control-Alt-Delete */
4696	case SDLK_DELETE:
4697	{
4698	gpKeyboard->PutCAD();
4699	break;
4700	}
4701
4702	/*
4703	* Fullscreen / Windowed toggle.
4704	*/
4705	case SDLK_f:
4706	{
4707	if ( strchr(gHostKeyDisabledCombinations, 'f')
4708	\|\| !gfAllowFullscreenToggle)
4709	return VERR_NOT_SUPPORTED;
4710
4711	/*
4712	* We have to pause/resume the machine during this
4713	* process because there might be a short moment
4714	* without a valid framebuffer
4715	*/
4716	MachineState_T machineState;
4717	gpMachine->COMGETTER(State)(&machineState);
4718	bool fPauseIt = machineState == MachineState_Running
4719	\|\| machineState == MachineState_Teleporting
4720	\|\| machineState == MachineState_LiveSnapshotting;
4721	if (fPauseIt)
4722	gpConsole->Pause();
4723	SetFullscreen(!gpFramebuffer[0]->getFullscreen());
4724	if (fPauseIt)
4725	gpConsole->Resume();
4726
4727	/*
4728	* We have switched from/to fullscreen, so request a full
4729	* screen repaint, just to be sure.
4730	*/
4731	gpDisplay->InvalidateAndUpdate();
4732	break;
4733	}
4734
4735	/*
4736	* Pause / Resume toggle.
4737	*/
4738	case SDLK_p:
4739	{
4740	if (strchr(gHostKeyDisabledCombinations, 'p'))
4741	return VERR_NOT_SUPPORTED;
4742
4743	MachineState_T machineState;
4744	gpMachine->COMGETTER(State)(&machineState);
4745	if ( machineState == MachineState_Running
4746	\|\| machineState == MachineState_Teleporting
4747	\|\| machineState == MachineState_LiveSnapshotting
4748	)
4749	{
4750	if (gfGrabbed)
4751	InputGrabEnd();
4752	gpConsole->Pause();
4753	}
4754	else if (machineState == MachineState_Paused)
4755	{
4756	gpConsole->Resume();
4757	}
4758	UpdateTitlebar(TITLEBAR_NORMAL);
4759	break;
4760	}
4761
4762	/*
4763	* Reset the VM
4764	*/
4765	case SDLK_r:
4766	{
4767	if (strchr(gHostKeyDisabledCombinations, 'r'))
4768	return VERR_NOT_SUPPORTED;
4769
4770	ResetVM();
4771	break;
4772	}
4773
4774	/*
4775	* Terminate the VM
4776	*/
4777	case SDLK_q:
4778	{
4779	if (strchr(gHostKeyDisabledCombinations, 'q'))
4780	return VERR_NOT_SUPPORTED;
4781
4782	return VINF_EM_TERMINATE;
4783	}
4784
4785	/*
4786	* Save the machine's state and exit
4787	*/
4788	case SDLK_s:
4789	{
4790	if (strchr(gHostKeyDisabledCombinations, 's'))
4791	return VERR_NOT_SUPPORTED;
4792
4793	SaveState();
4794	return VINF_EM_TERMINATE;
4795	}
4796
4797	case SDLK_h:
4798	{
4799	if (strchr(gHostKeyDisabledCombinations, 'h'))
4800	return VERR_NOT_SUPPORTED;
4801
4802	if (gpConsole)
4803	gpConsole->PowerButton();
4804	break;
4805	}
4806
4807	/*
4808	* Perform an online snapshot. Continue operation.
4809	*/
4810	case SDLK_n:
4811	{
4812	if (strchr(gHostKeyDisabledCombinations, 'n'))
4813	return VERR_NOT_SUPPORTED;
4814
4815	RTThreadYield();
4816	ULONG cSnapshots = 0;
4817	gpMachine->COMGETTER(SnapshotCount)(&cSnapshots);
4818	char pszSnapshotName[20];
4819	RTStrPrintf(pszSnapshotName, sizeof(pszSnapshotName), "Snapshot %d", cSnapshots + 1);
4820	gpProgress = NULL;
4821	HRESULT rc;
4822	CHECK_ERROR(gpConsole, TakeSnapshot(Bstr(pszSnapshotName).raw(),
4823	Bstr("Taken by VBoxSDL").raw(),
4824	gpProgress.asOutParam()));
4825	if (FAILED(rc))
4826	{
4827	RTPrintf("Error taking snapshot! rc = 0x%x\n", rc);
4828	/* continue operation */
4829	return VINF_SUCCESS;
4830	}
4831	/*
4832	* Wait for the operation to be completed and work
4833	* the title bar in the mean while.
4834	*/
4835	ULONG cPercent = 0;
4836	for (;;)
4837	{
4838	BOOL fCompleted = false;
4839	rc = gpProgress->COMGETTER(Completed)(&fCompleted);
4840	if (FAILED(rc) \|\| fCompleted)
4841	break;
4842	ULONG cPercentNow;
4843	rc = gpProgress->COMGETTER(Percent)(&cPercentNow);
4844	if (FAILED(rc))
4845	break;
4846	if (cPercentNow != cPercent)
4847	{
4848	UpdateTitlebar(TITLEBAR_SNAPSHOT, cPercent);
4849	cPercent = cPercentNow;
4850	}
4851
4852	/* wait */
4853	rc = gpProgress->WaitForCompletion(100);
4854	if (FAILED(rc))
4855	break;
4856	/// @todo process gui events.
4857	}
4858
4859	/* continue operation */
4860	return VINF_SUCCESS;
4861	}
4862
4863	case SDLK_F1: case SDLK_F2: case SDLK_F3:
4864	case SDLK_F4: case SDLK_F5: case SDLK_F6:
4865	case SDLK_F7: case SDLK_F8: case SDLK_F9:
4866	case SDLK_F10: case SDLK_F11: case SDLK_F12:
4867	{
4868	// /* send Ctrl-Alt-Fx to guest */
4869	com::SafeArray<LONG> keys(6);
4870
4871	keys[0] = 0x1d; // Ctrl down
4872	keys[1] = 0x38; // Alt down
4873	keys[2] = Keyevent2Keycode(pEv); // Fx down
4874	keys[3] = keys[2] + 0x80; // Fx up
4875	keys[4] = 0xb8; // Alt up
4876	keys[5] = 0x9d; // Ctrl up
4877
4878	gpKeyboard->PutScancodes(ComSafeArrayAsInParam(keys), NULL);
4879	return VINF_SUCCESS;
4880	}
4881
4882	/*
4883	* Not a host key combination.
4884	* Indicate this by returning false.
4885	*/
4886	default:
4887	return VERR_NOT_SUPPORTED;
4888	}
4889
4890	return VINF_SUCCESS;
4891	}
4892
4893	/**
4894	* Timer callback function for startup processing
4895	*/
4896	static Uint32 StartupTimer(Uint32 interval, void *param)
4897	{
4898	/* post message so we can do something in the startup loop */
4899	SDL_Event event = {0};
4900	event.type = SDL_USEREVENT;
4901	event.user.type = SDL_USER_EVENT_TIMER;
4902	SDL_PushEvent(&event);
4903	RTSemEventSignal(g_EventSemSDLEvents);
4904	return interval;
4905	}
4906
4907	/**
4908	* Timer callback function to check if resizing is finished
4909	*/
4910	static Uint32 ResizeTimer(Uint32 interval, void *param)
4911	{
4912	/* post message so the window is actually resized */
4913	SDL_Event event = {0};
4914	event.type = SDL_USEREVENT;
4915	event.user.type = SDL_USER_EVENT_WINDOW_RESIZE_DONE;
4916	PushSDLEventForSure(&event);
4917	/* one-shot */
4918	return 0;
4919	}
4920
4921	/**
4922	* Timer callback function to check if an ACPI power button event was handled by the guest.
4923	*/
4924	static Uint32 QuitTimer(Uint32 interval, void *param)
4925	{
4926	BOOL fHandled = FALSE;
4927
4928	gSdlQuitTimer = NULL;
4929	if (gpConsole)
4930	{
4931	int rc = gpConsole->GetPowerButtonHandled(&fHandled);
4932	LogRel(("QuitTimer: rc=%d handled=%d\n", rc, fHandled));
4933	if (RT_FAILURE(rc) \|\| !fHandled)
4934	{
4935	/* event was not handled, power down the guest */
4936	gfACPITerm = FALSE;
4937	SDL_Event event = {0};
4938	event.type = SDL_QUIT;
4939	PushSDLEventForSure(&event);
4940	}
4941	}
4942	/* one-shot */
4943	return 0;
4944	}
4945
4946	/**
4947	* Wait for the next SDL event. Don't use SDL_WaitEvent since this function
4948	* calls SDL_Delay(10) if the event queue is empty.
4949	*/
4950	static int WaitSDLEvent(SDL_Event *event)
4951	{
4952	for (;;)
4953	{
4954	int rc = SDL_PollEvent(event);
4955	if (rc == 1)
4956	{
4957	#ifdef USE_XPCOM_QUEUE_THREAD
4958	if (event->type == SDL_USER_EVENT_XPCOM_EVENTQUEUE)
4959	consumedXPCOMUserEvent();
4960	#endif
4961	return 1;
4962	}
4963	/* Immediately wake up if new SDL events are available. This does not
4964	* work for internal SDL events. Don't wait more than 10ms. */
4965	RTSemEventWait(g_EventSemSDLEvents, 10);
4966	}
4967	}
4968
4969	/**
4970	* Ensure that an SDL event is really enqueued. Try multiple times if necessary.
4971	*/
4972	int PushSDLEventForSure(SDL_Event *event)
4973	{
4974	int ntries = 10;
4975	for (; ntries > 0; ntries--)
4976	{
4977	int rc = SDL_PushEvent(event);
4978	RTSemEventSignal(g_EventSemSDLEvents);
4979	#ifdef VBOX_WITH_SDL13
4980	if (rc == 1)
4981	#else
4982	if (rc == 0)
4983	#endif
4984	return 0;
4985	Log(("PushSDLEventForSure: waiting for 2ms (rc = %d)\n", rc));
4986	RTThreadSleep(2);
4987	}
4988	LogRel(("WARNING: Failed to enqueue SDL event %d.%d!\n",
4989	event->type, event->type == SDL_USEREVENT ? event->user.type : 0));
4990	return -1;
4991	}
4992
4993	#ifdef VBOXSDL_WITH_X11
4994	/**
4995	* Special SDL_PushEvent function for NotifyUpdate events. These events may occur in bursts
4996	* so make sure they don't flood the SDL event queue.
4997	*/
4998	void PushNotifyUpdateEvent(SDL_Event *event)
4999	{
5000	int rc = SDL_PushEvent(event);
5001	#ifdef VBOX_WITH_SDL13
5002	bool fSuccess = (rc == 1);
5003	#else
5004	bool fSuccess = (rc == 0);
5005	#endif
5006
5007	RTSemEventSignal(g_EventSemSDLEvents);
5008	AssertMsg(fSuccess, ("SDL_PushEvent returned SDL error\n"));
5009	/* A global counter is faster than SDL_PeepEvents() */
5010	if (fSuccess)
5011	ASMAtomicIncS32(&g_cNotifyUpdateEventsPending);
5012	/* In order to not flood the SDL event queue, yield the CPU or (if there are already many
5013	* events queued) even sleep */
5014	if (g_cNotifyUpdateEventsPending > 96)
5015	{
5016	/* Too many NotifyUpdate events, sleep for a small amount to give the main thread time
5017	* to handle these events. The SDL queue can hold up to 128 events. */
5018	Log(("PushNotifyUpdateEvent: Sleep 1ms\n"));
5019	RTThreadSleep(1);
5020	}
5021	else
5022	RTThreadYield();
5023	}
5024	#endif /* VBOXSDL_WITH_X11 */
5025
5026	/**
5027	*
5028	*/
5029	static void SetFullscreen(bool enable)
5030	{
5031	if (enable == gpFramebuffer[0]->getFullscreen())
5032	return;
5033
5034	if (!gfFullscreenResize)
5035	{
5036	/*
5037	* The old/default way: SDL will resize the host to fit the guest screen resolution.
5038	*/
5039	gpFramebuffer[0]->setFullscreen(enable);
5040	}
5041	else
5042	{
5043	/*
5044	* The alternate way: Switch to fullscreen with the host screen resolution and adapt
5045	* the guest screen resolution to the host window geometry.
5046	*/
5047	uint32_t NewWidth = 0, NewHeight = 0;
5048	if (enable)
5049	{
5050	/* switch to fullscreen */
5051	gmGuestNormalXRes = gpFramebuffer[0]->getGuestXRes();
5052	gmGuestNormalYRes = gpFramebuffer[0]->getGuestYRes();
5053	gpFramebuffer[0]->getFullscreenGeometry(&NewWidth, &NewHeight);
5054	}
5055	else
5056	{
5057	/* switch back to saved geometry */
5058	NewWidth = gmGuestNormalXRes;
5059	NewHeight = gmGuestNormalYRes;
5060	}
5061	if (NewWidth != 0 && NewHeight != 0)
5062	{
5063	gpFramebuffer[0]->setFullscreen(enable);
5064	gfIgnoreNextResize = TRUE;
5065	gpDisplay->SetVideoModeHint(0 /=display/, true /=enabled/,
5066	false /=changeOrigin/, 0 /=originX/, 0 /=originY/,
5067	NewWidth, NewHeight, 0 /don't change bpp/);
5068	}
5069	}
5070	}
5071
5072	#ifdef VBOX_WITH_SDL13
5073	static VBoxSDLFB * getFbFromWinId(SDL_WindowID id)
5074	{
5075	for (unsigned i = 0; i < gcMonitors; i++)
5076	if (gpFramebuffer[i]->hasWindow(id))
5077	return gpFramebuffer[i];
5078
5079	return NULL;
5080	}
5081	#endif

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

source: vbox/trunk/src/VBox/Frontends/VBoxSDL/VBoxSDL.cpp@ 47972

Download in other formats: