UIMachineWindow.cpp

Last change on this file was 106061, checked in by vboxsync, 4 weeks ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 23.7 KB

Line
1	/* $Id: UIMachineWindow.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* VBox Qt GUI - UIMachineWindow class implementation.
4	*/
5
6	/*
7	* Copyright (C) 2010-2024 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 <QCloseEvent>
30	#include <QGridLayout>
31	#include <QProcess>
32	#include <QStyle>
33	#include <QTimer>
34
35	/* GUI includes: */
36	#include "UIActionPoolRuntime.h"
37	#include "UICommon.h"
38	#include "UIConverter.h"
39	#include "UIModalWindowManager.h"
40	#include "UIExtraDataManager.h"
41	#include "UILoggingDefs.h"
42	#include "UIMachine.h"
43	#include "UIMessageCenter.h"
44	#include "UIMachineLogic.h"
45	#include "UIMachineWindow.h"
46	#include "UIMachineWindowNormal.h"
47	#include "UIMachineWindowFullscreen.h"
48	#include "UIMachineWindowSeamless.h"
49	#include "UIMachineWindowScale.h"
50	#include "UIMachineView.h"
51	#include "UIKeyboardHandler.h"
52	#include "UIMouseHandler.h"
53	#include "UITranslationEventListener.h"
54	#include "UIVMCloseDialog.h"
55
56	/* COM includes: */
57	#include "CGraphicsAdapter.h"
58	#include "CSnapshot.h"
59
60	/* Other VBox includes: */
61	#include <VBox/version.h>
62	#ifdef VBOX_BLEEDING_EDGE
63	# include <iprt/buildconfig.h>
64	#endif /* VBOX_BLEEDING_EDGE */
65
66
67	/* static */
68	UIMachineWindow* UIMachineWindow::create(UIMachineLogic *pMachineLogic, ulong uScreenId)
69	{
70	/* Create machine-window: */
71	UIMachineWindow *pMachineWindow = 0;
72	switch (pMachineLogic->visualStateType())
73	{
74	case UIVisualStateType_Normal:
75	pMachineWindow = new UIMachineWindowNormal(pMachineLogic, uScreenId);
76	break;
77	case UIVisualStateType_Fullscreen:
78	pMachineWindow = new UIMachineWindowFullscreen(pMachineLogic, uScreenId);
79	break;
80	case UIVisualStateType_Seamless:
81	pMachineWindow = new UIMachineWindowSeamless(pMachineLogic, uScreenId);
82	break;
83	case UIVisualStateType_Scale:
84	pMachineWindow = new UIMachineWindowScale(pMachineLogic, uScreenId);
85	break;
86	default:
87	AssertMsgFailed(("Incorrect visual state!"));
88	break;
89	}
90	/* Prepare machine-window: */
91	pMachineWindow->prepare();
92	/* Return machine-window: */
93	return pMachineWindow;
94	}
95
96	/* static */
97	void UIMachineWindow::destroy(UIMachineWindow *pWhichWindow)
98	{
99	/* Cleanup machine-window: */
100	pWhichWindow->cleanup();
101	/* Delete machine-window: */
102	delete pWhichWindow;
103	}
104
105	void UIMachineWindow::prepare()
106	{
107	/* Prepare dialog itself: */
108	prepareSelf();
109
110	/* Prepare session-connections: */
111	prepareSessionConnections();
112
113	/* Prepare main-layout: */
114	prepareMainLayout();
115
116	/* Prepare menu: */
117	prepareMenu();
118
119	/* Prepare status-bar: */
120	prepareStatusBar();
121
122	/* Prepare visual-state: */
123	prepareVisualState();
124
125	/* Prepare machine-view: */
126	prepareMachineView();
127
128	/* Prepare notification-center: */
129	prepareNotificationCenter();
130
131	/* Prepare handlers: */
132	prepareHandlers();
133
134	/* Load settings: */
135	loadSettings();
136
137	/* Retranslate window: */
138	sltRetranslateUI();
139	connect(&translationEventListener(), &UITranslationEventListener::sigRetranslateUI,
140	this, &UIMachineWindow::sltRetranslateUI);
141
142	/* Show (must be done before updating the appearance): */
143	showInNecessaryMode();
144
145	/* Update all the elements: */
146	updateAppearanceOf(UIVisualElement_AllStuff);
147
148	#ifdef VBOX_WS_NIX
149	/* Prepare default class/name values: */
150	const QString strWindowClass = QString("VirtualBox Machine");
151	QString strWindowName = strWindowClass;
152	/* Check if we want Window Manager to distinguish Virtual Machine windows: */
153	if (gEDataManager->distinguishMachineWindowGroups(uiCommon().managedVMUuid()))
154	strWindowName = QString("VirtualBox Machine UUID: %1").arg(uiCommon().managedVMUuid().toString());
155	/* Assign WM_CLASS property: */
156	NativeWindowSubsystem::setWMClass(uiCommon().X11ServerAvailable(), this, strWindowName, strWindowClass);
157	/* Tell the WM we are well behaved wrt Xwayland keyboard-grabs: */
158	NativeWindowSubsystem::setXwaylandMayGrabKeyboardFlag(uiCommon().X11ServerAvailable(), this);
159	#endif
160	}
161
162	void UIMachineWindow::cleanup()
163	{
164	/* Save window settings: */
165	saveSettings();
166
167	/* Cleanup handlers: */
168	cleanupHandlers();
169
170	/* Cleanup visual-state: */
171	cleanupVisualState();
172
173	/* Cleanup notification-center: */
174	cleanupNotificationCenter();
175
176	/* Cleanup machine-view: */
177	cleanupMachineView();
178
179	/* Cleanup status-bar: */
180	cleanupStatusBar();
181
182	/* Cleanup menu: */
183	cleanupMenu();
184
185	/* Cleanup main layout: */
186	cleanupMainLayout();
187
188	/* Cleanup session connections: */
189	cleanupSessionConnections();
190	}
191
192	void UIMachineWindow::sltMachineStateChanged()
193	{
194	/* Update window-title: */
195	updateAppearanceOf(UIVisualElement_WindowTitle);
196	}
197
198	UIMachineWindow::UIMachineWindow(UIMachineLogic *pMachineLogic, ulong uScreenId)
199	: QMainWindow(0, pMachineLogic->windowFlags(uScreenId))
200	, m_pMachineLogic(pMachineLogic)
201	, m_pMachineView(0)
202	, m_uScreenId(uScreenId)
203	, m_pMainLayout(0)
204	, m_pTopSpacer(0)
205	, m_pBottomSpacer(0)
206	, m_pLeftSpacer(0)
207	, m_pRightSpacer(0)
208	{
209	}
210
211	UIMachine *UIMachineWindow::uimachine() const
212	{
213	return machineLogic()->uimachine();
214	}
215
216	UIActionPool *UIMachineWindow::actionPool() const
217	{
218	return machineLogic()->actionPool();
219	}
220
221	QString UIMachineWindow::machineName() const
222	{
223	return uimachine()->machineName();
224	}
225
226	bool UIMachineWindow::shouldResizeToGuestDisplay() const
227	{
228	return actionPool()
229	&& actionPool()->action(UIActionIndexRT_M_View_T_GuestAutoresize)
230	&& actionPool()->action(UIActionIndexRT_M_View_T_GuestAutoresize)->isChecked();
231	}
232
233	void UIMachineWindow::adjustMachineViewSize()
234	{
235	/* We need to adjust guest-screen size if necessary: */
236	machineView()->adjustGuestScreenSize();
237	}
238
239	void UIMachineWindow::sendMachineViewSizeHint()
240	{
241	/* Send machine-view size-hint to the guest: */
242	machineView()->resendSizeHint();
243	}
244
245	#ifdef VBOX_WITH_MASKED_SEAMLESS
246	void UIMachineWindow::setMask(const QRegion &region)
247	{
248	/* Call to base-class: */
249	QMainWindow::setMask(region);
250	}
251	#endif /* VBOX_WITH_MASKED_SEAMLESS */
252
253	void UIMachineWindow::updateAppearanceOf(int iElement)
254	{
255	/* Update window title: */
256	if (iElement & UIVisualElement_WindowTitle)
257	{
258	/* Make sure machine state is one of valid: */
259	const KMachineState enmState = uimachine()->machineState();
260	if (enmState == KMachineState_Null)
261	{
262	/* Assign default window title: */
263	setWindowTitle(defaultWindowTitle());
264	}
265	else
266	{
267	/* Prepare full name: */
268	QString strMachineName = machineName();
269
270	/* Append snapshot name: */
271	ulong uSnapshotCount = 0;
272	uimachine()->acquireSnapshotCount(uSnapshotCount);
273	if (uSnapshotCount > 0)
274	{
275	QString strCurrentSnapshotName;
276	uimachine()->acquireCurrentSnapshotName(strCurrentSnapshotName);
277	strMachineName += " (" + strCurrentSnapshotName + ")";
278	}
279
280	/* Append state name: */
281	strMachineName += " [" + gpConverter->toString(enmState) + "]";
282
283	#ifndef VBOX_WS_MAC
284	/* Append user product name (besides macOS): */
285	const QString strUserProductName = uimachine()->machineWindowNamePostfix();
286	strMachineName += " - " + (strUserProductName.isEmpty() ? defaultWindowTitle() : strUserProductName);
287	#endif /* !VBOX_WS_MAC */
288
289	/* Append screen number only if there are more than one present: */
290	ulong cMonitorCount = 0;
291	uimachine()->acquireMonitorCount(cMonitorCount);
292	if (cMonitorCount > 1)
293	strMachineName += QString(" : %1").arg(m_uScreenId + 1);
294
295	/* Assign title finally: */
296	setWindowTitle(strMachineName);
297	}
298	}
299	}
300
301	void UIMachineWindow::sltRetranslateUI()
302	{
303	/* Compose window-title prefix: */
304	m_strWindowTitlePrefix = VBOX_PRODUCT;
305	#ifdef VBOX_BLEEDING_EDGE
306	m_strWindowTitlePrefix += UIMachineWindow::tr(" EXPERIMENTAL build %1r%2 - %3")
307	.arg(RTBldCfgVersion())
308	.arg(RTBldCfgRevisionStr())
309	.arg(VBOX_BLEEDING_EDGE);
310	#endif /* VBOX_BLEEDING_EDGE */
311	/* Update appearance of the window-title: */
312	updateAppearanceOf(UIVisualElement_WindowTitle);
313	}
314
315	bool UIMachineWindow::event(QEvent *pEvent)
316	{
317	/* Call to base-class: */
318	const bool fResult = QMainWindow::event(pEvent);
319
320	/* Handle particular events: */
321	switch (pEvent->type())
322	{
323	case QEvent::WindowActivate:
324	{
325	/* Initiate registration in the modal window manager: */
326	windowManager().setMainWindowShown(this);
327	break;
328	}
329	default:
330	break;
331	}
332
333	/* Return result: */
334	return fResult;
335	}
336
337	void UIMachineWindow::showEvent(QShowEvent *pEvent)
338	{
339	/* Call to base-class: */
340	QMainWindow::showEvent(pEvent);
341
342	/* Initiate registration in the modal window manager: */
343	windowManager().setMainWindowShown(this);
344
345	/* Update appearance for indicator-pool: */
346	updateAppearanceOf(UIVisualElement_IndicatorPool);
347	}
348
349	void UIMachineWindow::hideEvent(QHideEvent *pEvent)
350	{
351	/* Update registration in the modal window manager: */
352	if (windowManager().mainWindowShown() == this)
353	{
354	if (machineLogic()->activeMachineWindow())
355	windowManager().setMainWindowShown(machineLogic()->activeMachineWindow());
356	else
357	windowManager().setMainWindowShown(machineLogic()->mainMachineWindow());
358	}
359
360	/* Call to base-class: */
361	QMainWindow::hideEvent(pEvent);
362	}
363
364	void UIMachineWindow::closeEvent(QCloseEvent *pCloseEvent)
365	{
366	/* Always ignore close-event first: */
367	pCloseEvent->ignore();
368	/* But accept close-event if app quit was requested: */
369	if (uimachine()->isQuitRequested())
370	{
371	pCloseEvent->accept();
372	return;
373	}
374
375	/* In certain cases we need to just request app quit: */
376	if ( !uimachine()->isSessionValid()
377	\|\| uimachine()->isTurnedOff())
378	{
379	uimachine()->closeRuntimeUI();
380	return;
381	}
382
383	/* Make sure machine is in one of the allowed states: */
384	if (!uimachine()->isRunning() && !uimachine()->isPaused() && !uimachine()->isStuck())
385	return;
386
387	/* If there is a close hook script defined: */
388	const QString strScript = gEDataManager->machineCloseHookScript(uiCommon().managedVMUuid());
389	if (!strScript.isEmpty())
390	{
391	/* Execute asynchronously and leave: */
392	QProcess::startDetached(strScript, QStringList() << uiCommon().managedVMUuid().toString());
393	return;
394	}
395
396	/* Choose the close action: */
397	MachineCloseAction closeAction = MachineCloseAction_Invalid;
398
399	/* If default close-action defined and not restricted: */
400	MachineCloseAction defaultCloseAction = uimachine()->defaultCloseAction();
401	MachineCloseAction restrictedCloseActions = uimachine()->restrictedCloseActions();
402	if ((defaultCloseAction != MachineCloseAction_Invalid) &&
403	!(restrictedCloseActions & defaultCloseAction))
404	{
405	switch (defaultCloseAction)
406	{
407	/* If VM is stuck, and the default close-action is 'detach', 'save-state' or 'shutdown',
408	* we should ask the user about what to do: */
409	case MachineCloseAction_Detach:
410	case MachineCloseAction_SaveState:
411	case MachineCloseAction_Shutdown:
412	closeAction = uimachine()->isStuck() ? MachineCloseAction_Invalid : defaultCloseAction;
413	break;
414	/* Otherwise we just use what we have: */
415	default:
416	closeAction = defaultCloseAction;
417	break;
418	}
419	}
420
421	/* If the close-action still undefined: */
422	if (closeAction == MachineCloseAction_Invalid)
423	{
424	/* Prepare close-dialog: */
425	QWidget *pParentDlg = windowManager().realParentWindow(this);
426	bool fInACPIMode = false;
427	uimachine()->acquireWhetherGuestEnteredACPIMode(fInACPIMode);
428	QPointer<UIVMCloseDialog> pCloseDlg = new UIVMCloseDialog(pParentDlg, uimachine(),
429	fInACPIMode,
430	restrictedCloseActions);
431	/* Configure close-dialog: */
432	if (uimachine()->machineWindowIcon())
433	pCloseDlg->setIcon(*uimachine()->machineWindowIcon());
434
435	/* Make sure close-dialog is valid: */
436	if (pCloseDlg->isValid())
437	{
438	/* We are going to show close-dialog: */
439	bool fShowCloseDialog = true;
440	/* Check if VM is paused or stuck: */
441	const bool fWasPaused = uimachine()->isPaused();
442	const bool fIsStuck = uimachine()->isStuck();
443	/* If VM is NOT paused and NOT stuck: */
444	if (!fWasPaused && !fIsStuck)
445	{
446	/* We should pause it first: */
447	const bool fIsPaused = uimachine()->pause();
448	/* If we were unable to pause VM: */
449	if (!fIsPaused)
450	{
451	/* If that is NOT the separate VM process UI: */
452	if (!uiCommon().isSeparateProcess())
453	{
454	/* We are not going to show close-dialog: */
455	fShowCloseDialog = false;
456	}
457	/* If that is the separate VM process UI: */
458	else
459	{
460	// WORKAROUND:
461	// We are going to show close-dialog only
462	// if headless frontend stopped/killed already:
463	KMachineState enmActualState = KMachineState_Null;
464	uimachine()->acquireLiveMachineState(enmActualState);
465	fShowCloseDialog = enmActualState == KMachineState_Null;
466	}
467	}
468	}
469	/* If we are going to show close-dialog: */
470	if (fShowCloseDialog)
471	{
472	/* Show close-dialog to let the user make the choice: */
473	windowManager().registerNewParent(pCloseDlg, pParentDlg);
474	closeAction = static_cast<MachineCloseAction>(pCloseDlg->exec());
475
476	/* Make sure the dialog still valid: */
477	if (!pCloseDlg)
478	return;
479
480	/* If VM was not paused before but paused now,
481	* we should resume it if user canceled dialog or chosen shutdown: */
482	if (!fWasPaused && uimachine()->isPaused() &&
483	(closeAction == MachineCloseAction_Invalid \|\|
484	closeAction == MachineCloseAction_Detach \|\|
485	closeAction == MachineCloseAction_Shutdown))
486	{
487	/* If we unable to resume VM, cancel closing: */
488	if (!uimachine()->unpause())
489	closeAction = MachineCloseAction_Invalid;
490	}
491	}
492	}
493	else
494	{
495	/* Else user misconfigured .vbox file, we will reject closing UI: */
496	closeAction = MachineCloseAction_Invalid;
497	}
498
499	/* Cleanup close-dialog: */
500	delete pCloseDlg;
501	}
502
503	/* Depending on chosen result: */
504	switch (closeAction)
505	{
506	case MachineCloseAction_Detach:
507	{
508	/* Detach GUI: */
509	LogRel(("GUI: Request for close-action to detach GUI.\n"));
510	uimachine()->detachUi();
511	break;
512	}
513	case MachineCloseAction_SaveState:
514	{
515	/* Save VM state: */
516	LogRel(("GUI: Request for close-action to save VM state.\n"));
517	uimachine()->saveState();
518	break;
519	}
520	case MachineCloseAction_Shutdown:
521	{
522	/* Shutdown VM: */
523	LogRel(("GUI: Request for close-action to shutdown VM.\n"));
524	uimachine()->shutdown();
525	break;
526	}
527	case MachineCloseAction_PowerOff:
528	case MachineCloseAction_PowerOff_RestoringSnapshot:
529	{
530	/* Power VM off: */
531	LogRel(("GUI: Request for close-action to power VM off.\n"));
532	ulong uSnapshotCount = 0;
533	uimachine()->acquireSnapshotCount(uSnapshotCount);
534	const bool fDiscardStateOnPowerOff = gEDataManager->discardStateOnPowerOff(uiCommon().managedVMUuid())
535	\|\| closeAction == MachineCloseAction_PowerOff_RestoringSnapshot;
536	uimachine()->powerOff(uSnapshotCount > 0 && fDiscardStateOnPowerOff);
537	break;
538	}
539	default:
540	break;
541	}
542	}
543
544	void UIMachineWindow::prepareSelf()
545	{
546	#ifndef VBOX_WS_MAC
547	/* Set machine-window icon if any: */
548	// On macOS window icon is referenced in info.plist.
549	if (uimachine()->machineWindowIcon())
550	setWindowIcon(*uimachine()->machineWindowIcon());
551	#endif /* !VBOX_WS_MAC */
552	}
553
554	void UIMachineWindow::prepareSessionConnections()
555	{
556	/* We should watch for console events: */
557	connect(uimachine(), &UIMachine::sigMachineStateChange, this, &UIMachineWindow::sltMachineStateChanged);
558	}
559
560	void UIMachineWindow::prepareMainLayout()
561	{
562	/* Create central-widget: */
563	setCentralWidget(new QWidget);
564
565	/* Create main-layout: */
566	m_pMainLayout = new QGridLayout(centralWidget());
567	m_pMainLayout->setContentsMargins(0, 0, 0, 0);
568	m_pMainLayout->setSpacing(0);
569
570	/* Create shifting-spacers: */
571	m_pTopSpacer = new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding);
572	m_pBottomSpacer = new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding);
573	m_pLeftSpacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed);
574	m_pRightSpacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed);
575
576	/* Add shifting-spacers into main-layout: */
577	m_pMainLayout->addItem(m_pTopSpacer, 0, 1);
578	m_pMainLayout->addItem(m_pBottomSpacer, 2, 1);
579	m_pMainLayout->addItem(m_pLeftSpacer, 1, 0);
580	m_pMainLayout->addItem(m_pRightSpacer, 1, 2);
581	}
582
583	void UIMachineWindow::prepareMachineView()
584	{
585	/* Get visual-state type: */
586	UIVisualStateType visualStateType = machineLogic()->visualStateType();
587
588	/* Create machine-view: */
589	m_pMachineView = UIMachineView::create(this, m_uScreenId, visualStateType);
590
591	/* Add machine-view into main-layout: */
592	m_pMainLayout->addWidget(m_pMachineView, 1, 1, viewAlignment(visualStateType));
593
594	/* Install focus-proxy: */
595	setFocusProxy(m_pMachineView);
596	}
597
598	void UIMachineWindow::prepareNotificationCenter()
599	{
600	// for now it will be added from within particular visual mode windows ..
601	}
602
603	void UIMachineWindow::prepareHandlers()
604	{
605	/* Register keyboard-handler: */
606	machineLogic()->keyboardHandler()->prepareListener(m_uScreenId, this);
607
608	/* Register mouse-handler: */
609	machineLogic()->mouseHandler()->prepareListener(m_uScreenId, this);
610	}
611
612	void UIMachineWindow::cleanupHandlers()
613	{
614	/* Unregister mouse-handler: */
615	machineLogic()->mouseHandler()->cleanupListener(m_uScreenId);
616
617	/* Unregister keyboard-handler: */
618	machineLogic()->keyboardHandler()->cleanupListener(m_uScreenId);
619	}
620
621	void UIMachineWindow::cleanupNotificationCenter()
622	{
623	// for now it will be removed from within particular visual mode windows ..
624	}
625
626	void UIMachineWindow::cleanupMachineView()
627	{
628	/* Destroy machine-view: */
629	UIMachineView::destroy(m_pMachineView);
630	m_pMachineView = 0;
631	}
632
633	void UIMachineWindow::cleanupSessionConnections()
634	{
635	/* We should stop watching for console events: */
636	disconnect(uimachine(), &UIMachine::sigMachineStateChange, this, &UIMachineWindow::sltMachineStateChanged);
637	}
638
639	#ifdef VBOX_WITH_DEBUGGER_GUI
640	void UIMachineWindow::updateDbgWindows()
641	{
642	/* The debugger windows are bind to the main VM window. */
643	if (m_uScreenId == 0)
644	uimachine()->dbgAdjustRelativePos();
645	}
646	#endif /* VBOX_WITH_DEBUGGER_GUI */
647
648	/* static */
649	Qt::Alignment UIMachineWindow::viewAlignment(UIVisualStateType visualStateType)
650	{
651	switch (visualStateType)
652	{
653	case UIVisualStateType_Normal: return Qt::Alignment();
654	case UIVisualStateType_Fullscreen: return Qt::AlignVCenter \| Qt::AlignHCenter;
655	case UIVisualStateType_Seamless: return Qt::Alignment();
656	case UIVisualStateType_Scale: return Qt::Alignment();
657	case UIVisualStateType_Invalid: case UIVisualStateType_All: break; /* Shut up, MSC! */
658	}
659	AssertMsgFailed(("Incorrect visual state!"));
660	return Qt::Alignment();
661	}
662
663	#ifdef VBOX_WS_MAC
664	void UIMachineWindow::handleStandardWindowButtonCallback(StandardWindowButtonType enmButtonType, bool fWithOptionKey)
665	{
666	switch (enmButtonType)
667	{
668	case StandardWindowButtonType_Zoom:
669	{
670	/* Handle 'Zoom' button for 'Normal' and 'Scaled' modes: */
671	if ( machineLogic()->visualStateType() == UIVisualStateType_Normal
672	\|\| machineLogic()->visualStateType() == UIVisualStateType_Scale)
673	{
674	if (fWithOptionKey)
675	{
676	/* Toggle window zoom: */
677	darwinToggleWindowZoom(this);
678	}
679	else
680	{
681	/* Enter 'full-screen' mode: */
682	uimachine()->setRequestedVisualState(UIVisualStateType_Invalid);
683	uimachine()->asyncChangeVisualState(UIVisualStateType_Fullscreen);
684	}
685	}
686	break;
687	}
688	default:
689	break;
690	}
691	}
692
693	/* static */
694	void UIMachineWindow::handleNativeNotification(const QString &strNativeNotificationName, QWidget *pWidget)
695	{
696	/* Handle arrived notification: */
697	LogRel(("GUI: UIMachineWindow::handleNativeNotification: Notification '%s' received\n",
698	strNativeNotificationName.toLatin1().constData()));
699	AssertPtrReturnVoid(pWidget);
700	if (UIMachineWindow pMachineWindow = qobject_cast<UIMachineWindow>(pWidget))
701	{
702	/* Redirect arrived notification: */
703	LogRel2(("UIMachineWindow::handleNativeNotification: Redirecting '%s' notification to corresponding machine-window...\n",
704	strNativeNotificationName.toLatin1().constData()));
705	pMachineWindow->handleNativeNotification(strNativeNotificationName);
706	}
707	}
708
709	/* static */
710	void UIMachineWindow::handleStandardWindowButtonCallback(StandardWindowButtonType enmButtonType, bool fWithOptionKey, QWidget *pWidget)
711	{
712	/* Handle arrived callback: */
713	LogRel(("GUI: UIMachineWindow::handleStandardWindowButtonCallback: Callback for standard window button '%d' with option key '%d' received\n",
714	(int)enmButtonType, (int)fWithOptionKey));
715	AssertPtrReturnVoid(pWidget);
716	if (UIMachineWindow pMachineWindow = qobject_cast<UIMachineWindow>(pWidget))
717	{
718	/* Redirect arrived callback: */
719	LogRel2(("UIMachineWindow::handleStandardWindowButtonCallback: Redirecting callback for standard window button '%d' with option key '%d' to corresponding machine-window...\n",
720	(int)enmButtonType, (int)fWithOptionKey));
721	pMachineWindow->handleStandardWindowButtonCallback(enmButtonType, fWithOptionKey);
722	}
723	}
724	#endif /* VBOX_WS_MAC */

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

source: vbox/trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineWindow.cpp

Download in other formats: