UISession.cpp@ 103977

Last change on this file since 103977 was 103793, checked in by vboxsync, 9 months ago
FE/Qt: UICommon: Move versioning related functionality to UIVersion / UIVersionInfo; Rework user cases accordingly.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 103.3 KB

Line
1	/* $Id: UISession.cpp 103793 2024-03-11 19:17:31Z vboxsync $ */
2	/** @file
3	* VBox Qt GUI - UISession class implementation.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	/* Qt includes: */
29	#include <QApplication>
30	#include <QRegularExpression>
31	#include <QWidget>
32
33	/* GUI includes: */
34	#include "UIActionPoolRuntime.h"
35	#include "UICommon.h"
36	#include "UIConsoleEventHandler.h"
37	#include "UIConverter.h"
38	#include "UIDetailsGenerator.h"
39	#include "UIExtraDataManager.h"
40	#include "UIFrameBuffer.h"
41	#include "UIGlobalSession.h"
42	#include "UIIconPool.h"
43	#include "UIGuestOSType.h"
44	#include "UILoggingDefs.h"
45	#include "UIMachine.h"
46	#include "UIMachineLogic.h"
47	#include "UIMachineView.h"
48	#include "UIMachineWindow.h"
49	#include "UIMedium.h"
50	#include "UIMessageCenter.h"
51	#include "UIModalWindowManager.h"
52	#include "UIMousePointerShapeData.h"
53	#include "UINotificationCenter.h"
54	#include "UISession.h"
55	#include "UITextTable.h"
56	#include "UIVersion.h"
57	#ifdef VBOX_GUI_WITH_KEYS_RESET_HANDLER
58	# include "UIKeyboardHandler.h"
59	# include <signal.h>
60	#endif
61
62	/* COM includes: */
63	#include "CAudioAdapter.h"
64	#include "CAudioSettings.h"
65	#include "CEmulatedUSB.h"
66	#include "CGraphicsAdapter.h"
67	#include "CHostNetworkInterface.h"
68	#include "CHostUSBDevice.h"
69	#include "CHostVideoInputDevice.h"
70	#include "CMedium.h"
71	#include "CMediumAttachment.h"
72	#include "CPlatform.h"
73	#include "CPlatformProperties.h"
74	#include "CRecordingSettings.h"
75	#include "CSnapshot.h"
76	#include "CStorageController.h"
77	#include "CSystemProperties.h"
78	#include "CUSBController.h"
79	#include "CUSBDevice.h"
80	#include "CUSBDeviceFilter.h"
81	#include "CUSBDeviceFilters.h"
82	#include "CVRDEServer.h"
83	#include "CVRDEServerInfo.h"
84	#ifdef VBOX_WITH_NETFLT
85	# include "CNetworkAdapter.h"
86	#endif
87
88	/* Other VBox includes: */
89	#ifdef VBOX_WITH_DEBUGGER_GUI
90	# include <VBox/dbggui.h>
91	# include <iprt/ldr.h>
92	#endif
93
94	#include <VBox/GuestHost/clipboard-helper.h>
95
96	/* VirtualBox interface declarations: */
97	#include <VBox/com/VirtualBox.h>
98
99	/* External includes: */
100	#ifdef VBOX_WS_NIX
101	# include <X11/Xlib.h>
102	# include <X11/Xutil.h>
103	#endif
104
105
106	#ifdef VBOX_GUI_WITH_KEYS_RESET_HANDLER
107	static void signalHandlerSIGUSR1(int sig, siginfo_t , void );
108	#endif
109
110	UISession::UISession(UIMachine *pMachine)
111	: QObject(pMachine)
112	/* Base variables: */
113	, m_pMachine(pMachine)
114	, m_fValid(false)
115	, m_pConsoleEventhandler(0)
116	/* Common variables: */
117	, m_enmMachineStatePrevious(KMachineState_Null)
118	, m_enmMachineState(KMachineState_Null)
119	/* Guest additions flags: */
120	, m_ulGuestAdditionsRunLevel(0)
121	, m_fIsGuestSupportsGraphics(false)
122	, m_fIsGuestSupportsSeamless(false)
123	#ifdef VBOX_WITH_DEBUGGER_GUI
124	/* Debug UI stuff: */
125	, m_pDbgGui(0)
126	, m_pDbgGuiVT(0)
127	#endif /* VBOX_WITH_DEBUGGER_GUI */
128	{
129	}
130
131	bool UISession::prepare()
132	{
133	/* Prepare COM stuff: */
134	if (!prepareCOMStuff())
135	return false;
136
137	/* Cache media early if requested: */
138	if (uiCommon().agressiveCaching())
139	recacheMachineMedia();
140
141	/* Prepare GUI stuff: */
142	prepareConsoleEventHandlers();
143	prepareFramebuffers();
144	prepareConnections();
145	prepareSignalHandling();
146
147	/* True by default: */
148	return true;
149	}
150
151	bool UISession::initialize()
152	{
153	/* Preprocess initialization: */
154	if (!preprocessInitialization())
155	return false;
156
157	/* Notify user about mouse&keyboard auto-capturing: */
158	if (gEDataManager->autoCaptureEnabled())
159	UINotificationMessage::remindAboutAutoCapture();
160
161	m_enmMachineState = machine().GetState();
162
163	/* Apply debug settings from the command line. */
164	if (!debugger().isNull() && debugger().isOk())
165	{
166	if (uiCommon().areWeToExecuteAllInIem())
167	debugger().SetExecuteAllInIEM(true);
168	if (!uiCommon().isDefaultWarpPct())
169	debugger().SetVirtualTimeRate(uiCommon().getWarpPct());
170	}
171
172	/* Apply ad-hoc reconfigurations from the command line: */
173	if (uiCommon().hasFloppyImageToMount())
174	mountAdHocImage(KDeviceType_Floppy, UIMediumDeviceType_Floppy, uiCommon().getFloppyImage().toString());
175	if (uiCommon().hasDvdImageToMount())
176	mountAdHocImage(KDeviceType_DVD, UIMediumDeviceType_DVD, uiCommon().getDvdImage().toString());
177
178	/* Power UP if this is NOT separate process: */
179	if (!uiCommon().isSeparateProcess())
180	if (!powerUp())
181	return false;
182
183	/* Make sure all the pending Console events converted to signals
184	* during the powerUp() progress above reached their destinations.
185	* That is necessary to make sure all the pending machine state change events processed.
186	* We can't just use the machine state directly acquired from IMachine because there
187	* will be few places which are using stale machine state, not just this one. */
188	QApplication::sendPostedEvents(0, QEvent::MetaCall);
189
190	/* Check if we missed a really quick termination after successful startup: */
191	if (isTurnedOff())
192	{
193	LogRel(("GUI: Aborting startup due to invalid machine state detected: %d\n", machineState()));
194	return false;
195	}
196
197	/* Fetch corresponding states: */
198	if (uiCommon().isSeparateProcess())
199	sltAdditionsChange();
200
201	#ifdef VBOX_GUI_WITH_PIDFILE
202	uiCommon().createPidfile();
203	#endif /* VBOX_GUI_WITH_PIDFILE */
204
205	/* Mark as valid finally: */
206	m_fValid = true;
207
208	/* True by default: */
209	return true;
210	}
211
212	bool UISession::powerUp()
213	{
214	/* Power UP machine: */
215	CProgress comProgress = uiCommon().shouldStartPaused() ? console().PowerUpPaused() : console().PowerUp();
216
217	/* Check for immediate failure: */
218	if (!console().isOk() \|\| comProgress.isNull())
219	{
220	if (uiCommon().showStartVMErrors())
221	msgCenter().cannotStartMachine(console(), machineName());
222	LogRel(("GUI: Aborting startup due to power up issue detected...\n"));
223	return false;
224	}
225
226	/* Some logging right after we powered up: */
227	LogRel(("GUI: Qt version: %s\n", UIVersionInfo::qtRTVersionString().toUtf8().constData()));
228	#ifdef VBOX_WS_NIX
229	LogRel(("GUI: X11 Window Manager code: %d\n", (int)uiCommon().typeOfWindowManager()));
230	#endif
231	#if defined(VBOX_WS_MAC) \|\| defined(VBOX_WS_WIN)
232	LogRel(("GUI: HID LEDs sync is %s\n", uimachine()->isHidLedsSyncEnabled() ? "enabled" : "disabled"));
233	#else
234	LogRel(("GUI: HID LEDs sync is not supported on this platform\n"));
235	#endif
236
237	/* Enable 'manual-override',
238	* preventing automatic Runtime UI closing
239	* and visual representation mode changes: */
240	uimachine()->setManualOverrideMode(true);
241
242	/* Show "Starting/Restoring" progress dialog: */
243	if (isSaved())
244	{
245	msgCenter().showModalProgressDialog(comProgress, machineName(), ":/progress_state_restore_90px.png", 0, 0);
246	/* After restoring from 'saved' state, machine-window(s) geometry should be adjusted: */
247	machineLogic()->adjustMachineWindowsGeometry();
248	}
249	else
250	{
251	#ifdef VBOX_IS_QT6_OR_LATER /** @todo why is this any problem on qt6? */
252	msgCenter().showModalProgressDialog(comProgress, machineName(), ":/progress_start_90px.png", 0, 0);
253	#else
254	msgCenter().showModalProgressDialog(comProgress, machineName(), ":/progress_start_90px.png");
255	#endif
256	/* After VM start, machine-window(s) size-hint(s) should be sent: */
257	machineLogic()->sendMachineWindowsSizeHints();
258	}
259
260	/* Check for progress failure: */
261	if (!comProgress.isOk() \|\| comProgress.GetResultCode() != 0)
262	{
263	if (uiCommon().showStartVMErrors())
264	msgCenter().cannotStartMachine(comProgress, machineName());
265	LogRel(("GUI: Aborting startup due to power up progress issue detected...\n"));
266	return false;
267	}
268
269	/* Disable 'manual-override' finally: */
270	uimachine()->setManualOverrideMode(false);
271
272	/* True by default: */
273	return true;
274	}
275
276	WId UISession::mainMachineWindowId() const
277	{
278	return mainMachineWindow() ? mainMachineWindow()->winId() : 0;
279	}
280
281	void UISession::acquireMachinePixmap(const QSize &size, QPixmap &pixmap)
282	{
283	QPixmap machinePixmap;
284	if (machine().isNotNull())
285	machinePixmap = generalIconPool().userMachinePixmap(machine(), size);
286	if (machinePixmap.isNull())
287	machinePixmap = generalIconPool().guestOSTypePixmap(osTypeId(), size);
288	if (!machinePixmap.isNull())
289	pixmap = machinePixmap;
290	}
291
292	void UISession::acquireUserMachineIcon(QIcon &icon)
293	{
294	QIcon machineIcon;
295	if (machine().isNotNull())
296	machineIcon = generalIconPool().userMachineIcon(machine());
297	if (machineIcon.isNull())
298	machineIcon = generalIconPool().guestOSTypeIcon(osTypeId());
299	if (machineIcon.isNull())
300	machineIcon = QIcon(":/VirtualBox_48px.png");
301	if (!machineIcon.isNull())
302	icon = machineIcon;
303	}
304
305	bool UISession::acquireArchitectureType(KPlatformArchitecture &enmType)
306	{
307	CMachine comMachine = machine();
308	if (comMachine.isNull())
309	return false;
310	CPlatform comPlatform = comMachine.GetPlatform();
311	bool fSuccess = comMachine.isOk();
312	if (!fSuccess)
313	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
314	else
315	{
316	const KPlatformArchitecture enmArchType = comPlatform.GetArchitecture();
317	fSuccess = comPlatform.isOk();
318	if (!fSuccess)
319	UINotificationMessage::cannotAcquirePlatformParameter(comPlatform);
320	else
321	enmType = enmArchType;
322	}
323	return fSuccess;
324	}
325
326	bool UISession::acquireChipsetType(KChipsetType &enmType)
327	{
328	CMachine comMachine = machine();
329	if (comMachine.isNull())
330	return false;
331	CPlatform comPlatform = comMachine.GetPlatform();
332	bool fSuccess = comMachine.isOk();
333	if (!fSuccess)
334	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
335	else
336	{
337	const KChipsetType enmChipsetType = comPlatform.GetChipsetType();
338	fSuccess = comPlatform.isOk();
339	if (!fSuccess)
340	UINotificationMessage::cannotAcquirePlatformParameter(comPlatform);
341	else
342	enmType = enmChipsetType;
343	}
344	return fSuccess;
345	}
346
347	bool UISession::acquireLiveMachineState(KMachineState &enmState)
348	{
349	CMachine comMachine = machine();
350	if (comMachine.isNull())
351	return false;
352	const KMachineState enmMachineState = comMachine.GetState();
353	const bool fSuccess = comMachine.isOk();
354	if (!fSuccess)
355	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
356	else
357	enmState = enmMachineState;
358	return fSuccess;
359	}
360
361	bool UISession::reset()
362	{
363	CConsole comConsole = console();
364	comConsole.Reset();
365	const bool fSuccess = comConsole.isOk();
366	if (!fSuccess)
367	UINotificationMessage::cannotResetMachine(comConsole);
368	return fSuccess;
369	}
370
371	bool UISession::setPause(bool fPause)
372	{
373	CConsole comConsole = console();
374	if (fPause)
375	comConsole.Pause();
376	else
377	comConsole.Resume();
378	const bool fSuccess = comConsole.isOk();
379	if (!fSuccess)
380	{
381	if (fPause)
382	UINotificationMessage::cannotPauseMachine(comConsole);
383	else
384	UINotificationMessage::cannotResumeMachine(comConsole);
385	}
386	return fSuccess;
387	}
388
389	bool UISession::acquireSettingsFilePath(QString &strPath)
390	{
391	CMachine comMachine = machine();
392	const QString strSettingsFilePath = comMachine.GetSettingsFilePath();
393	const bool fSuccess = comMachine.isOk();
394	if (!fSuccess)
395	UINotificationMessage::cannotSaveMachineSettings(comMachine);
396	else
397	strPath = strSettingsFilePath;
398	return fSuccess;
399	}
400
401	bool UISession::saveSettings()
402	{
403	CMachine comMachine = machine();
404	comMachine.SaveSettings();
405	const bool fSuccess = comMachine.isOk();
406	if (!fSuccess)
407	UINotificationMessage::cannotSaveMachineSettings(comMachine);
408	return fSuccess;
409	}
410
411	bool UISession::acquireSnapshotCount(ulong &uCount)
412	{
413	CMachine comMachine = machine();
414	const ULONG uSnapshotCount = comMachine.GetSnapshotCount();
415	const bool fSuccess = comMachine.isOk();
416	if (!fSuccess)
417	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
418	else
419	uCount = uSnapshotCount;
420	return fSuccess;
421	}
422
423	bool UISession::acquireCurrentSnapshotName(QString &strName)
424	{
425	CMachine comMachine = machine();
426	CSnapshot comSnapshot = comMachine.GetCurrentSnapshot();
427	bool fSuccess = comMachine.isOk();
428	if (!fSuccess)
429	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
430	{
431	const QString strSnapshotName = comSnapshot.GetName();
432	fSuccess = comSnapshot.isOk();
433	if (!fSuccess)
434	UINotificationMessage::cannotAcquireSnapshotParameter(comSnapshot);
435	else
436	strName = strSnapshotName;
437	}
438	return fSuccess;
439	}
440
441	bool UISession::acquireMaxSnapshotIndex(const QString &strNameTemplate, ulong &uIndex)
442	{
443	CMachine comMachine = machine();
444	CSnapshot comSnapshot = comMachine.FindSnapshot(QString());
445	return searchMaxSnapshotIndex(comMachine, comSnapshot, strNameTemplate, uIndex);
446	}
447
448	void UISession::takeSnapshot(const QString &strName, const QString &strDescription)
449	{
450	CMachine comMachine = machine();
451	UINotificationProgressSnapshotTake *pNotification = new UINotificationProgressSnapshotTake(comMachine,
452	strName,
453	strDescription);
454	gpNotificationCenter->append(pNotification);
455	}
456
457	bool UISession::putScancode(LONG iCode)
458	{
459	CKeyboard comKeyboard = keyboard();
460	comKeyboard.PutScancode(iCode);
461	const bool fSuccess = comKeyboard.isOk();
462	if (!fSuccess)
463	UINotificationMessage::cannotChangeKeyboardParameter(comKeyboard);
464	return fSuccess;
465	}
466
467	bool UISession::putScancodes(const QVector<LONG> &codes)
468	{
469	CKeyboard comKeyboard = keyboard();
470	if (comKeyboard.isNull())
471	return false;
472	comKeyboard.PutScancodes(codes);
473	const bool fSuccess = comKeyboard.isOk();
474	if (!fSuccess)
475	UINotificationMessage::cannotChangeKeyboardParameter(comKeyboard);
476	return fSuccess;
477	}
478
479	bool UISession::putCAD()
480	{
481	CKeyboard comKeyboard = keyboard();
482	comKeyboard.PutCAD();
483	const bool fSuccess = comKeyboard.isOk();
484	if (!fSuccess)
485	UINotificationMessage::cannotChangeKeyboardParameter(comKeyboard);
486	return fSuccess;
487	}
488
489	bool UISession::releaseKeys()
490	{
491	CKeyboard comKeyboard = keyboard();
492	comKeyboard.ReleaseKeys();
493	const bool fSuccess = comKeyboard.isOk();
494	if (!fSuccess)
495	UINotificationMessage::cannotChangeKeyboardParameter(comKeyboard);
496	return fSuccess;
497	}
498
499	bool UISession::putUsageCode(LONG iUsageCode, LONG iUsagePage, bool fKeyRelease)
500	{
501	CKeyboard comKeyboard = keyboard();
502	comKeyboard.PutUsageCode(iUsageCode, iUsagePage, fKeyRelease);
503	const bool fSuccess = comKeyboard.isOk();
504	if (!fSuccess)
505	UINotificationMessage::cannotChangeKeyboardParameter(comKeyboard);
506	return fSuccess;
507	}
508
509	bool UISession::acquireWhetherAbsoluteSupported(bool &fSupported)
510	{
511	CMouse comMouse = mouse();
512	if (comMouse.isNull())
513	return false;
514	const BOOL fAbsoluteSupported = comMouse.GetAbsoluteSupported();
515	const bool fSuccess = comMouse.isOk();
516	if (!fSuccess)
517	UINotificationMessage::cannotAcquireMouseParameter(comMouse);
518	else
519	fSupported = fAbsoluteSupported == TRUE;
520	return fSuccess;
521	}
522
523	bool UISession::acquireWhetherRelativeSupported(bool &fSupported)
524	{
525	CMouse comMouse = mouse();
526	if (comMouse.isNull())
527	return false;
528	const BOOL fRelativeSupported = comMouse.GetRelativeSupported();
529	const bool fSuccess = comMouse.isOk();
530	if (!fSuccess)
531	UINotificationMessage::cannotAcquireMouseParameter(comMouse);
532	else
533	fSupported = fRelativeSupported == TRUE;
534	return fSuccess;
535	}
536
537	bool UISession::acquireWhetherTouchScreenSupported(bool &fSupported)
538	{
539	CMouse comMouse = mouse();
540	if (comMouse.isNull())
541	return false;
542	const BOOL fTouchScreenSupported = comMouse.GetTouchScreenSupported();
543	const bool fSuccess = comMouse.isOk();
544	if (!fSuccess)
545	UINotificationMessage::cannotAcquireMouseParameter(comMouse);
546	else
547	fSupported = fTouchScreenSupported == TRUE;
548	return fSuccess;
549	}
550
551	bool UISession::acquireWhetherTouchPadSupported(bool &fSupported)
552	{
553	CMouse comMouse = mouse();
554	if (comMouse.isNull())
555	return false;
556	const BOOL fTouchPadSupported = comMouse.GetTouchPadSupported();
557	const bool fSuccess = comMouse.isOk();
558	if (!fSuccess)
559	UINotificationMessage::cannotAcquireMouseParameter(comMouse);
560	else
561	fSupported = fTouchPadSupported == TRUE;
562	return fSuccess;
563	}
564
565	bool UISession::acquireWhetherNeedsHostCursor(bool &fNeeds)
566	{
567	CMouse comMouse = mouse();
568	if (comMouse.isNull())
569	return false;
570	const BOOL fNeedsHostCursor = comMouse.GetNeedsHostCursor();
571	const bool fSuccess = comMouse.isOk();
572	if (!fSuccess)
573	UINotificationMessage::cannotAcquireMouseParameter(comMouse);
574	else
575	fNeeds = fNeedsHostCursor == TRUE;
576	return fSuccess;
577	}
578
579	bool UISession::putMouseEvent(long iDx, long iDy, long iDz, long iDw, long iButtonState)
580	{
581	CMouse comMouse = mouse();
582	if (comMouse.isNull())
583	return false;
584	comMouse.PutMouseEvent(iDx, iDy, iDz, iDw, iButtonState);
585	const bool fSuccess = comMouse.isOk();
586	if (!fSuccess)
587	UINotificationMessage::cannotChangeMouseParameter(comMouse);
588	return fSuccess;
589	}
590
591	bool UISession::putMouseEventAbsolute(long iX, long iY, long iDz, long iDw, long iButtonState)
592	{
593	CMouse comMouse = mouse();
594	if (comMouse.isNull())
595	return false;
596	comMouse.PutMouseEventAbsolute(iX, iY, iDz, iDw, iButtonState);
597	const bool fSuccess = comMouse.isOk();
598	if (!fSuccess)
599	UINotificationMessage::cannotChangeMouseParameter(comMouse);
600	return fSuccess;
601	}
602
603	bool UISession::putEventMultiTouch(long iCount, const QVector<LONG64> &contacts, bool fIsTouchScreen, ulong uScanTime)
604	{
605	CMouse comMouse = mouse();
606	if (comMouse.isNull())
607	return false;
608	comMouse.PutEventMultiTouch(iCount, contacts, fIsTouchScreen, uScanTime);
609	const bool fSuccess = comMouse.isOk();
610	if (!fSuccess)
611	UINotificationMessage::cannotChangeMouseParameter(comMouse);
612	return fSuccess;
613	}
614
615	bool UISession::acquireClipboardMode(KClipboardMode &enmMode)
616	{
617	CMachine comMachine = machine();
618	if (comMachine.isNull())
619	return false;
620	const KClipboardMode enmClipboardMode = comMachine.GetClipboardMode();
621	const bool fSuccess = comMachine.isOk();
622	if (!fSuccess)
623	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
624	else
625	enmMode = enmClipboardMode;
626	return fSuccess;
627	}
628
629	bool UISession::setClipboardMode(KClipboardMode enmMode)
630	{
631	CMachine comMachine = machine();
632	comMachine.SetClipboardMode(enmMode);
633	const bool fSuccess = comMachine.isOk();
634	if (!fSuccess)
635	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
636	return fSuccess;
637	}
638
639	bool UISession::toggleClipboardFileTransfer(bool fEnabled)
640	{
641	CMachine comMachine = machine();
642	comMachine.SetClipboardFileTransfersEnabled(fEnabled);
643	const bool fSuccess = comMachine.isOk();
644	if (!fSuccess)
645	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
646	return fSuccess;
647	}
648
649	bool UISession::isClipboardFileTransferEnabled()
650	{
651	CMachine comMachine = machine();
652	bool fEnabled = comMachine.GetClipboardFileTransfersEnabled();
653	const bool fSuccess = comMachine.isOk();
654	if (!fSuccess)
655	{
656	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
657	return false;
658	}
659	return fEnabled;
660	}
661
662	bool UISession::acquireDnDMode(KDnDMode &enmMode)
663	{
664	CMachine comMachine = machine();
665	if (comMachine.isNull())
666	return false;
667	const KDnDMode enmDnDMode = comMachine.GetDnDMode();
668	const bool fSuccess = comMachine.isOk();
669	if (!fSuccess)
670	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
671	else
672	enmMode = enmDnDMode;
673	return fSuccess;
674	}
675
676	bool UISession::setDnDMode(KDnDMode enmMode)
677	{
678	CMachine comMachine = machine();
679	comMachine.SetDnDMode(enmMode);
680	const bool fSuccess = comMachine.isOk();
681	if (!fSuccess)
682	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
683	return fSuccess;
684	}
685
686	bool UISession::acquireAmountOfStorageDevices(ulong &cHardDisks, ulong &cOpticalDrives, ulong &cFloppyDrives)
687	{
688	const CMachine comMachine = machine();
689	if (comMachine.isNull())
690	return false;
691	ulong cActualHardDisks = 0, cActualOpticalDrives = 0, cActualFloppyDrives = 0;
692	const CMediumAttachmentVector comAttachments = comMachine.GetMediumAttachments();
693	bool fSuccess = comMachine.isOk();
694	if (!fSuccess)
695	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
696	else
697	{
698	foreach (const CMediumAttachment &comAttachment, comAttachments)
699	{
700	/* Get device type: */
701	const KDeviceType enmDeviceType = comAttachment.GetType();
702	fSuccess = comAttachment.isOk();
703	if (!fSuccess)
704	{
705	UINotificationMessage::cannotAcquireMediumAttachmentParameter(comAttachment);
706	break;
707	}
708
709	/* And advance corresponding amount: */
710	switch (enmDeviceType)
711	{
712	case KDeviceType_HardDisk: ++cActualHardDisks; break;
713	case KDeviceType_DVD: ++cActualOpticalDrives; break;
714	case KDeviceType_Floppy: ++cActualFloppyDrives; break;
715	default: break;
716	}
717	}
718	}
719	if (fSuccess)
720	{
721	cHardDisks = cActualHardDisks;
722	cOpticalDrives = cActualOpticalDrives;
723	cFloppyDrives = cActualFloppyDrives;
724	}
725	return fSuccess;
726	}
727
728	bool UISession::storageDevices(KDeviceType enmActualDeviceType, QList<StorageDeviceInfo> &guiStorageDevices)
729	{
730	const CMachine comMachine = machine();
731	const CMediumAttachmentVector comAttachments = comMachine.GetMediumAttachments();
732	bool fSuccess = comMachine.isOk();
733	if (!fSuccess)
734	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
735	else
736	{
737	foreach (const CMediumAttachment &comAttachment, comAttachments)
738	{
739	/* Get device type: */
740	const KDeviceType enmDeviceType = comAttachment.GetType();
741	fSuccess = comAttachment.isOk();
742	if (!fSuccess)
743	{
744	UINotificationMessage::cannotAcquireMediumAttachmentParameter(comAttachment);
745	break;
746	}
747	/* And make sure it's actual one: */
748	if (enmDeviceType != enmActualDeviceType)
749	continue;
750
751	/* Get controller name: */
752	const QString strControllerName = comAttachment.GetController();
753	fSuccess = comAttachment.isOk();
754	if (!fSuccess)
755	{
756	UINotificationMessage::cannotAcquireMediumAttachmentParameter(comAttachment);
757	break;
758	}
759	/* And search for it's presence: */
760	const CStorageController comController = comMachine.GetStorageControllerByName(strControllerName);
761	fSuccess = comMachine.isOk();
762	if (!fSuccess)
763	{
764	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
765	break;
766	}
767
768	/* Fill structure fields: */
769	StorageDeviceInfo guiStorageDevice;
770	guiStorageDevice.m_strControllerName = strControllerName; // already confirmed
771	const KStorageBus enmStorageBus = comController.GetBus();
772	fSuccess = comController.isOk();
773	if (!fSuccess)
774	{
775	UINotificationMessage::cannotAcquireStorageControllerParameter(comController);
776	break;
777	}
778	switch (enmStorageBus)
779	{
780	case KStorageBus_IDE: guiStorageDevice.m_icon = UIIconPool::iconSet(":/ide_16px.png"); break;
781	case KStorageBus_SATA: guiStorageDevice.m_icon = UIIconPool::iconSet(":/sata_16px.png"); break;
782	case KStorageBus_SCSI: guiStorageDevice.m_icon = UIIconPool::iconSet(":/scsi_16px.png"); break;
783	case KStorageBus_Floppy: guiStorageDevice.m_icon = UIIconPool::iconSet(":/floppy_16px.png"); break;
784	case KStorageBus_SAS: guiStorageDevice.m_icon = UIIconPool::iconSet(":/sas_16px.png"); break;
785	case KStorageBus_USB: guiStorageDevice.m_icon = UIIconPool::iconSet(":/usb_16px.png"); break;
786	case KStorageBus_PCIe: guiStorageDevice.m_icon = UIIconPool::iconSet(":/pcie_16px.png"); break;
787	case KStorageBus_VirtioSCSI: guiStorageDevice.m_icon = UIIconPool::iconSet(":/virtio_scsi_16px.png"); break;
788	default: break;
789	}
790	const long iPort = comAttachment.GetPort();
791	fSuccess = comAttachment.isOk();
792	if (!fSuccess)
793	{
794	UINotificationMessage::cannotAcquireMediumAttachmentParameter(comAttachment);
795	break;
796	}
797	const long iDevice = comAttachment.GetDevice();
798	fSuccess = comAttachment.isOk();
799	if (!fSuccess)
800	{
801	UINotificationMessage::cannotAcquireMediumAttachmentParameter(comAttachment);
802	break;
803	}
804	if (fSuccess)
805	{
806	const StorageSlot guiStorageSlot(enmStorageBus, iPort, iDevice);
807	guiStorageDevice.m_guiStorageSlot = guiStorageSlot;
808	}
809
810	/* Append or break if necessary: */
811	if (fSuccess)
812	guiStorageDevices << guiStorageDevice;
813	else
814	break;
815	}
816	}
817	return fSuccess;
818	}
819
820	bool UISession::acquireEncryptedMedia(EncryptedMediumMap &media)
821	{
822	EncryptedMediumMap encryptedMedia;
823	CMachine comMachine = machine();
824	const CMediumAttachmentVector comAttachments = comMachine.GetMediumAttachments();
825	bool fSuccess = comMachine.isOk();
826	if (!fSuccess)
827	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
828	else
829	{
830	foreach (const CMediumAttachment &comAttachment, comAttachments)
831	{
832	const KDeviceType enmType = comAttachment.GetType();
833	fSuccess = comAttachment.isOk();
834	if (!fSuccess)
835	{
836	UINotificationMessage::cannotAcquireMediumAttachmentParameter(comAttachment);
837	break;
838	}
839
840	/* Look for hard-drive attachments only: */
841	if (enmType != KDeviceType_HardDisk)
842	continue;
843
844	/* Get the attachment medium: */
845	const CMedium comMedium = comAttachment.GetMedium();
846	fSuccess = comAttachment.isOk();
847	if (!fSuccess)
848	{
849	UINotificationMessage::cannotAcquireMediumAttachmentParameter(comAttachment);
850	break;
851	}
852
853	/* Get the medium ID: */
854	const QUuid uId = comMedium.GetId();
855	fSuccess = comMedium.isOk();
856	if (!fSuccess)
857	{
858	UINotificationMessage::cannotAcquireMediumParameter(comMedium);
859	break;
860	}
861
862	/* Update the map with this medium if it's encrypted: */
863	QString strCipher;
864	const QString strPasswordId = comMedium.GetEncryptionSettings(strCipher);
865	if (comMedium.isOk()) // GetEncryptionSettings failure is a valid case
866	encryptedMedia.insert(strPasswordId, uId);
867	}
868	}
869
870	if (fSuccess)
871	media = encryptedMedia;
872	return fSuccess;
873	}
874
875	bool UISession::addEncryptionPassword(const QString &strId, const QString &strPassword, bool fClearOnSuspend)
876	{
877	CConsole comConsole = console();
878	comConsole.AddEncryptionPassword(strId, strPassword, fClearOnSuspend);
879	const bool fSuccess = comConsole.isOk();
880	if (!fSuccess)
881	msgCenter().cannotAddDiskEncryptionPassword(comConsole);
882	return fSuccess;
883	}
884
885	bool UISession::acquireAmountOfImmutableImages(ulong &cAmount)
886	{
887	CMachine comMachine = machine();
888	return UICommon::acquireAmountOfImmutableImages(comMachine, cAmount);
889	}
890
891	bool UISession::mountBootMedium(const QUuid &uMediumId)
892	{
893	AssertReturn(!uMediumId.isNull(), false);
894
895	/* Get recommended controller bus & type: */
896	CVirtualBox comVBox = gpGlobalSession->virtualBox();
897
898	if (!comVBox.isOk())
899	{
900	UINotificationMessage::cannotAcquireVirtualBoxParameter(comVBox);
901	return false;
902	}
903
904	const KStorageBus enmRecommendedDvdBus = gpGlobalSession->guestOSTypeManager().getRecommendedDVDStorageBus(osTypeId());
905	const KStorageControllerType enmRecommendedDvdType = gpGlobalSession->guestOSTypeManager().getRecommendedDVDStorageController(osTypeId());
906
907	/* Search for an attachment of required bus & type: */
908	CMachine comMachine = machine();
909	CMediumAttachmentVector comMediumAttachments = comMachine.GetMediumAttachments();
910	bool fSuccess = comMachine.isOk();
911	if (!fSuccess)
912	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
913	else
914	{
915	CMediumAttachment comChosenAttachment;
916	QString strChosenControllerName;
917	LONG iChosenAttachmentPort = 0;
918	LONG iChosenAttachmentDevice = 0;
919	foreach (const CMediumAttachment &comAttachment, comMediumAttachments)
920	{
921	/* Get attachment type: */
922	const KDeviceType enmCurrentDeviceType = comAttachment.GetType();
923	fSuccess = comAttachment.isOk();
924	if (!fSuccess)
925	{
926	UINotificationMessage::cannotAcquireMediumAttachmentParameter(comAttachment);
927	break;
928	}
929	/* And make sure it's DVD: */
930	if (enmCurrentDeviceType != KDeviceType_DVD)
931	continue;
932
933	/* Get controller name: */
934	const QString strControllerName = comAttachment.GetController();
935	fSuccess = comAttachment.isOk();
936	if (!fSuccess)
937	{
938	UINotificationMessage::cannotAcquireMediumAttachmentParameter(comAttachment);
939	break;
940	}
941	/* And look for corresponding controller: */
942	const CStorageController comCurrentController = comMachine.GetStorageControllerByName(strControllerName);
943	fSuccess = comMachine.isOk();
944	if (!fSuccess)
945	{
946	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
947	break;
948	}
949
950	/* Get current controller bus: */
951	const KStorageBus enmCurrentBus = comCurrentController.GetBus();
952	fSuccess = comCurrentController.isOk();
953	if (!fSuccess)
954	{
955	UINotificationMessage::cannotAcquireStorageControllerParameter(comCurrentController);
956	break;
957	}
958	/* Get current controller type: */
959	const KStorageControllerType enmCurrentType = comCurrentController.GetControllerType();
960	fSuccess = comCurrentController.isOk();
961	if (!fSuccess)
962	{
963	UINotificationMessage::cannotAcquireStorageControllerParameter(comCurrentController);
964	break;
965	}
966	/* And check if they are suitable: */
967	if ( enmCurrentBus != enmRecommendedDvdBus
968	\|\| enmCurrentType != enmRecommendedDvdType)
969	continue;
970
971	/* Get current attachment port: */
972	iChosenAttachmentPort = comAttachment.GetPort();
973	fSuccess = comAttachment.isOk();
974	if (!fSuccess)
975	{
976	UINotificationMessage::cannotAcquireMediumAttachmentParameter(comAttachment);
977	break;
978	}
979	/* Get current attachment device: */
980	iChosenAttachmentDevice = comAttachment.GetDevice();
981	fSuccess = comAttachment.isOk();
982	if (!fSuccess)
983	{
984	UINotificationMessage::cannotAcquireMediumAttachmentParameter(comAttachment);
985	break;
986	}
987
988	/* Everything is nice it seems: */
989	comChosenAttachment = comAttachment;
990	strChosenControllerName = strControllerName;
991	break;
992	}
993	AssertMsgReturn(!comChosenAttachment.isNull(), ("Storage Controller is NOT properly configured!\n"), false);
994
995	/* Get medium to mount: */
996	const UIMedium guiMedium = uiCommon().medium(uMediumId);
997	const CMedium comMedium = guiMedium.medium();
998
999	/* Mount medium to the predefined port/device: */
1000	comMachine.MountMedium(strChosenControllerName,
1001	iChosenAttachmentPort, iChosenAttachmentDevice,
1002	comMedium, false /* force */);
1003	fSuccess = comMachine.isOk();
1004	if (!fSuccess)
1005	{
1006	QWidget *pParent = windowManager().realParentWindow(activeMachineWindow());
1007	msgCenter().cannotRemountMedium(machine(), guiMedium, true /* mount? /, false / retry? */, pParent);
1008	}
1009	else
1010	fSuccess = saveSettings();
1011	}
1012
1013	return fSuccess;
1014	}
1015
1016	void UISession::prepareStorageMenu(QMenu *pMenu,
1017	QObject pListener, const char pszSlotName,
1018	const QString &strControllerName, const StorageSlot &storageSlot)
1019	{
1020	CMachine comMachine = machine();
1021	uiCommon().prepareStorageMenu(pMenu,
1022	pListener, pszSlotName,
1023	comMachine, strControllerName, storageSlot);
1024	}
1025
1026	void UISession::updateMachineStorage(const UIMediumTarget &target, UIActionPool *pActionPool)
1027	{
1028	CMachine comMachine = machine();
1029	uiCommon().updateMachineStorage(comMachine, target, pActionPool);
1030	}
1031
1032	void UISession::acquireWhetherUSBControllerEnabled(bool &fEnabled)
1033	{
1034	fEnabled = false;
1035
1036	/* Check whether USB device filters are available: */
1037	CMachine comMachine = machine();
1038	if (comMachine.isNull())
1039	return;
1040	CUSBDeviceFilters comUSBDeviceFilters = comMachine.GetUSBDeviceFilters();
1041	if (!comMachine.isOk() \|\| comUSBDeviceFilters.isNull())
1042	return;
1043	/* Check whether USB controllers are available: */
1044	CUSBControllerVector comUSBControllers = comMachine.GetUSBControllers();
1045	if (!comMachine.isOk() \|\| comUSBControllers.isEmpty())
1046	return;
1047	/* Check whether USB proxy is available: */
1048	const BOOL fUSBProxyAvailable = comMachine.GetUSBProxyAvailable();
1049	if (!comMachine.isOk() \|\| fUSBProxyAvailable == FALSE)
1050	return;
1051
1052	fEnabled = true;
1053	}
1054
1055	void UISession::acquireWhetherVideoInputDevicesEnabled(bool &fEnabled)
1056	{
1057	fEnabled = false;
1058
1059	/* Check whether video input devices are available: */
1060	CHost comHost = gpGlobalSession->host();
1061	CHostVideoInputDeviceVector comVideoInputDevices = comHost.GetVideoInputDevices();
1062	if (!comHost.isOk() \|\| comVideoInputDevices.isEmpty())
1063	return;
1064	/* Check whether USB controllers are available: */
1065	CMachine comMachine = machine();
1066	if (comMachine.isNull())
1067	return;
1068	CUSBControllerVector comUSBControllers = comMachine.GetUSBControllers();
1069	if (!comMachine.isOk() \|\| comUSBControllers.isEmpty())
1070	return;
1071
1072	fEnabled = true;
1073	}
1074
1075	bool UISession::usbDevices(QList<USBDeviceInfo> &guiUSBDevices)
1076	{
1077	const CHost comHost = gpGlobalSession->host();
1078	const CHostUSBDeviceVector comHostUSBDevices = comHost.GetUSBDevices();
1079	bool fSuccess = comHost.isOk();
1080	if (!fSuccess)
1081	UINotificationMessage::cannotAcquireHostParameter(comHost);
1082	else
1083	{
1084	foreach (const CHostUSBDevice &comHostUSBDevice, comHostUSBDevices)
1085	{
1086	/* Get USB device from current host USB device,
1087	* this stuff requires #include <VBox/com/VirtualBox.h> */
1088	const CUSBDevice comUSBDevice(comHostUSBDevice);
1089
1090	/* Fill structure fields: */
1091	USBDeviceInfo guiUSBDevice;
1092	if (fSuccess)
1093	{
1094	guiUSBDevice.m_uId = comUSBDevice.GetId();
1095	fSuccess = comUSBDevice.isOk();
1096	}
1097	if (fSuccess)
1098	{
1099	/// @todo make sure UICommon::usbDetails is checked for errors as well
1100	guiUSBDevice.m_strName = uiCommon().usbDetails(comUSBDevice);
1101	fSuccess = comUSBDevice.isOk();
1102	}
1103	if (fSuccess)
1104	{
1105	/// @todo make sure UICommon::usbToolTip is checked for errors as well
1106	guiUSBDevice.m_strToolTip = uiCommon().usbToolTip(comUSBDevice);
1107	fSuccess = comUSBDevice.isOk();
1108	}
1109	if (fSuccess)
1110	{
1111	/* Check if that USB device was already attached to this session;
1112	* Nothing to check for errors here because error is valid case as well. */
1113	const CUSBDevice comAttachedDevice = console().FindUSBDeviceById(guiUSBDevice.m_uId);
1114	guiUSBDevice.m_fIsChecked = !comAttachedDevice.isNull();
1115	}
1116	if (fSuccess)
1117	{
1118	guiUSBDevice.m_fIsEnabled = comHostUSBDevice.GetState() != KUSBDeviceState_Unavailable;
1119	fSuccess = comHostUSBDevice.isOk();
1120	}
1121
1122	/* Append or break if necessary: */
1123	if (fSuccess)
1124	guiUSBDevices << guiUSBDevice;
1125	else
1126	break;
1127	}
1128	}
1129	return fSuccess;
1130	}
1131
1132	bool UISession::attachUSBDevice(const QUuid &uId)
1133	{
1134	CConsole comConsole = console();
1135	comConsole.AttachUSBDevice(uId, QString(""));
1136	const bool fSuccess = comConsole.isOk();
1137	if (!fSuccess)
1138	{
1139	CHost comHost = gpGlobalSession->host();
1140	/* Nothing to check for errors here because error is valid case as well. */
1141	CHostUSBDevice comHostUSBDevice = comHost.FindUSBDeviceById(uId);
1142	/* Get USB device from current host USB device,
1143	* this stuff requires #include <VBox/com/VirtualBox.h> */
1144	CUSBDevice comUSBDevice(comHostUSBDevice);
1145	UINotificationMessage::cannotAttachUSBDevice(comConsole, uiCommon().usbDetails(comUSBDevice));
1146	/// @todo make sure UICommon::usbDetails is checked for errors as well
1147	}
1148	return fSuccess;
1149	}
1150
1151	bool UISession::detachUSBDevice(const QUuid &uId)
1152	{
1153	CConsole comConsole = console();
1154	comConsole.DetachUSBDevice(uId);
1155	const bool fSuccess = comConsole.isOk();
1156	if (!fSuccess)
1157	{
1158	CUSBDevice comUSBDevice = CConsole(comConsole).FindUSBDeviceById(uId);
1159	UINotificationMessage::cannotDetachUSBDevice(comConsole, uiCommon().usbDetails(comUSBDevice));
1160	/// @todo make sure UICommon::usbDetails is checked for errors as well
1161	}
1162	return fSuccess;
1163	}
1164
1165	bool UISession::webcamDevices(QList<WebcamDeviceInfo> &guiWebcamDevices)
1166	{
1167	const CHost comHost = gpGlobalSession->host();
1168	const CHostVideoInputDeviceVector comHostVideoInputDevices = comHost.GetVideoInputDevices();
1169	bool fSuccess = comHost.isOk();
1170	if (!fSuccess)
1171	UINotificationMessage::cannotAcquireHostParameter(comHost);
1172	else
1173	{
1174	CConsole comConsole = console();
1175	CEmulatedUSB comEmulatedUSB = comConsole.GetEmulatedUSB();
1176	fSuccess = comConsole.isOk();
1177	if (!fSuccess)
1178	UINotificationMessage::cannotAcquireConsoleParameter(comConsole);
1179	else
1180	{
1181	const QVector<QString> attachedWebcamPaths = comEmulatedUSB.GetWebcams();
1182	fSuccess = comEmulatedUSB.isOk();
1183	if (!fSuccess)
1184	UINotificationMessage::cannotAcquireEmulatedUSBParameter(comEmulatedUSB);
1185	else
1186	{
1187	foreach (const CHostVideoInputDevice &comHostVideoInputDevice, comHostVideoInputDevices)
1188	{
1189	/* Fill structure fields: */
1190	WebcamDeviceInfo guiWebcamDevice;
1191	if (fSuccess)
1192	{
1193	guiWebcamDevice.m_strName = comHostVideoInputDevice.GetName();
1194	fSuccess = comHostVideoInputDevice.isOk();
1195	}
1196	if (fSuccess)
1197	{
1198	guiWebcamDevice.m_strPath = comHostVideoInputDevice.GetPath();
1199	fSuccess = comHostVideoInputDevice.isOk();
1200	}
1201	if (fSuccess)
1202	{
1203	/// @todo make sure UICommon::usbToolTip is checked for errors as well
1204	guiWebcamDevice.m_strToolTip = uiCommon().usbToolTip(comHostVideoInputDevice);
1205	fSuccess = comHostVideoInputDevice.isOk();
1206	}
1207	if (fSuccess)
1208	guiWebcamDevice.m_fIsChecked = attachedWebcamPaths.contains(guiWebcamDevice.m_strPath);
1209
1210	/* Append or break if necessary: */
1211	if (fSuccess)
1212	guiWebcamDevices << guiWebcamDevice;
1213	else
1214	break;
1215	}
1216	}
1217	}
1218	}
1219	return fSuccess;
1220	}
1221
1222	bool UISession::webcamAttach(const QString &strPath, const QString &strName)
1223	{
1224	CConsole comConsole = console();
1225	CEmulatedUSB comDispatcher = comConsole.GetEmulatedUSB();
1226	bool fSuccess = comConsole.isOk();
1227	if (!fSuccess)
1228	UINotificationMessage::cannotAcquireConsoleParameter(comConsole);
1229	else
1230	{
1231	comDispatcher.WebcamAttach(strPath, "");
1232	fSuccess = comDispatcher.isOk();
1233	if (!fSuccess)
1234	UINotificationMessage::cannotAttachWebCam(comDispatcher, strName, machineName());
1235	}
1236	return fSuccess;
1237	}
1238
1239	bool UISession::webcamDetach(const QString &strPath, const QString &strName)
1240	{
1241	CConsole comConsole = console();
1242	CEmulatedUSB comDispatcher = comConsole.GetEmulatedUSB();
1243	bool fSuccess = comConsole.isOk();
1244	if (!fSuccess)
1245	UINotificationMessage::cannotAcquireConsoleParameter(comConsole);
1246	else
1247	{
1248	comDispatcher.WebcamDetach(strPath);
1249	fSuccess = comDispatcher.isOk();
1250	if (!fSuccess)
1251	UINotificationMessage::cannotDetachWebCam(comDispatcher, strName, machineName());
1252	}
1253	return fSuccess;
1254	}
1255
1256	bool UISession::acquireWhetherNetworkAdapterEnabled(ulong uSlot, bool &fEnabled)
1257	{
1258	CMachine comMachine = machine();
1259	CNetworkAdapter comAdapter = comMachine.GetNetworkAdapter(uSlot);
1260	bool fSuccess = comMachine.isOk();
1261	if (!fSuccess)
1262	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1263	else
1264	{
1265	const BOOL fAdapterEnabled = comAdapter.GetEnabled();
1266	fSuccess = comAdapter.isOk();
1267	if (!fSuccess)
1268	UINotificationMessage::cannotAcquireNetworkAdapterParameter(comAdapter);
1269	else
1270	fEnabled = fAdapterEnabled == TRUE;
1271	}
1272	return fSuccess;
1273	}
1274
1275	bool UISession::acquireWhetherAtLeastOneNetworkAdapterEnabled(bool &fEnabled)
1276	{
1277	/* Acquire architecture type: */
1278	KPlatformArchitecture enmArchType = KPlatformArchitecture_None;
1279	bool fSuccess = acquireArchitectureType(enmArchType);
1280	{
1281	/* Acquire system properties: */
1282	CVirtualBox comVBox = gpGlobalSession->virtualBox();
1283	AssertReturn(comVBox.isNotNull(), false);
1284	CPlatformProperties comProperties = comVBox.GetPlatformProperties(enmArchType);
1285	fSuccess = comVBox.isOk();
1286	if (!fSuccess)
1287	UINotificationMessage::cannotAcquireVirtualBoxParameter(comVBox);
1288	else
1289	{
1290	/* Acquire chipset type: */
1291	KChipsetType enmChipsetType = KChipsetType_Null;
1292	fSuccess = acquireChipsetType(enmChipsetType);
1293	if (fSuccess)
1294	{
1295	/* Acquire maximum network adapters count: */
1296	const ulong cMaxNetworkAdapters = comProperties.GetMaxNetworkAdapters(enmChipsetType);
1297	fSuccess = comProperties.isOk();
1298	if (!fSuccess)
1299	UINotificationMessage::cannotAcquirePlatformPropertiesParameter(comProperties);
1300	else
1301	{
1302	/* Search for 1st enabled adapter: */
1303	for (ulong uSlot = 0; uSlot < cMaxNetworkAdapters; ++uSlot)
1304	{
1305	bool fAdapterEnabled = false;
1306	fSuccess = acquireWhetherNetworkAdapterEnabled(uSlot, fAdapterEnabled);
1307	if (!fSuccess)
1308	break;
1309	if (!fAdapterEnabled)
1310	continue;
1311	fEnabled = true;
1312	break;
1313	}
1314	}
1315	}
1316	}
1317	}
1318	return fSuccess;
1319	}
1320
1321	bool UISession::acquireWhetherNetworkCableConnected(ulong uSlot, bool &fConnected)
1322	{
1323	CMachine comMachine = machine();
1324	CNetworkAdapter comAdapter = comMachine.GetNetworkAdapter(uSlot);
1325	bool fSuccess = comMachine.isOk();
1326	if (!fSuccess)
1327	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1328	else
1329	{
1330	const BOOL fCableConnected = comAdapter.GetCableConnected();
1331	fSuccess = comAdapter.isOk();
1332	if (!fSuccess)
1333	UINotificationMessage::cannotAcquireNetworkAdapterParameter(comAdapter);
1334	else
1335	fConnected = fCableConnected == TRUE;
1336	}
1337	return fSuccess;
1338	}
1339
1340	bool UISession::setNetworkCableConnected(ulong uSlot, bool fConnected)
1341	{
1342	CMachine comMachine = machine();
1343	CNetworkAdapter comAdapter = comMachine.GetNetworkAdapter(uSlot);
1344	bool fSuccess = comMachine.isOk();
1345	if (!fSuccess)
1346	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1347	else
1348	{
1349	comAdapter.SetCableConnected(fConnected);
1350	fSuccess = comAdapter.isOk();
1351	if (!fSuccess)
1352	UINotificationMessage::cannotToggleNetworkCable(comAdapter, machineName(), fConnected);
1353	}
1354	return fSuccess;
1355	}
1356
1357	bool UISession::guestAdditionsUpgradable()
1358	{
1359	if (!machine().isOk())
1360	return false;
1361
1362	/* Auto GA update is currently for Windows and Linux guests only */
1363	bool fIsWindowOrLinux = gpGlobalSession->guestOSTypeManager().isLinux(uimachine()->osTypeId())
1364	\|\| gpGlobalSession->guestOSTypeManager().isWindows(uimachine()->osTypeId());
1365
1366	if (!fIsWindowOrLinux)
1367	return false;
1368
1369	/* Also check whether we have something to update automatically: */
1370	if (m_ulGuestAdditionsRunLevel < (ulong)KAdditionsRunLevelType_Userland)
1371	return false;
1372
1373	return true;
1374	}
1375
1376	bool UISession::acquireGuestAdditionsVersion(QString &strVersion)
1377	{
1378	CGuest comGuest = guest();
1379	const QString strGAVersion = comGuest.GetAdditionsVersion();
1380	const bool fSuccess = comGuest.isOk();
1381	if (!fSuccess)
1382	UINotificationMessage::cannotAcquireGuestParameter(comGuest);
1383	else
1384	strVersion = strGAVersion;
1385	return fSuccess;
1386	}
1387
1388	bool UISession::acquireGuestAdditionsRevision(ulong &uRevision)
1389	{
1390	CGuest comGuest = guest();
1391	const ULONG uGARevision = comGuest.GetAdditionsRevision();
1392	const bool fSuccess = comGuest.isOk();
1393	if (!fSuccess)
1394	UINotificationMessage::cannotAcquireGuestParameter(comGuest);
1395	else
1396	uRevision = uGARevision;
1397	return fSuccess;
1398	}
1399
1400	bool UISession::notifyGuiFocusChange(bool fInfocus)
1401	{
1402	CMachine comMachine = machine();
1403	comMachine.SetGuestProperty(VBOX_GUI_FOCUS_CHANGE_GUEST_PROP_NAME, fInfocus ? "1" : "0", "RDONLYGUEST,TRANSIENT");
1404	return comMachine.isOk();
1405	}
1406
1407	bool UISession::acquireWhetherAudioAdapterPresent(bool &fPresent)
1408	{
1409	CMachine comMachine = machine();
1410	if (comMachine.isNull())
1411	return false;
1412	CAudioSettings comSettings = comMachine.GetAudioSettings();
1413	const bool fSuccess = comMachine.isOk();
1414	if (!fSuccess)
1415	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1416	else
1417	{
1418	CAudioAdapter comAdapter = comSettings.GetAdapter();
1419	fPresent = comSettings.isOk() && comAdapter.isNotNull();
1420	}
1421	return fSuccess;
1422	}
1423
1424	bool UISession::acquireWhetherAudioAdapterEnabled(bool &fEnabled)
1425	{
1426	CMachine comMachine = machine();
1427	CAudioSettings comSettings = comMachine.GetAudioSettings();
1428	bool fSuccess = comMachine.isOk();
1429	if (!fSuccess)
1430	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1431	else
1432	{
1433	CAudioAdapter comAdapter = comSettings.GetAdapter();
1434	fSuccess = comSettings.isOk();
1435	if (!fSuccess)
1436	UINotificationMessage::cannotAcquireAudioSettingsParameter(comSettings);
1437	{
1438	const BOOL fAdapterEnabled = comAdapter.GetEnabled();
1439	fSuccess = comAdapter.isOk();
1440	if (!fSuccess)
1441	UINotificationMessage::cannotAcquireAudioAdapterParameter(comAdapter);
1442	else
1443	fEnabled = fAdapterEnabled == TRUE;
1444	}
1445	}
1446	return fSuccess;
1447	}
1448
1449	bool UISession::acquireWhetherAudioAdapterOutputEnabled(bool &fEnabled)
1450	{
1451	CMachine comMachine = machine();
1452	CAudioSettings comSettings = comMachine.GetAudioSettings();
1453	bool fSuccess = comMachine.isOk();
1454	if (!fSuccess)
1455	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1456	else
1457	{
1458	CAudioAdapter comAdapter = comSettings.GetAdapter();
1459	fSuccess = comSettings.isOk();
1460	if (!fSuccess)
1461	UINotificationMessage::cannotAcquireAudioSettingsParameter(comSettings);
1462	{
1463	const BOOL fOutputEnabled = comAdapter.GetEnabledOut();
1464	fSuccess = comAdapter.isOk();
1465	if (!fSuccess)
1466	UINotificationMessage::cannotAcquireAudioAdapterParameter(comAdapter);
1467	else
1468	fEnabled = fOutputEnabled == TRUE;
1469	}
1470	}
1471	return fSuccess;
1472	}
1473
1474	bool UISession::acquireWhetherAudioAdapterInputEnabled(bool &fEnabled)
1475	{
1476	CMachine comMachine = machine();
1477	CAudioSettings comSettings = comMachine.GetAudioSettings();
1478	bool fSuccess = comMachine.isOk();
1479	if (!fSuccess)
1480	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1481	else
1482	{
1483	CAudioAdapter comAdapter = comSettings.GetAdapter();
1484	fSuccess = comSettings.isOk();
1485	if (!fSuccess)
1486	UINotificationMessage::cannotAcquireAudioSettingsParameter(comSettings);
1487	{
1488	const BOOL fInputEnabled = comAdapter.GetEnabledIn();
1489	fSuccess = comAdapter.isOk();
1490	if (!fSuccess)
1491	UINotificationMessage::cannotAcquireAudioAdapterParameter(comAdapter);
1492	else
1493	fEnabled = fInputEnabled == TRUE;
1494	}
1495	}
1496	return fSuccess;
1497	}
1498
1499	bool UISession::setAudioAdapterOutputEnabled(bool fEnabled)
1500	{
1501	CMachine comMachine = machine();
1502	CAudioSettings comSettings = comMachine.GetAudioSettings();
1503	bool fSuccess = comMachine.isOk();
1504	if (!fSuccess)
1505	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1506	else
1507	{
1508	CAudioAdapter comAdapter = comSettings.GetAdapter();
1509	fSuccess = comSettings.isOk();
1510	if (!fSuccess)
1511	UINotificationMessage::cannotAcquireAudioSettingsParameter(comSettings);
1512	{
1513	comAdapter.SetEnabledOut(fEnabled);
1514	fSuccess = comAdapter.isOk();
1515	if (!fSuccess)
1516	UINotificationMessage::cannotToggleAudioOutput(comAdapter, machineName(), fEnabled);
1517	}
1518	}
1519	return fSuccess;
1520	}
1521
1522	bool UISession::setAudioAdapterInputEnabled(bool fEnabled)
1523	{
1524	CMachine comMachine = machine();
1525	CAudioSettings comSettings = comMachine.GetAudioSettings();
1526	bool fSuccess = comMachine.isOk();
1527	if (!fSuccess)
1528	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1529	else
1530	{
1531	CAudioAdapter comAdapter = comSettings.GetAdapter();
1532	fSuccess = comSettings.isOk();
1533	if (!fSuccess)
1534	UINotificationMessage::cannotAcquireAudioSettingsParameter(comSettings);
1535	{
1536	comAdapter.SetEnabledIn(fEnabled);
1537	fSuccess = comAdapter.isOk();
1538	if (!fSuccess)
1539	UINotificationMessage::cannotToggleAudioInput(comAdapter, machineName(), fEnabled);
1540	}
1541	}
1542	return fSuccess;
1543	}
1544
1545	UIFrameBuffer *UISession::frameBuffer(ulong uScreenId) const
1546	{
1547	return m_frameBufferVector.value((int)uScreenId, 0);
1548	}
1549
1550	QSize UISession::frameBufferSize(ulong uScreenId) const
1551	{
1552	UIFrameBuffer *pFramebuffer = frameBuffer(uScreenId);
1553	return pFramebuffer ? QSize(pFramebuffer->width(), pFramebuffer->height()) : QSize();
1554	}
1555
1556	bool UISession::acquireGraphicsControllerType(KGraphicsControllerType &enmType)
1557	{
1558	CMachine comMachine = machine();
1559	CGraphicsAdapter comAdapter = comMachine.GetGraphicsAdapter();
1560	bool fSuccess = comMachine.isOk();
1561	if (!fSuccess)
1562	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1563	else
1564	{
1565	const KGraphicsControllerType enmControllerType = comAdapter.GetGraphicsControllerType();
1566	fSuccess = comAdapter.isOk();
1567	if (!fSuccess)
1568	UINotificationMessage::cannotAcquireGraphicsAdapterParameter(comAdapter);
1569	else
1570	enmType = enmControllerType;
1571	}
1572	return fSuccess;
1573	}
1574
1575	bool UISession::acquireVRAMSize(ulong &uSize)
1576	{
1577	CMachine comMachine = machine();
1578	CGraphicsAdapter comAdapter = comMachine.GetGraphicsAdapter();
1579	bool fSuccess = comMachine.isOk();
1580	if (!fSuccess)
1581	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1582	else
1583	{
1584	const ULONG uVRAMSize = comAdapter.GetVRAMSize();
1585	fSuccess = comAdapter.isOk();
1586	if (!fSuccess)
1587	UINotificationMessage::cannotAcquireGraphicsAdapterParameter(comAdapter);
1588	else
1589	uSize = uVRAMSize;
1590	}
1591	return fSuccess;
1592	}
1593
1594	bool UISession::acquireWhetherAccelerate3DEnabled(bool &fEnabled)
1595	{
1596	CMachine comMachine = machine();
1597	CGraphicsAdapter comAdapter = comMachine.GetGraphicsAdapter();
1598	bool fSuccess = comMachine.isOk();
1599	if (!fSuccess)
1600	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1601	else
1602	{
1603	const BOOL fAccelerate3DEnabeld = comAdapter.GetAccelerate3DEnabled();
1604	fSuccess = comAdapter.isOk();
1605	if (!fSuccess)
1606	UINotificationMessage::cannotAcquireGraphicsAdapterParameter(comAdapter);
1607	else
1608	fEnabled = fAccelerate3DEnabeld == TRUE;
1609	}
1610	return fSuccess;
1611	}
1612
1613	bool UISession::acquireMonitorCount(ulong &uCount)
1614	{
1615	// WORKAROUND:
1616	// We certainly don't want to get into
1617	// 'no visible screens' case if something
1618	// gone wrong... Inventing sane default.
1619	uCount = 1;
1620
1621	CMachine comMachine = machine();
1622	if (comMachine.isNull())
1623	return false;
1624	CGraphicsAdapter comAdapter = comMachine.GetGraphicsAdapter();
1625	bool fSuccess = comMachine.isOk();
1626	if (!fSuccess)
1627	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1628	else
1629	{
1630	const ULONG uMonitorCount = comAdapter.GetMonitorCount();
1631	fSuccess = comAdapter.isOk();
1632	if (!fSuccess)
1633	UINotificationMessage::cannotAcquireGraphicsAdapterParameter(comAdapter);
1634	else
1635	uCount = uMonitorCount;
1636	}
1637	return fSuccess;
1638	}
1639
1640	bool UISession::acquireGuestScreenParameters(ulong uScreenId,
1641	ulong &uWidth, ulong &uHeight, ulong &uBitsPerPixel,
1642	long &xOrigin, long &yOrigin, KGuestMonitorStatus &enmMonitorStatus)
1643	{
1644	CDisplay comDisplay = display();
1645	ULONG uGuestWidth = 0, uGuestHeight = 0, uGuestBitsPerPixel = 0;
1646	LONG iGuestXOrigin = 0, iGuestYOrigin = 0;
1647	KGuestMonitorStatus enmGuestMonitorStatus = KGuestMonitorStatus_Disabled;
1648	comDisplay.GetScreenResolution(uScreenId, uGuestWidth, uGuestHeight, uGuestBitsPerPixel,
1649	iGuestXOrigin, iGuestYOrigin, enmGuestMonitorStatus);
1650	const bool fSuccess = comDisplay.isOk();
1651	if (!fSuccess)
1652	UINotificationMessage::cannotAcquireDisplayParameter(comDisplay);
1653	else
1654	{
1655	uWidth = uGuestWidth;
1656	uHeight = uGuestHeight;
1657	uBitsPerPixel = uGuestBitsPerPixel;
1658	xOrigin = iGuestXOrigin;
1659	yOrigin = iGuestYOrigin;
1660	enmMonitorStatus = enmGuestMonitorStatus;
1661	}
1662	return fSuccess;
1663	}
1664
1665	bool UISession::acquireSavedGuestScreenInfo(ulong uScreenId,
1666	long &xOrigin, long &yOrigin,
1667	ulong &uWidth, ulong &uHeight, bool &fEnabled)
1668	{
1669	CMachine comMachine = machine();
1670	ULONG uGuestXOrigin = 0, uGuestYOrigin = 0, uGuestWidth = 0, uGuestHeight = 0;
1671	BOOL fGuestEnabled = FALSE;
1672	comMachine.QuerySavedGuestScreenInfo(uScreenId, uGuestXOrigin, uGuestYOrigin, uGuestWidth, uGuestHeight, fGuestEnabled);
1673	const bool fSuccess = comMachine.isOk();
1674	if (!fSuccess)
1675	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1676	else
1677	{
1678	xOrigin = uGuestXOrigin;
1679	yOrigin = uGuestYOrigin;
1680	uWidth = uGuestWidth;
1681	uHeight = uGuestHeight;
1682	fEnabled = fGuestEnabled == TRUE;
1683	}
1684	return fSuccess;
1685	}
1686
1687	bool UISession::setVideoModeHint(ulong uScreenId, bool fEnabled, bool fChangeOrigin, long xOrigin, long yOrigin,
1688	ulong uWidth, ulong uHeight, ulong uBitsPerPixel, bool fNotify)
1689	{
1690	CDisplay comDisplay = display();
1691	comDisplay.SetVideoModeHint(uScreenId, fEnabled, fChangeOrigin, xOrigin, yOrigin,
1692	uWidth, uHeight, uBitsPerPixel, fNotify);
1693	const bool fSuccess = comDisplay.isOk();
1694	if (!fSuccess)
1695	UINotificationMessage::cannotChangeDisplayParameter(comDisplay);
1696	return fSuccess;
1697	}
1698
1699	bool UISession::acquireVideoModeHint(ulong uScreenId, bool &fEnabled, bool &fChangeOrigin,
1700	long &xOrigin, long &yOrigin, ulong &uWidth, ulong &uHeight,
1701	ulong &uBitsPerPixel)
1702	{
1703	CDisplay comDisplay = display();
1704	BOOL fGuestEnabled = FALSE, fGuestChangeOrigin = FALSE;
1705	LONG iGuestXOrigin = 0, iGuestYOrigin = 0;
1706	ULONG uGuestWidth = 0, uGuestHeight = 0, uGuestBitsPerPixel = 0;
1707	comDisplay.GetVideoModeHint(uScreenId, fGuestEnabled, fGuestChangeOrigin,
1708	iGuestXOrigin, iGuestYOrigin, uGuestWidth, uGuestHeight,
1709	uGuestBitsPerPixel);
1710	const bool fSuccess = comDisplay.isOk();
1711	if (!fSuccess)
1712	UINotificationMessage::cannotAcquireDisplayParameter(comDisplay);
1713	else
1714	{
1715	fEnabled = fGuestEnabled == TRUE;
1716	fChangeOrigin = fGuestChangeOrigin == TRUE;
1717	xOrigin = iGuestXOrigin;
1718	yOrigin = iGuestYOrigin;
1719	uWidth = uGuestWidth;
1720	uHeight = uGuestHeight;
1721	uBitsPerPixel = uGuestBitsPerPixel;
1722	}
1723	return fSuccess;
1724	}
1725
1726	bool UISession::acquireScreenShot(ulong uScreenId, ulong uWidth, ulong uHeight, KBitmapFormat enmFormat, uchar *pBits)
1727	{
1728	CDisplay comDisplay = display();
1729	bool fSuccess = false;
1730	/* For separate process: */
1731	if (uiCommon().isSeparateProcess())
1732	{
1733	/* Take screen-data to array first: */
1734	const QVector<BYTE> screenData = comDisplay.TakeScreenShotToArray(uScreenId, uWidth, uHeight, enmFormat);
1735	fSuccess = comDisplay.isOk();
1736	if (!fSuccess)
1737	UINotificationMessage::cannotAcquireDisplayParameter(comDisplay);
1738	else
1739	{
1740	/* And copy that data to screen-shot if it is Ok: */
1741	if (!screenData.isEmpty())
1742	memcpy(pBits, screenData.data(), uWidth * uHeight * 4);
1743	}
1744	}
1745	/* For the same process: */
1746	else
1747	{
1748	/* Take the screen-shot directly: */
1749	comDisplay.TakeScreenShot(uScreenId, pBits, uWidth, uHeight, enmFormat);
1750	fSuccess = comDisplay.isOk();
1751	if (!fSuccess)
1752	UINotificationMessage::cannotAcquireDisplayParameter(comDisplay);
1753	}
1754	return fSuccess;
1755	}
1756
1757	bool UISession::acquireSavedScreenshotInfo(ulong uScreenId, ulong &uWidth, ulong &uHeight, QVector<KBitmapFormat> &formats)
1758	{
1759	CMachine comMachine = machine();
1760	ULONG uGuestWidth = 0, uGuestHeight = 0;
1761	QVector<KBitmapFormat> guestFormats = comMachine.QuerySavedScreenshotInfo(uScreenId, uGuestWidth, uGuestHeight);
1762	const bool fSuccess = comMachine.isOk();
1763	if (!fSuccess)
1764	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1765	else
1766	{
1767	uWidth = uGuestWidth;
1768	uHeight = uGuestHeight;
1769	formats = guestFormats;
1770	}
1771	return fSuccess;
1772	}
1773
1774	bool UISession::acquireSavedScreenshot(ulong uScreenId, KBitmapFormat enmFormat,
1775	ulong &uWidth, ulong &uHeight, QVector<BYTE> &screenshot)
1776	{
1777	CMachine comMachine = machine();
1778	ULONG uGuestWidth = 0, uGuestHeight = 0;
1779	const QVector<BYTE> guestScreenshot = comMachine.ReadSavedScreenshotToArray(uScreenId, enmFormat,
1780	uGuestWidth, uGuestHeight);
1781	const bool fSuccess = comMachine.isOk();
1782	if (!fSuccess)
1783	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1784	else
1785	{
1786	uWidth = uGuestWidth;
1787	uHeight = uGuestHeight;
1788	screenshot = guestScreenshot;
1789	}
1790	return fSuccess;
1791	}
1792
1793	bool UISession::notifyScaleFactorChange(ulong uScreenId, ulong uScaleFactorWMultiplied, ulong uScaleFactorHMultiplied)
1794	{
1795	CDisplay comDisplay = display();
1796	comDisplay.NotifyScaleFactorChange(uScreenId, uScaleFactorWMultiplied, uScaleFactorHMultiplied);
1797	const bool fSuccess = comDisplay.isOk();
1798	if (!fSuccess)
1799	UINotificationMessage::cannotChangeDisplayParameter(comDisplay);
1800	return fSuccess;
1801	}
1802
1803	bool UISession::notifyHiDPIOutputPolicyChange(bool fUnscaledHiDPI)
1804	{
1805	CDisplay comDisplay = display();
1806	comDisplay.NotifyHiDPIOutputPolicyChange(fUnscaledHiDPI);
1807	const bool fSuccess = comDisplay.isOk();
1808	if (!fSuccess)
1809	UINotificationMessage::cannotChangeDisplayParameter(comDisplay);
1810	return fSuccess;
1811	}
1812
1813	bool UISession::setSeamlessMode(bool fEnabled)
1814	{
1815	CDisplay comDisplay = display();
1816	comDisplay.SetSeamlessMode(fEnabled);
1817	const bool fSuccess = comDisplay.isOk();
1818	if (!fSuccess)
1819	UINotificationMessage::cannotChangeDisplayParameter(comDisplay);
1820	return fSuccess;
1821	}
1822
1823	bool UISession::viewportChanged(ulong uScreenId, ulong xOrigin, ulong yOrigin, ulong uWidth, ulong uHeight)
1824	{
1825	CDisplay comDisplay = display();
1826	if (comDisplay.isNull())
1827	return false;
1828	comDisplay.ViewportChanged(uScreenId, xOrigin, yOrigin, uWidth, uHeight);
1829	const bool fSuccess = comDisplay.isOk();
1830	if (!fSuccess)
1831	UINotificationMessage::cannotChangeDisplayParameter(comDisplay);
1832	return fSuccess;
1833	}
1834
1835	bool UISession::invalidateAndUpdate()
1836	{
1837	CDisplay comDisplay = display();
1838	comDisplay.InvalidateAndUpdate();
1839	const bool fSuccess = comDisplay.isOk();
1840	if (!fSuccess)
1841	UINotificationMessage::cannotChangeDisplayParameter(comDisplay);
1842	return fSuccess;
1843	}
1844
1845	bool UISession::invalidateAndUpdateScreen(ulong uScreenId)
1846	{
1847	CDisplay comDisplay = display();
1848	comDisplay.InvalidateAndUpdateScreen(uScreenId);
1849	const bool fSuccess = comDisplay.isOk();
1850	if (!fSuccess)
1851	UINotificationMessage::cannotChangeDisplayParameter(comDisplay);
1852	return fSuccess;
1853	}
1854
1855	bool UISession::acquireWhetherVRDEServerPresent(bool &fPresent)
1856	{
1857	CMachine comMachine = machine();
1858	if (comMachine.isNull())
1859	return false;
1860	CVRDEServer comServer = comMachine.GetVRDEServer();
1861	fPresent = comMachine.isOk() && comServer.isNotNull();
1862	return true;
1863	}
1864
1865	bool UISession::acquireWhetherVRDEServerEnabled(bool &fEnabled)
1866	{
1867	CMachine comMachine = machine();
1868	CVRDEServer comServer = comMachine.GetVRDEServer();
1869	bool fSuccess = comMachine.isOk();
1870	if (!fSuccess)
1871	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1872	else
1873	{
1874	const BOOL fServerEnabled = comServer.GetEnabled();
1875	fSuccess = comServer.isOk();
1876	if (!fSuccess)
1877	UINotificationMessage::cannotAcquireVRDEServerParameter(comServer);
1878	else
1879	fEnabled = fServerEnabled == TRUE;
1880	}
1881	return fSuccess;
1882	}
1883
1884	bool UISession::setVRDEServerEnabled(bool fEnabled)
1885	{
1886	CMachine comMachine = machine();
1887	CVRDEServer comServer = comMachine.GetVRDEServer();
1888	bool fSuccess = comMachine.isOk();
1889	if (!fSuccess)
1890	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1891	else
1892	{
1893	comServer.SetEnabled(fEnabled);
1894	fSuccess = comServer.isOk();
1895	if (!fSuccess)
1896	UINotificationMessage::cannotToggleVRDEServer(comServer, machineName(), fEnabled);
1897	}
1898	return fSuccess;
1899	}
1900
1901	bool UISession::acquireVRDEServerPort(long &iPort)
1902	{
1903	CConsole comConsole = console();
1904	const CVRDEServerInfo comVRDEServerInfo = comConsole.GetVRDEServerInfo();
1905	bool fSuccess = comConsole.isOk();
1906	if (!fSuccess)
1907	UINotificationMessage::cannotAcquireConsoleParameter(comConsole);
1908	else
1909	{
1910	const LONG iVRDEPort = comVRDEServerInfo.GetPort();
1911	fSuccess = comVRDEServerInfo.isOk();
1912	if (!fSuccess)
1913	UINotificationMessage::cannotAcquireVRDEServerInfoParameter(comVRDEServerInfo);
1914	else
1915	iPort = iVRDEPort;
1916	}
1917	return fSuccess;
1918	}
1919
1920	bool UISession::acquireWhetherRecordingSettingsPresent(bool &fPresent)
1921	{
1922	CMachine comMachine = machine();
1923	CRecordingSettings comSettings = comMachine.GetRecordingSettings();
1924	fPresent = comMachine.isOk() && comSettings.isNotNull();
1925	return true;
1926	}
1927
1928	bool UISession::acquireWhetherRecordingSettingsEnabled(bool &fEnabled)
1929	{
1930	CMachine comMachine = machine();
1931	CRecordingSettings comSettings = comMachine.GetRecordingSettings();
1932	bool fSuccess = comMachine.isOk();
1933	if (!fSuccess)
1934	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1935	else
1936	{
1937	const BOOL fSettingsEnabled = comSettings.GetEnabled();
1938	fSuccess = comSettings.isOk();
1939	if (!fSuccess)
1940	UINotificationMessage::cannotAcquireRecordingSettingsParameter(comSettings);
1941	else
1942	fEnabled = fSettingsEnabled == TRUE;
1943	}
1944	return fSuccess;
1945	}
1946
1947	bool UISession::setRecordingSettingsEnabled(bool fEnabled)
1948	{
1949	CMachine comMachine = machine();
1950	CRecordingSettings comSettings = comMachine.GetRecordingSettings();
1951	bool fSuccess = comMachine.isOk();
1952	if (!fSuccess)
1953	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
1954	else
1955	{
1956	comSettings.SetEnabled(fEnabled);
1957	fSuccess = comSettings.isOk();
1958	if (!fSuccess)
1959	UINotificationMessage::cannotToggleRecording(comSettings, machineName(), fEnabled);
1960	}
1961	return fSuccess;
1962	}
1963
1964	bool UISession::acquireDeviceActivity(const QVector<KDeviceType> &deviceTypes, QVector<KDeviceActivity> &states)
1965	{
1966	CConsole comConsole = console();
1967	const QVector<KDeviceActivity> currentStates = comConsole.GetDeviceActivity(deviceTypes);
1968	const bool fSuccess = comConsole.isOk();
1969	if (!fSuccess)
1970	UINotificationMessage::cannotAcquireConsoleParameter(comConsole);
1971	else
1972	states = currentStates;
1973	return fSuccess;
1974	}
1975
1976	void UISession::acquireHardDiskStatusInfo(QString &strInfo, bool &fAttachmentsPresent)
1977	{
1978	CMachine comMachine = machine();
1979	if (comMachine.isNull())
1980	return;
1981	UIDetailsGenerator::acquireHardDiskStatusInfo(comMachine, strInfo, fAttachmentsPresent);
1982	}
1983
1984	void UISession::acquireOpticalDiskStatusInfo(QString &strInfo, bool &fAttachmentsPresent, bool &fAttachmentsMounted)
1985	{
1986	CMachine comMachine = machine();
1987	if (comMachine.isNull())
1988	return;
1989	UIDetailsGenerator::acquireOpticalDiskStatusInfo(comMachine, strInfo, fAttachmentsPresent, fAttachmentsMounted);
1990	}
1991
1992	void UISession::acquireFloppyDiskStatusInfo(QString &strInfo, bool &fAttachmentsPresent, bool &fAttachmentsMounted)
1993	{
1994	CMachine comMachine = machine();
1995	if (comMachine.isNull())
1996	return;
1997	UIDetailsGenerator::acquireFloppyDiskStatusInfo(comMachine, strInfo, fAttachmentsPresent, fAttachmentsMounted);
1998	}
1999
2000	void UISession::acquireAudioStatusInfo(QString &strInfo, bool &fAudioEnabled, bool &fEnabledOutput, bool &fEnabledInput)
2001	{
2002	CMachine comMachine = machine();
2003	if (comMachine.isNull())
2004	return;
2005	UIDetailsGenerator::acquireAudioStatusInfo(comMachine, strInfo, fAudioEnabled, fEnabledOutput, fEnabledInput);
2006	}
2007
2008	void UISession::acquireNetworkStatusInfo(QString &strInfo, bool &fAdaptersPresent, bool &fCablesDisconnected)
2009	{
2010	CMachine comMachine = machine();
2011	if (comMachine.isNull())
2012	return;
2013	UIDetailsGenerator::acquireNetworkStatusInfo(comMachine, strInfo, fAdaptersPresent, fCablesDisconnected);
2014	}
2015
2016	void UISession::acquireUsbStatusInfo(QString &strInfo, bool &fUsbEnableds)
2017	{
2018	CMachine comMachine = machine();
2019	if (comMachine.isNull())
2020	return;
2021	CConsole comConsole = console();
2022	if (comConsole.isNull())
2023	return;
2024	UIDetailsGenerator::acquireUsbStatusInfo(comMachine, comConsole, strInfo, fUsbEnableds);
2025	}
2026
2027	void UISession::acquireSharedFoldersStatusInfo(QString &strInfo, bool &fFoldersPresent)
2028	{
2029	CMachine comMachine = machine();
2030	if (comMachine.isNull())
2031	return;
2032	CConsole comConsole = console();
2033	if (comConsole.isNull())
2034	return;
2035	CGuest comGuest = guest();
2036	if (comGuest.isNull())
2037	return;
2038	UIDetailsGenerator::acquireSharedFoldersStatusInfo(comMachine, comConsole, comGuest, strInfo, fFoldersPresent);
2039	}
2040
2041	void UISession::acquireDisplayStatusInfo(QString &strInfo, bool &fAcceleration3D)
2042	{
2043	CMachine comMachine = machine();
2044	if (comMachine.isNull())
2045	return;
2046	UIDetailsGenerator::acquireDisplayStatusInfo(comMachine, strInfo, fAcceleration3D);
2047	}
2048
2049	void UISession::acquireRecordingStatusInfo(QString &strInfo, bool &fRecordingEnabled, bool &fMachinePaused)
2050	{
2051	CMachine comMachine = machine();
2052	if (comMachine.isNull())
2053	return;
2054	fMachinePaused = isPaused();
2055	UIDetailsGenerator::acquireRecordingStatusInfo(comMachine, strInfo, fRecordingEnabled);
2056	}
2057
2058	void UISession::acquireFeaturesStatusInfo(QString &strInfo, KVMExecutionEngine &enmEngine,
2059	bool fNestedPagingEnabled, bool fUxEnabled,
2060	KParavirtProvider enmProvider)
2061	{
2062	CMachine comMachine = machine();
2063	if (comMachine.isNull())
2064	return;
2065	UIDetailsGenerator::acquireFeaturesStatusInfo(comMachine, strInfo,
2066	enmEngine,
2067	fNestedPagingEnabled, fUxEnabled,
2068	enmProvider);
2069	}
2070
2071	void UISession::generateMachineInformationGeneral(const UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral &fOptions,
2072	UITextTable &returnTable)
2073	{
2074	CMachine comMachine = machine();
2075	returnTable = UIDetailsGenerator::generateMachineInformationGeneral(comMachine, fOptions);
2076	}
2077
2078	void UISession::generateMachineInformationSystem(const UIExtraDataMetaDefs::DetailsElementOptionTypeSystem &fOptions,
2079	UITextTable &returnTable)
2080	{
2081	CMachine comMachine = machine();
2082	returnTable = UIDetailsGenerator::generateMachineInformationSystem(comMachine, fOptions);
2083	}
2084
2085	void UISession::generateMachineInformationDisplay(const UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay &fOptions,
2086	UITextTable &returnTable)
2087	{
2088	CMachine comMachine = machine();
2089	returnTable = UIDetailsGenerator::generateMachineInformationDisplay(comMachine, fOptions);
2090	}
2091
2092	void UISession::generateMachineInformationStorage(const UIExtraDataMetaDefs::DetailsElementOptionTypeStorage &fOptions,
2093	UITextTable &returnTable)
2094	{
2095	CMachine comMachine = machine();
2096	returnTable = UIDetailsGenerator::generateMachineInformationStorage(comMachine, fOptions);
2097	}
2098
2099	void UISession::generateMachineInformationAudio(const UIExtraDataMetaDefs::DetailsElementOptionTypeAudio &fOptions,
2100	UITextTable &returnTable)
2101	{
2102	CMachine comMachine = machine();
2103	returnTable = UIDetailsGenerator::generateMachineInformationAudio(comMachine, fOptions);
2104	}
2105
2106	void UISession::generateMachineInformationNetwork(const UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork &fOptions,
2107	UITextTable &returnTable)
2108	{
2109	CMachine comMachine = machine();
2110	returnTable = UIDetailsGenerator::generateMachineInformationNetwork(comMachine, fOptions);
2111	}
2112	void UISession::generateMachineInformationSerial(const UIExtraDataMetaDefs::DetailsElementOptionTypeSerial &fOptions,
2113	UITextTable &returnTable)
2114	{
2115	CMachine comMachine = machine();
2116	returnTable = UIDetailsGenerator::generateMachineInformationSerial(comMachine, fOptions);
2117	}
2118
2119	void UISession::generateMachineInformationUSB(const UIExtraDataMetaDefs::DetailsElementOptionTypeUsb &fOptions,
2120	UITextTable &returnTable)
2121	{
2122	CMachine comMachine = machine();
2123	returnTable = UIDetailsGenerator::generateMachineInformationUSB(comMachine, fOptions);
2124	}
2125
2126	void UISession::generateMachineInformationSharedFolders(const UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders &fOptions,
2127	UITextTable &returnTable)
2128	{
2129	CMachine comMachine = machine();
2130	returnTable = UIDetailsGenerator::generateMachineInformationSharedFolders(comMachine, fOptions);
2131	}
2132
2133	bool UISession::setLogEnabled(bool fEnabled)
2134	{
2135	CMachineDebugger comDebugger = debugger();
2136	comDebugger.SetLogEnabled(fEnabled ? TRUE : FALSE);
2137	const bool fSuccess = comDebugger.isOk();
2138	if (!fSuccess)
2139	UINotificationMessage::cannotChangeMachineDebuggerParameter(comDebugger);
2140	return fSuccess;
2141	}
2142
2143	bool UISession::acquireWhetherLogEnabled(bool &fEnabled)
2144	{
2145	CMachineDebugger comDebugger = debugger();
2146	if (comDebugger.isNull())
2147	return false;
2148	const BOOL fLogEnabled = comDebugger.GetLogEnabled();
2149	const bool fSuccess = comDebugger.isOk();
2150	if (!fSuccess)
2151	UINotificationMessage::cannotAcquireMachineDebuggerParameter(comDebugger);
2152	else
2153	fEnabled = fLogEnabled == TRUE;
2154	return fSuccess;
2155	}
2156
2157	bool UISession::acquireLogFolder(QString &strFolder)
2158	{
2159	CMachine comMachine = machine();
2160	const QString strLogFolder = comMachine.GetLogFolder();
2161	const bool fSuccess = comMachine.isOk();
2162	if (!fSuccess)
2163	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
2164	else
2165	strFolder = strLogFolder;
2166	return fSuccess;
2167	}
2168
2169	bool UISession::acquireEffectiveParavirtProvider(KParavirtProvider &enmProvider)
2170	{
2171	CMachine comMachine = machine();
2172	if (comMachine.isNull())
2173	return false;
2174	const KParavirtProvider enmParavirtProvider = comMachine.GetEffectiveParavirtProvider();
2175	const bool fSuccess = comMachine.isOk();
2176	if (!fSuccess)
2177	UINotificationMessage::cannotAcquireMachineParameter(comMachine);
2178	else
2179	enmProvider = enmParavirtProvider;
2180	return fSuccess;
2181	}
2182
2183	bool UISession::acquireExecutionEngineType(KVMExecutionEngine &enmType)
2184	{
2185	CMachineDebugger comDebugger = debugger();
2186	if (comDebugger.isNull())
2187	return false;
2188	const KVMExecutionEngine enmEngineType = comDebugger.GetExecutionEngine();
2189	const bool fSuccess = comDebugger.isOk();
2190	if (!fSuccess)
2191	UINotificationMessage::cannotAcquireMachineDebuggerParameter(comDebugger);
2192	else
2193	enmType = enmEngineType;
2194	return fSuccess;
2195	}
2196
2197	bool UISession::acquireWhetherHwVirtExNestedPagingEnabled(bool &fEnabled)
2198	{
2199	CMachineDebugger comDebugger = debugger();
2200	if (comDebugger.isNull())
2201	return false;
2202	const BOOL fFeatureEnabled = comDebugger.GetHWVirtExNestedPagingEnabled();
2203	const bool fSuccess = comDebugger.isOk();
2204	if (!fSuccess)
2205	UINotificationMessage::cannotAcquireMachineDebuggerParameter(comDebugger);
2206	else
2207	fEnabled = fFeatureEnabled == TRUE;
2208	return fSuccess;
2209	}
2210
2211	bool UISession::acquireWhetherHwVirtExUXEnabled(bool &fEnabled)
2212	{
2213	CMachineDebugger comDebugger = debugger();
2214	if (comDebugger.isNull())
2215	return false;
2216	const BOOL fFeatureEnabled = comDebugger.GetHWVirtExUXEnabled();
2217	const bool fSuccess = comDebugger.isOk();
2218	if (!fSuccess)
2219	UINotificationMessage::cannotAcquireMachineDebuggerParameter(comDebugger);
2220	else
2221	fEnabled = fFeatureEnabled == TRUE;
2222	return fSuccess;
2223	}
2224
2225	bool UISession::acquireEffectiveCPULoad(ulong &uLoad)
2226	{
2227	CMachineDebugger comDebugger = debugger();
2228	ULONG uPctExecuting;
2229	ULONG uPctHalted;
2230	ULONG uPctOther;
2231	comDebugger.GetCPULoad(0x7fffffff, uPctExecuting, uPctHalted, uPctOther);
2232	const bool fSuccess = comDebugger.isOk();
2233	if (!fSuccess)
2234	UINotificationMessage::cannotAcquireMachineDebuggerParameter(comDebugger);
2235	else
2236	uLoad = uPctExecuting + uPctOther;
2237	return fSuccess;
2238	}
2239
2240	bool UISession::acquireUptime(LONG64 &iUpTime)
2241	{
2242	CMachineDebugger comDebugger = debugger();
2243	const LONG64 iGuestUpTime = comDebugger.GetUptime();
2244	const bool fSuccess = comDebugger.isOk();
2245	if (!fSuccess)
2246	UINotificationMessage::cannotAcquireMachineDebuggerParameter(comDebugger);
2247	else
2248	iUpTime = iGuestUpTime;
2249	return fSuccess;
2250	}
2251
2252	#ifdef VBOX_WITH_DEBUGGER_GUI
2253	bool UISession::dbgCreated(void *pActionDebug)
2254	{
2255	if (m_pDbgGui)
2256	return true;
2257
2258	RTLDRMOD hLdrMod = uiCommon().getDebuggerModule();
2259	if (hLdrMod == NIL_RTLDRMOD)
2260	return false;
2261
2262	PFNDBGGUICREATE pfnGuiCreate;
2263	int rc = RTLdrGetSymbol(hLdrMod, "DBGGuiCreate", (void**)&pfnGuiCreate);
2264	if (RT_SUCCESS(rc))
2265	{
2266	ISession *pISession = session().raw();
2267	rc = pfnGuiCreate(pISession, &m_pDbgGui, &m_pDbgGuiVT);
2268	if (RT_SUCCESS(rc))
2269	{
2270	if ( DBGGUIVT_ARE_VERSIONS_COMPATIBLE(m_pDbgGuiVT->u32Version, DBGGUIVT_VERSION)
2271	\|\| m_pDbgGuiVT->u32EndVersion == m_pDbgGuiVT->u32Version)
2272	{
2273	m_pDbgGuiVT->pfnSetParent(m_pDbgGui, activeMachineWindow());
2274	m_pDbgGuiVT->pfnSetMenu(m_pDbgGui, pActionDebug);
2275	dbgAdjustRelativePos();
2276	return true;
2277	}
2278
2279	LogRel(("GUI: DBGGuiCreate failed, incompatible versions (loaded %#x/%#x, expected %#x)\n",
2280	m_pDbgGuiVT->u32Version, m_pDbgGuiVT->u32EndVersion, DBGGUIVT_VERSION));
2281	}
2282	else
2283	LogRel(("GUI: DBGGuiCreate failed, rc=%Rrc\n", rc));
2284	}
2285	else
2286	LogRel(("GUI: RTLdrGetSymbol(,\"DBGGuiCreate\",) -> %Rrc\n", rc));
2287
2288	m_pDbgGui = 0;
2289	m_pDbgGuiVT = 0;
2290	return false;
2291	}
2292
2293	void UISession::dbgDestroy()
2294	{
2295	if (m_pDbgGui)
2296	{
2297	m_pDbgGuiVT->pfnDestroy(m_pDbgGui);
2298	m_pDbgGui = 0;
2299	m_pDbgGuiVT = 0;
2300	}
2301	}
2302
2303	void UISession::dbgShowStatistics()
2304	{
2305	const QByteArray &filterBytes = uiCommon().getDebuggerStatisticsFilter().toUtf8();
2306	const QByteArray &expandBytes = uiCommon().getDebuggerStatisticsExpand().toUtf8();
2307	const QByteArray &configBytes = uiCommon().getDebuggerStatisticsConfig().toUtf8();
2308	m_pDbgGuiVT->pfnShowStatistics(m_pDbgGui, filterBytes.constData(), expandBytes.constData(), configBytes.constData());
2309	}
2310
2311	void UISession::dbgShowCommandLine()
2312	{
2313	m_pDbgGuiVT->pfnShowCommandLine(m_pDbgGui);
2314	}
2315
2316	void UISession::dbgAdjustRelativePos()
2317	{
2318	if (m_pDbgGui)
2319	{
2320	const QRect rct = activeMachineWindow()->frameGeometry();
2321	m_pDbgGuiVT->pfnAdjustRelativePos(m_pDbgGui, rct.x(), rct.y(), rct.width(), rct.height());
2322	}
2323	}
2324	#endif /* VBOX_WITH_DEBUGGER_GUI */
2325
2326	bool UISession::acquireWhetherGuestEnteredACPIMode(bool &fEntered)
2327	{
2328	CConsole comConsole = console();
2329	const BOOL fGuestEntered = comConsole.GetGuestEnteredACPIMode();
2330	const bool fSuccess = comConsole.isOk();
2331	if (!fSuccess)
2332	UINotificationMessage::cannotAcquireConsoleParameter(comConsole);
2333	else
2334	fEntered = fGuestEntered == TRUE;
2335	return fSuccess;
2336	}
2337
2338	void UISession::saveState()
2339	{
2340	if ( isPaused()
2341	\|\| (isRunning() && pause()))
2342	{
2343	/* Enable 'manual-override',
2344	* preventing automatic Runtime UI closing: */
2345	uimachine()->setManualOverrideMode(true);
2346
2347	/* Now, do the magic: */
2348	LogRel(("GUI: Saving VM state..\n"));
2349	UINotificationProgressMachineSaveState *pNotification =
2350	new UINotificationProgressMachineSaveState(machine());
2351	connect(pNotification, &UINotificationProgressMachineSaveState::sigMachineStateSaved,
2352	this, &UISession::sltHandleMachineStateSaved);
2353	gpNotificationCenter->append(pNotification);
2354	}
2355	}
2356
2357	void UISession::shutdown()
2358	{
2359	/* Check whether guest is in proper mode: */
2360	bool fValidMode = false;
2361	acquireWhetherGuestEnteredACPIMode(fValidMode);
2362	if (!fValidMode)
2363	UINotificationMessage::cannotSendACPIToMachine();
2364	else
2365	{
2366	/* Now, do the magic: */
2367	LogRel(("GUI: Sending ACPI shutdown signal..\n"));
2368	CConsole comConsole = console();
2369	comConsole.PowerButton();
2370	if (!comConsole.isOk())
2371	UINotificationMessage::cannotACPIShutdownMachine(comConsole);
2372	}
2373	}
2374
2375	void UISession::powerOff(bool fIncludingDiscard)
2376	{
2377	/* Enable 'manual-override',
2378	* preventing automatic Runtime UI closing: */
2379	uimachine()->setManualOverrideMode(true);
2380
2381	/* Now, do the magic: */
2382	LogRel(("GUI: Powering VM off..\n"));
2383	UINotificationProgressMachinePowerOff *pNotification =
2384	new UINotificationProgressMachinePowerOff(machine(),
2385	console(),
2386	fIncludingDiscard);
2387	connect(pNotification, &UINotificationProgressMachinePowerOff::sigMachinePoweredOff,
2388	this, &UISession::sltHandleMachinePoweredOff);
2389	gpNotificationCenter->append(pNotification);
2390	}
2391
2392	void UISession::sltInstallGuestAdditionsFrom(const QString &strSource)
2393	{
2394	if (!guestAdditionsUpgradable())
2395	return sltMountDVDAdHoc(strSource);
2396
2397	/* Update guest additions automatically: */
2398	UINotificationProgressGuestAdditionsInstall *pNotification =
2399	new UINotificationProgressGuestAdditionsInstall(guest(), strSource);
2400	connect(pNotification, &UINotificationProgressGuestAdditionsInstall::sigGuestAdditionsInstallationFailed,
2401	this, &UISession::sltMountDVDAdHoc);
2402	gpNotificationCenter->append(pNotification);
2403	}
2404
2405	void UISession::sltMountDVDAdHoc(const QString &strSource)
2406	{
2407	mountAdHocImage(KDeviceType_DVD, UIMediumDeviceType_DVD, strSource);
2408	}
2409
2410	void UISession::sltDetachCOM()
2411	{
2412	/* Cleanup everything COM related: */
2413	cleanupFramebuffers();
2414	cleanupConsoleEventHandlers();
2415	cleanupCOMStuff();
2416	}
2417
2418	void UISession::sltStateChange(KMachineState enmState)
2419	{
2420	/* Check if something had changed: */
2421	if (m_enmMachineState != enmState)
2422	{
2423	/* Store new data: */
2424	m_enmMachineStatePrevious = m_enmMachineState;
2425	m_enmMachineState = enmState;
2426
2427	/* Notify listeners about machine state changed: */
2428	emit sigMachineStateChange();
2429	}
2430	}
2431
2432	void UISession::sltAdditionsChange()
2433	{
2434	/* Acquire actual states: */
2435	const ulong ulGuestAdditionsRunLevel = guest().GetAdditionsRunLevel();
2436	LONG64 iLastUpdatedIgnored;
2437	const bool fIsGuestSupportsGraphics = guest().GetFacilityStatus(KAdditionsFacilityType_Graphics, iLastUpdatedIgnored)
2438	== KAdditionsFacilityStatus_Active;
2439	const bool fIsGuestSupportsSeamless = guest().GetFacilityStatus(KAdditionsFacilityType_Seamless, iLastUpdatedIgnored)
2440	== KAdditionsFacilityStatus_Active;
2441
2442	/* Check if something had changed: */
2443	if ( m_ulGuestAdditionsRunLevel != ulGuestAdditionsRunLevel
2444	\|\| m_fIsGuestSupportsGraphics != fIsGuestSupportsGraphics
2445	\|\| m_fIsGuestSupportsSeamless != fIsGuestSupportsSeamless)
2446	{
2447	/* Store new data: */
2448	m_ulGuestAdditionsRunLevel = ulGuestAdditionsRunLevel;
2449	m_fIsGuestSupportsGraphics = fIsGuestSupportsGraphics;
2450	m_fIsGuestSupportsSeamless = fIsGuestSupportsSeamless;
2451
2452	/* Notify listeners about GA state really changed: */
2453	LogRel(("GUI: UISession::sltAdditionsChange: GA state really changed, notifying listeners.\n"));
2454	emit sigAdditionsStateActualChange();
2455	}
2456	else
2457	LogRel(("GUI: UISession::sltAdditionsChange: GA state doesn't really changed, still notifying listeners.\n"));
2458
2459	/* Notify listeners about GA state change event came: */
2460	emit sigAdditionsStateChange();
2461	}
2462
2463	void UISession::sltHandleMachineStateSaved(bool fSuccess)
2464	{
2465	/* Let user try again if saving failed: */
2466	if (!fSuccess)
2467	{
2468	/* Disable 'manual-override' finally: */
2469	uimachine()->setManualOverrideMode(false);
2470	}
2471	/* Close Runtime UI otherwise: */
2472	else
2473	uimachine()->closeRuntimeUI();
2474	}
2475
2476	void UISession::sltHandleMachinePoweredOff(bool fSuccess, bool fIncludingDiscard)
2477	{
2478	/* Let user try again if power off failed: */
2479	if (!fSuccess)
2480	{
2481	/* Disable 'manual-override' finally: */
2482	uimachine()->setManualOverrideMode(false);
2483	}
2484	/* Check for other tasks otherwise: */
2485	else
2486	{
2487	if (fIncludingDiscard)
2488	{
2489	/* Now, do more magic! */
2490	UINotificationProgressSnapshotRestore *pNotification =
2491	new UINotificationProgressSnapshotRestore(uiCommon().managedVMUuid());
2492	connect(pNotification, &UINotificationProgressSnapshotRestore::sigSnapshotRestored,
2493	this, &UISession::sltHandleSnapshotRestored);
2494	gpNotificationCenter->append(pNotification);
2495	}
2496	else
2497	uimachine()->closeRuntimeUI();
2498	}
2499	}
2500
2501	void UISession::sltHandleSnapshotRestored(bool)
2502	{
2503	/* Close Runtime UI independent of snapshot restoring state: */
2504	uimachine()->closeRuntimeUI();
2505	}
2506
2507	bool UISession::prepareCOMStuff()
2508	{
2509	/* Open session: */
2510	m_comSession = uiCommon().openSession(uiCommon().managedVMUuid(),
2511	uiCommon().isSeparateProcess()
2512	? KLockType_Shared
2513	: KLockType_VM);
2514	if (m_comSession.isNull())
2515	return false;
2516
2517	/* Get machine: */
2518	m_comMachine = m_comSession.GetMachine();
2519	if (m_comMachine.isNull())
2520	return false;
2521
2522	/* Get console: */
2523	m_comConsole = m_comSession.GetConsole();
2524	if (m_comConsole.isNull())
2525	return false;
2526
2527	/* Get display: */
2528	m_comDisplay = m_comConsole.GetDisplay();
2529	if (m_comDisplay.isNull())
2530	return false;
2531
2532	/* Get guest: */
2533	m_comGuest = m_comConsole.GetGuest();
2534	if (m_comGuest.isNull())
2535	return false;
2536
2537	/* Get mouse: */
2538	m_comMouse = m_comConsole.GetMouse();
2539	if (m_comMouse.isNull())
2540	return false;
2541
2542	/* Get keyboard: */
2543	m_comKeyboard = m_comConsole.GetKeyboard();
2544	if (m_comKeyboard.isNull())
2545	return false;
2546
2547	/* Get debugger: */
2548	m_comDebugger = m_comConsole.GetDebugger();
2549	if (m_comDebugger.isNull())
2550	return false;
2551
2552	/* Update machine attributes: */
2553	m_strMachineName = machine().GetName();
2554	m_strOSTypeId = machine().GetOSTypeId();
2555
2556	/* Update machine-state: */
2557	m_enmMachineState = machine().GetState();
2558
2559	/* True by default: */
2560	return true;
2561	}
2562
2563	void UISession::prepareConsoleEventHandlers()
2564	{
2565	/* Create console event-handler: */
2566	m_pConsoleEventhandler = new UIConsoleEventHandler(this);
2567
2568	/* Console event connections: */
2569	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigAdditionsChange,
2570	this, &UISession::sltAdditionsChange);
2571	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigAudioAdapterChange,
2572	this, &UISession::sigAudioAdapterChange);
2573	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigClipboardModeChange,
2574	this, &UISession::sigClipboardModeChange);
2575	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigClipboardError,
2576	this, &UISession::sigClipboardError);
2577	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigCPUExecutionCapChange,
2578	this, &UISession::sigCPUExecutionCapChange);
2579	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigDnDModeChange,
2580	this, &UISession::sigDnDModeChange);
2581	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigGuestMonitorChange,
2582	this, &UISession::sigGuestMonitorChange);
2583	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigMediumChange,
2584	this, &UISession::sigMediumChange);
2585	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigNetworkAdapterChange,
2586	this, &UISession::sigNetworkAdapterChange);
2587	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigRecordingChange,
2588	this, &UISession::sigRecordingChange);
2589	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigSharedFolderChange,
2590	this, &UISession::sigSharedFolderChange);
2591	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigStateChange,
2592	this, &UISession::sltStateChange);
2593	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigStorageDeviceChange,
2594	this, &UISession::sigStorageDeviceChange);
2595	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigUSBControllerChange,
2596	this, &UISession::sigUSBControllerChange);
2597	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigUSBDeviceStateChange,
2598	this, &UISession::sigUSBDeviceStateChange);
2599	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigVRDEChange,
2600	this, &UISession::sigVRDEChange);
2601	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigRuntimeError,
2602	this, &UISession::sigRuntimeError);
2603
2604	#ifdef VBOX_WS_MAC
2605	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigShowWindow,
2606	this, &UISession::sigShowWindows, Qt::QueuedConnection);
2607	#endif
2608
2609	/* Console keyboard connections: */
2610	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigKeyboardLedsChange,
2611	this, &UISession::sigKeyboardLedsChange);
2612
2613	/* Console mouse connections: */
2614	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigMousePointerShapeChange,
2615	this, &UISession::sigMousePointerShapeChange);
2616	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigMouseCapabilityChange,
2617	this, &UISession::sigMouseCapabilityChange);
2618	connect(m_pConsoleEventhandler, &UIConsoleEventHandler::sigCursorPositionChange,
2619	this, &UISession::sigCursorPositionChange);
2620	}
2621
2622	void UISession::prepareFramebuffers()
2623	{
2624	/* Acquire guest-screen count: */
2625	ulong cGuestScreenCount = 0;
2626	acquireMonitorCount(cGuestScreenCount);
2627	m_frameBufferVector.resize(cGuestScreenCount);
2628
2629	/* Create new frame-buffers: */
2630	for (int iIndex = 0; iIndex < m_frameBufferVector.size(); ++iIndex)
2631	m_frameBufferVector[iIndex] = new UIFrameBuffer;
2632	}
2633
2634	void UISession::prepareConnections()
2635	{
2636	/* UICommon connections: */
2637	connect(&uiCommon(), &UICommon::sigAskToDetachCOM, this, &UISession::sltDetachCOM);
2638	}
2639
2640	void UISession::prepareSignalHandling()
2641	{
2642	#ifdef VBOX_GUI_WITH_KEYS_RESET_HANDLER
2643	struct sigaction sa;
2644	sa.sa_sigaction = &signalHandlerSIGUSR1;
2645	sigemptyset(&sa.sa_mask);
2646	sa.sa_flags = SA_RESTART \| SA_SIGINFO;
2647	sigaction(SIGUSR1, &sa, NULL);
2648	#endif /* VBOX_GUI_WITH_KEYS_RESET_HANDLER */
2649	}
2650
2651	void UISession::cleanupFramebuffers()
2652	{
2653	/* Cleanup framebuffers finally: */
2654	for (int i = m_frameBufferVector.size() - 1; i >= 0; --i)
2655	{
2656	UIFrameBuffer *pFrameBuffer = m_frameBufferVector[i];
2657	if (pFrameBuffer)
2658	{
2659	/* Mark framebuffer as unused: */
2660	pFrameBuffer->setMarkAsUnused(true);
2661	/* Detach framebuffer from Display: */
2662	pFrameBuffer->detach();
2663	/* Delete framebuffer reference: */
2664	delete pFrameBuffer;
2665	}
2666	}
2667	m_frameBufferVector.clear();
2668	}
2669
2670	void UISession::cleanupConsoleEventHandlers()
2671	{
2672	/* Destroy console event-handler: */
2673	delete m_pConsoleEventhandler;
2674	m_pConsoleEventhandler = 0;
2675	}
2676
2677	void UISession::cleanupCOMStuff()
2678	{
2679	/* Detach debugger: */
2680	if (!m_comDebugger.isNull())
2681	m_comDebugger.detach();
2682
2683	/* Detach keyboard: */
2684	if (!m_comKeyboard.isNull())
2685	m_comKeyboard.detach();
2686
2687	/* Detach mouse: */
2688	if (!m_comMouse.isNull())
2689	m_comMouse.detach();
2690
2691	/* Detach guest: */
2692	if (!m_comGuest.isNull())
2693	m_comGuest.detach();
2694
2695	/* Detach display: */
2696	if (!m_comDisplay.isNull())
2697	m_comDisplay.detach();
2698
2699	/* Detach console: */
2700	if (!m_comConsole.isNull())
2701	m_comConsole.detach();
2702
2703	/* Detach machine: */
2704	if (!m_comMachine.isNull())
2705	m_comMachine.detach();
2706
2707	/* Close session: */
2708	if (!m_comSession.isNull() && gpGlobalSession->isVBoxSVCAvailable())
2709	{
2710	m_comSession.UnlockMachine();
2711	m_comSession.detach();
2712	}
2713	}
2714
2715	UIMachineLogic *UISession::machineLogic() const
2716	{
2717	return uimachine() ? uimachine()->machineLogic() : 0;
2718	}
2719
2720	UIMachineWindow *UISession::activeMachineWindow() const
2721	{
2722	return machineLogic() ? machineLogic()->activeMachineWindow() : 0;
2723	}
2724
2725	QWidget *UISession::mainMachineWindow() const
2726	{
2727	return machineLogic() ? machineLogic()->mainMachineWindow() : 0;
2728	}
2729
2730	bool UISession::preprocessInitialization()
2731	{
2732	#ifdef VBOX_WITH_NETFLT
2733	/* Skip network interface name checks if VM in saved state: */
2734	if (!isSaved())
2735	{
2736	/* Make sure all the attached and enabled network
2737	* adapters are present on the host. This check makes sense
2738	* in two cases only - when attachement type is Bridged Network
2739	* or Host-only Interface. NOTE: Only currently enabled
2740	* attachement type is checked (incorrect parameters check for
2741	* currently disabled attachement types is skipped). */
2742	QStringList failedInterfaceNames;
2743	QStringList availableInterfaceNames;
2744
2745	/* Create host network interface names list: */
2746	foreach (const CHostNetworkInterface &comNetIface, gpGlobalSession->host().GetNetworkInterfaces())
2747	{
2748	availableInterfaceNames << comNetIface.GetName();
2749	availableInterfaceNames << comNetIface.GetShortName();
2750	}
2751
2752	/* Enumerate all the virtual network adapters: */
2753	CPlatform comPlatform = machine().GetPlatform();
2754	CPlatformProperties comProperties = gpGlobalSession->virtualBox().GetPlatformProperties(comPlatform.GetArchitecture());
2755	const ulong cCount = comProperties.GetMaxNetworkAdapters(comPlatform.GetChipsetType());
2756	for (ulong uAdapterIndex = 0; uAdapterIndex < cCount; ++uAdapterIndex)
2757	{
2758	CNetworkAdapter comNetworkAdapter = machine().GetNetworkAdapter(uAdapterIndex);
2759	if (comNetworkAdapter.GetEnabled())
2760	{
2761	/* Get physical network interface name for
2762	* currently enabled network attachement type: */
2763	QString strInterfaceName;
2764	switch (comNetworkAdapter.GetAttachmentType())
2765	{
2766	case KNetworkAttachmentType_Bridged:
2767	strInterfaceName = comNetworkAdapter.GetBridgedInterface();
2768	break;
2769	# ifndef VBOX_WITH_VMNET
2770	case KNetworkAttachmentType_HostOnly:
2771	strInterfaceName = comNetworkAdapter.GetHostOnlyInterface();
2772	break;
2773	# endif /* !VBOX_WITH_VMNET */
2774	default:
2775	break;
2776	}
2777
2778	if ( !strInterfaceName.isEmpty()
2779	&& !availableInterfaceNames.contains(strInterfaceName))
2780	{
2781	LogRel(("GUI: Invalid network interface found: %s\n", strInterfaceName.toUtf8().constData()));
2782	failedInterfaceNames << QString("%1 (adapter %2)").arg(strInterfaceName).arg(uAdapterIndex + 1);
2783	}
2784	}
2785	}
2786
2787	/* Check if non-existent interfaces found: */
2788	if (!failedInterfaceNames.isEmpty())
2789	{
2790	if (msgCenter().warnAboutNetworkInterfaceNotFound(machineName(), failedInterfaceNames.join(", ")))
2791	machineLogic()->openNetworkSettingsDialog();
2792	else
2793	{
2794	LogRel(("GUI: Aborting startup due to preprocess initialization issue detected...\n"));
2795	return false;
2796	}
2797	}
2798	}
2799	#endif /* VBOX_WITH_NETFLT */
2800
2801	/* Check for USB enumeration warning. Don't return false even if we have a warning: */
2802	CHost comHost = gpGlobalSession->host();
2803	if (comHost.GetUSBDevices().isEmpty() && comHost.isWarning())
2804	{
2805	/* Do not bitch if USB disabled: */
2806	if (!machine().GetUSBControllers().isEmpty())
2807	{
2808	/* Do not bitch if there are no filters (check if enabled too?): */
2809	if (!machine().GetUSBDeviceFilters().GetDeviceFilters().isEmpty())
2810	UINotificationMessage::cannotEnumerateHostUSBDevices(comHost);
2811	}
2812	}
2813
2814	/* True by default: */
2815	return true;
2816	}
2817
2818	bool UISession::mountAdHocImage(KDeviceType enmDeviceType, UIMediumDeviceType enmMediumType, const QString &strMediumName)
2819	{
2820	/* Get VBox: */
2821	CVirtualBox comVBox = gpGlobalSession->virtualBox();
2822
2823	/* Prepare medium to mount: */
2824	UIMedium guiMedium;
2825
2826	/* The 'none' medium name means ejecting what ever is in the drive,
2827	* in that case => leave the guiMedium variable null. */
2828	if (strMediumName != "none")
2829	{
2830	/* Open the medium: */
2831	const CMedium comMedium = comVBox.OpenMedium(strMediumName, enmDeviceType, KAccessMode_ReadWrite, false /* fForceNewUuid */);
2832	if (!comVBox.isOk() \|\| comMedium.isNull())
2833	{
2834	UINotificationMessage::cannotOpenMedium(comVBox, strMediumName);
2835	return false;
2836	}
2837
2838	/* Make sure medium ID is valid: */
2839	const QUuid uMediumId = comMedium.GetId();
2840	AssertReturn(!uMediumId.isNull(), false);
2841
2842	/* Try to find UIMedium among cached: */
2843	guiMedium = uiCommon().medium(uMediumId);
2844	if (guiMedium.isNull())
2845	{
2846	/* Cache new one if necessary: */
2847	guiMedium = UIMedium(comMedium, enmMediumType, KMediumState_Created);
2848	uiCommon().createMedium(guiMedium);
2849	}
2850	}
2851
2852	/* Search for a suitable storage slots: */
2853	QList<ExactStorageSlot> aFreeStorageSlots;
2854	QList<ExactStorageSlot> aBusyStorageSlots;
2855	foreach (const CStorageController &comController, machine().GetStorageControllers())
2856	{
2857	foreach (const CMediumAttachment &comAttachment, machine().GetMediumAttachmentsOfController(comController.GetName()))
2858	{
2859	/* Look for an optical devices only: */
2860	if (comAttachment.GetType() == enmDeviceType)
2861	{
2862	/* Append storage slot to corresponding list: */
2863	if (comAttachment.GetMedium().isNull())
2864	aFreeStorageSlots << ExactStorageSlot(comController.GetName(), comController.GetBus(),
2865	comAttachment.GetPort(), comAttachment.GetDevice());
2866	else
2867	aBusyStorageSlots << ExactStorageSlot(comController.GetName(), comController.GetBus(),
2868	comAttachment.GetPort(), comAttachment.GetDevice());
2869	}
2870	}
2871	}
2872
2873	/* Make sure at least one storage slot found: */
2874	QList<ExactStorageSlot> sStorageSlots = aFreeStorageSlots + aBusyStorageSlots;
2875	if (sStorageSlots.isEmpty())
2876	{
2877	UINotificationMessage::cannotMountImage(machineName(), strMediumName);
2878	return false;
2879	}
2880
2881	/* Try to mount medium into first available storage slot: */
2882	while (!sStorageSlots.isEmpty())
2883	{
2884	const ExactStorageSlot storageSlot = sStorageSlots.takeFirst();
2885	machine().MountMedium(storageSlot.controller, storageSlot.port, storageSlot.device, guiMedium.medium(), false /* force */);
2886	if (machine().isOk())
2887	break;
2888	}
2889
2890	/* Show error message if necessary: */
2891	if (!machine().isOk())
2892	{
2893	msgCenter().cannotRemountMedium(machine(), guiMedium, true /* mount? /, false / retry? */, activeMachineWindow());
2894	return false;
2895	}
2896
2897	/* Save machine settings: */
2898	if (!saveSettings())
2899	return false;
2900
2901	/* True by default: */
2902	return true;
2903	}
2904
2905	void UISession::recacheMachineMedia()
2906	{
2907	/* Compose a list of machine media: */
2908	CMediumVector comMedia;
2909
2910	/* Enumerate all the controllers: */
2911	foreach (const CStorageController &comController, machine().GetStorageControllers())
2912	{
2913	/* Enumerate all the attachments: */
2914	foreach (const CMediumAttachment &comAttachment, machine().GetMediumAttachmentsOfController(comController.GetName()))
2915	{
2916	/* Skip unrelated device types: */
2917	const KDeviceType enmDeviceType = comAttachment.GetType();
2918	if ( enmDeviceType != KDeviceType_HardDisk
2919	&& enmDeviceType != KDeviceType_Floppy
2920	&& enmDeviceType != KDeviceType_DVD)
2921	continue;
2922	if ( comAttachment.GetIsEjected()
2923	\|\| comAttachment.GetMedium().isNull())
2924	continue;
2925	comMedia.append(comAttachment.GetMedium());
2926	}
2927	}
2928
2929	/* Start media enumeration: */
2930	uiCommon().enumerateMedia(comMedia);
2931	}
2932
2933	/* static */
2934	bool UISession::searchMaxSnapshotIndex(const CMachine &comMachine,
2935	const CSnapshot &comSnapshot,
2936	const QString &strNameTemplate,
2937	ulong &uIndex)
2938	{
2939	bool fSuccess = true;
2940	ulong uMaxIndex = 0;
2941	const QRegularExpression re(QString("^") + strNameTemplate.arg("([0-9]+)") + QString("$"));
2942	if (!comSnapshot.isNull())
2943	{
2944	/* Check current snapshot name: */
2945	const QString strName = comSnapshot.GetName();
2946	fSuccess = comSnapshot.isOk();
2947	if (!fSuccess)
2948	UINotificationMessage::cannotAcquireSnapshotParameter(comSnapshot);
2949	else
2950	{
2951	const QRegularExpressionMatch mt = re.match(strName);
2952	if (mt.hasMatch())
2953	{
2954	const ulong uFoundIndex = mt.captured(1).toULong();
2955	uMaxIndex = uFoundIndex > uMaxIndex ? uFoundIndex : uMaxIndex;
2956	}
2957	/* Traversing all the snapshot children: */
2958	QVector<CSnapshot> comSnapshotChildren = comSnapshot.GetChildren();
2959	fSuccess = comSnapshot.isOk();
2960	if (!fSuccess)
2961	UINotificationMessage::cannotAcquireSnapshotParameter(comSnapshot);
2962	else
2963	foreach (const CSnapshot &comSnapshotChild, comSnapshotChildren)
2964	{
2965	ulong uMaxIndexOfChildren = 0;
2966	fSuccess = searchMaxSnapshotIndex(comMachine, comSnapshotChild, strNameTemplate, uMaxIndexOfChildren);
2967	if (!fSuccess)
2968	break;
2969	uMaxIndex = uMaxIndexOfChildren > uMaxIndex ? uMaxIndexOfChildren : uMaxIndex;
2970	}
2971	}
2972	}
2973	if (fSuccess)
2974	uIndex = uMaxIndex;
2975	return fSuccess;
2976	}
2977
2978	#ifdef VBOX_GUI_WITH_KEYS_RESET_HANDLER
2979	/**
2980	* Custom signal handler. When switching VTs, we might not get release events
2981	* for Ctrl-Alt and in case a savestate is performed on the new VT, the VM will
2982	* be saved with modifier keys stuck. This is annoying enough for introducing
2983	* this hack.
2984	*/
2985	/* static */
2986	static void signalHandlerSIGUSR1(int sig, siginfo_t * /* pInfo /, void /pSecret /)
2987	{
2988	/* Only SIGUSR1 is interesting: */
2989	if (sig == SIGUSR1)
2990	if (gpMachine)
2991	gpMachine->machineLogic()->keyboardHandler()->releaseAllPressedKeys();
2992	}
2993	#endif /* VBOX_GUI_WITH_KEYS_RESET_HANDLER */

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

source: vbox/trunk/src/VBox/Frontends/VirtualBox/src/runtime/UISession.cpp@ 103977

Download in other formats: