UIMachineWindowSeamless.cpp

Last change on this file was 106061, checked in by vboxsync, 3 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: 14.0 KB

Line
1	/* $Id: UIMachineWindowSeamless.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* VBox Qt GUI - UIMachineWindowSeamless 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 <QMenu>
30	#include <QSpacerItem>
31	#include <QTimer>
32	#include <QWindowStateChangeEvent>
33
34	/* GUI includes: */
35	#include "UIActionPoolRuntime.h"
36	#include "UICommon.h"
37	#include "UIDesktopWidgetWatchdog.h"
38	#include "UIExtraDataManager.h"
39	#include "UILoggingDefs.h"
40	#include "UIMachine.h"
41	#include "UIMachineLogicSeamless.h"
42	#include "UIMachineView.h"
43	#include "UIMachineWindowSeamless.h"
44	#if defined(VBOX_WS_WIN) \|\| defined(VBOX_WS_NIX)
45	# include "UIMachineDefs.h"
46	# include "UIMiniToolBar.h"
47	#elif defined(VBOX_WS_MAC)
48	# include "VBoxUtils.h"
49	#endif /* VBOX_WS_MAC */
50
51	/* COM includes: */
52	#include "CSnapshot.h"
53
54
55	UIMachineWindowSeamless::UIMachineWindowSeamless(UIMachineLogic *pMachineLogic, ulong uScreenId)
56	: UIMachineWindow(pMachineLogic, uScreenId)
57	#if defined(VBOX_WS_WIN) \|\| defined(VBOX_WS_NIX)
58	, m_pMiniToolBar(0)
59	#endif /* VBOX_WS_WIN \|\| VBOX_WS_NIX */
60	, m_fWasMinimized(false)
61	#ifdef VBOX_WS_NIX
62	, m_fIsMinimizationRequested(false)
63	, m_fIsMinimized(false)
64	#endif
65	{
66	}
67
68	#if defined(VBOX_WS_WIN) \|\| defined(VBOX_WS_NIX)
69	void UIMachineWindowSeamless::sltMachineStateChanged()
70	{
71	/* Call to base-class: */
72	UIMachineWindow::sltMachineStateChanged();
73
74	/* Update mini-toolbar: */
75	updateAppearanceOf(UIVisualElement_MiniToolBar);
76	}
77
78	void UIMachineWindowSeamless::sltRevokeWindowActivation()
79	{
80	#ifdef VBOX_WS_NIX
81	// WORKAROUND:
82	// We could be asked to minimize already, but just
83	// not yet executed that order to current moment.
84	if (m_fIsMinimizationRequested)
85	return;
86	#endif
87
88	/* Make sure window is visible: */
89	if (!isVisible() \|\| isMinimized())
90	return;
91
92	/* Revoke stolen activation: */
93	#ifdef VBOX_WS_NIX
94	raise();
95	#endif /* VBOX_WS_NIX */
96	activateWindow();
97	}
98
99	void UIMachineWindowSeamless::sltHandleMiniToolBarAutoHideToggled(bool fEnabled)
100	{
101	/* Save mini-toolbar settings: */
102	gEDataManager->setAutoHideMiniToolbar(fEnabled, uiCommon().managedVMUuid());
103	}
104	#endif /* VBOX_WS_WIN \|\| VBOX_WS_NIX */
105
106	void UIMachineWindowSeamless::sltShowMinimized()
107	{
108	#ifdef VBOX_WS_NIX
109	/* Remember that we are asked to minimize: */
110	m_fIsMinimizationRequested = true;
111	#endif
112
113	showMinimized();
114	}
115
116	void UIMachineWindowSeamless::prepareVisualState()
117	{
118	/* Call to base-class: */
119	UIMachineWindow::prepareVisualState();
120
121	/* Make sure we have no background
122	* until the first one paint-event: */
123	setAttribute(Qt::WA_NoSystemBackground);
124
125	#ifdef VBOX_WITH_TRANSLUCENT_SEAMLESS
126	/* Using Qt API to enable translucent background: */
127	setAttribute(Qt::WA_TranslucentBackground);
128	#endif /* VBOX_WITH_TRANSLUCENT_SEAMLESS */
129
130	#ifdef VBOX_WITH_MASKED_SEAMLESS
131	/* Make sure we have no background
132	* until the first one set-region-event: */
133	setMask(m_maskGuest);
134	#endif /* VBOX_WITH_MASKED_SEAMLESS */
135
136	#if defined(VBOX_WS_WIN) \|\| defined(VBOX_WS_NIX)
137	/* Prepare mini-toolbar: */
138	prepareMiniToolbar();
139	#endif /* VBOX_WS_WIN \|\| VBOX_WS_NIX */
140	}
141
142	#if defined(VBOX_WS_WIN) \|\| defined(VBOX_WS_NIX)
143	void UIMachineWindowSeamless::prepareMiniToolbar()
144	{
145	/* Make sure mini-toolbar is not restricted: */
146	if (!gEDataManager->miniToolbarEnabled(uiCommon().managedVMUuid()))
147	return;
148
149	/* Create mini-toolbar: */
150	m_pMiniToolBar = new UIMiniToolBar(this,
151	GeometryType_Available,
152	gEDataManager->miniToolbarAlignment(uiCommon().managedVMUuid()),
153	gEDataManager->autoHideMiniToolbar(uiCommon().managedVMUuid()),
154	screenId());
155	AssertPtrReturnVoid(m_pMiniToolBar);
156	{
157	/* Configure mini-toolbar: */
158	m_pMiniToolBar->addMenus(actionPool()->menus());
159	connect(m_pMiniToolBar, &UIMiniToolBar::sigMinimizeAction,
160	this, &UIMachineWindowSeamless::sltShowMinimized, Qt::QueuedConnection);
161	connect(m_pMiniToolBar, &UIMiniToolBar::sigExitAction,
162	actionPool()->action(UIActionIndexRT_M_View_T_Seamless), &UIAction::trigger);
163	connect(m_pMiniToolBar, &UIMiniToolBar::sigCloseAction,
164	actionPool()->action(UIActionIndex_M_Application_S_Close), &UIAction::trigger);
165	connect(m_pMiniToolBar, &UIMiniToolBar::sigNotifyAboutWindowActivationStolen,
166	this, &UIMachineWindowSeamless::sltRevokeWindowActivation, Qt::QueuedConnection);
167	connect(m_pMiniToolBar, &UIMiniToolBar::sigAutoHideToggled,
168	this, &UIMachineWindowSeamless::sltHandleMiniToolBarAutoHideToggled);
169	}
170	}
171	#endif /* VBOX_WS_WIN \|\| VBOX_WS_NIX */
172
173	#if defined(VBOX_WS_WIN) \|\| defined(VBOX_WS_NIX)
174	void UIMachineWindowSeamless::cleanupMiniToolbar()
175	{
176	/* Delete mini-toolbar: */
177	delete m_pMiniToolBar;
178	m_pMiniToolBar = 0;
179	}
180	#endif /* VBOX_WS_WIN \|\| VBOX_WS_NIX */
181
182	void UIMachineWindowSeamless::cleanupVisualState()
183	{
184	#if defined(VBOX_WS_WIN) \|\| defined(VBOX_WS_NIX)
185	/* Cleanup mini-toolbar: */
186	cleanupMiniToolbar();
187	#endif /* VBOX_WS_WIN \|\| VBOX_WS_NIX */
188
189	/* Call to base-class: */
190	UIMachineWindow::cleanupVisualState();
191	}
192
193	void UIMachineWindowSeamless::placeOnScreen()
194	{
195	/* Make sure this window has seamless logic: */
196	UIMachineLogicSeamless pSeamlessLogic = qobject_cast<UIMachineLogicSeamless>(machineLogic());
197	AssertPtrReturnVoid(pSeamlessLogic);
198
199	/* Get corresponding host-screen: */
200	const int iHostScreen = pSeamlessLogic->hostScreenForGuestScreen(m_uScreenId);
201	/* And corresponding working area: */
202	const QRect workingArea = gpDesktop->availableGeometry(iHostScreen);
203	Q_UNUSED(workingArea);
204
205	#ifdef VBOX_WS_NIX
206
207	/* Make sure we are located on corresponding host-screen: */
208	if ( UIDesktopWidgetWatchdog::screenCount() > 1
209	&& (x() != workingArea.x() \|\| y() != workingArea.y()))
210	{
211	// WORKAROUND:
212	// With Qt5 on KDE we can't just move the window onto desired host-screen if
213	// window is maximized. So we have to show it normal first of all:
214	if (isVisible() && isMaximized())
215	showNormal();
216
217	// WORKAROUND:
218	// With Qt5 on X11 we can't just move the window onto desired host-screen if
219	// window size is more than the available geometry (working area) of that
220	// host-screen. So we are resizing it to a smaller size first of all:
221	const QSize newSize = workingArea.size() * .9;
222	LogRel(("GUI: UIMachineWindowSeamless::placeOnScreen: Resize window: %d to smaller size: %dx%d\n",
223	m_uScreenId, newSize.width(), newSize.height()));
224	resize(newSize);
225	/* Move window onto required screen: */
226	const QPoint newPosition = workingArea.topLeft();
227	LogRel(("GUI: UIMachineWindowSeamless::placeOnScreen: Move window: %d to: %dx%d\n",
228	m_uScreenId, newPosition.x(), newPosition.y()));
229	move(newPosition);
230	}
231
232	#else
233
234	/* Set appropriate window geometry: */
235	const QSize newSize = workingArea.size();
236	LogRel(("GUI: UIMachineWindowSeamless::placeOnScreen: Resize window: %d to: %dx%d\n",
237	m_uScreenId, newSize.width(), newSize.height()));
238	resize(newSize);
239	const QPoint newPosition = workingArea.topLeft();
240	LogRel(("GUI: UIMachineWindowSeamless::placeOnScreen: Move window: %d to: %dx%d\n",
241	m_uScreenId, newPosition.x(), newPosition.y()));
242	move(newPosition);
243
244	#endif
245	}
246
247	void UIMachineWindowSeamless::showInNecessaryMode()
248	{
249	/* Make sure window has seamless logic: */
250	UIMachineLogicSeamless pSeamlessLogic = qobject_cast<UIMachineLogicSeamless>(machineLogic());
251	AssertPtrReturnVoid(pSeamlessLogic);
252
253	/* If window shouldn't be shown or mapped to some host-screen: */
254	if (!uimachine()->isScreenVisible(m_uScreenId) \|\|
255	!pSeamlessLogic->hasHostScreenForGuestScreen(m_uScreenId))
256	{
257	/* Remember whether the window was minimized: */
258	if (isMinimized())
259	m_fWasMinimized = true;
260
261	/* Hide window and reset it's state to NONE: */
262	setWindowState(Qt::WindowNoState);
263	hide();
264	}
265	/* If window should be shown and mapped to some host-screen: */
266	else
267	{
268	/* Check whether window was minimized: */
269	const bool fWasMinimized = isMinimized() && isVisible();
270	/* And reset it's state in such case before exposing: */
271	if (fWasMinimized)
272	setWindowState(Qt::WindowNoState);
273
274	/* Make sure window have appropriate geometry: */
275	placeOnScreen();
276
277	#ifdef VBOX_WS_NIX
278	/* Show window: */
279	if (!isMaximized())
280	showMaximized();
281	#else
282	/* Show window: */
283	show();
284	#endif
285
286	/* Restore minimized state if necessary: */
287	if (m_fWasMinimized \|\| fWasMinimized)
288	{
289	m_fWasMinimized = false;
290	QMetaObject::invokeMethod(this, "showMinimized", Qt::QueuedConnection);
291	}
292
293	/* Adjust machine-view size if necessary: */
294	adjustMachineViewSize();
295
296	/* Make sure machine-view have focus: */
297	m_pMachineView->setFocus();
298	}
299	}
300
301	#if defined(VBOX_WS_WIN) \|\| defined(VBOX_WS_NIX)
302	void UIMachineWindowSeamless::updateAppearanceOf(int iElement)
303	{
304	/* Call to base-class: */
305	UIMachineWindow::updateAppearanceOf(iElement);
306
307	/* Update mini-toolbar: */
308	if (iElement & UIVisualElement_MiniToolBar)
309	{
310	/* If there is a mini-toolbar: */
311	if (m_pMiniToolBar)
312	{
313	/* Get snapshot(s): */
314	QString strSnapshotName;
315	ulong uSnapshotCount = 0;
316	uimachine()->acquireSnapshotCount(uSnapshotCount);
317	if (uSnapshotCount > 0)
318	{
319	QString strCurrentSnapshotName;
320	uimachine()->acquireCurrentSnapshotName(strCurrentSnapshotName);
321	strSnapshotName = " (" + strCurrentSnapshotName + ")";
322	}
323	/* Update mini-toolbar text: */
324	m_pMiniToolBar->setText(machineName() + strSnapshotName);
325	}
326	}
327	}
328	#endif /* VBOX_WS_WIN \|\| VBOX_WS_NIX */
329
330	#ifdef VBOX_WS_NIX
331	void UIMachineWindowSeamless::changeEvent(QEvent *pEvent)
332	{
333	switch (pEvent->type())
334	{
335	case QEvent::WindowStateChange:
336	{
337	/* Watch for window state changes: */
338	QWindowStateChangeEvent pChangeEvent = static_cast<QWindowStateChangeEvent>(pEvent);
339	LogRel2(("GUI: UIMachineWindowSeamless::changeEvent: Window state changed from %d to %d\n",
340	(int)pChangeEvent->oldState(), (int)windowState()));
341	if ( windowState() == Qt::WindowMinimized
342	&& pChangeEvent->oldState() == Qt::WindowNoState
343	&& !m_fIsMinimized)
344	{
345	/* Mark window minimized, isMinimized() is not enough due to Qt5vsX11 fight: */
346	LogRel2(("GUI: UIMachineWindowSeamless::changeEvent: Window minimized\n"));
347	m_fIsMinimized = true;
348	}
349	else
350	if ( windowState() == Qt::WindowNoState
351	&& pChangeEvent->oldState() == Qt::WindowMinimized
352	&& m_fIsMinimized)
353	{
354	/* Mark window restored, and do manual restoring with showInNecessaryMode(): */
355	LogRel2(("GUI: UIMachineWindowSeamless::changeEvent: Window restored\n"));
356	m_fIsMinimized = false;
357	/* Remember that we no more asked to minimize: */
358	m_fIsMinimizationRequested = false;
359	showInNecessaryMode();
360	}
361	break;
362	}
363	default:
364	break;
365	}
366
367	/* Call to base-class: */
368	UIMachineWindow::changeEvent(pEvent);
369	}
370	#endif /* VBOX_WS_NIX */
371
372	#ifdef VBOX_WS_WIN
373	void UIMachineWindowSeamless::showEvent(QShowEvent *pEvent)
374	{
375	/* Expose workaround again,
376	* Qt devs will never fix that it seems.
377	* This time they forget to set 'Mapped'
378	* attribute for initially frame-less window. */
379	setAttribute(Qt::WA_Mapped);
380
381	/* Call to base-class: */
382	UIMachineWindow::showEvent(pEvent);
383	}
384	#endif /* VBOX_WS_WIN */
385
386	#ifdef VBOX_WITH_MASKED_SEAMLESS
387	void UIMachineWindowSeamless::setMask(const QRegion &maskGuest)
388	{
389	/* Remember new guest mask: */
390	m_maskGuest = maskGuest;
391
392	/* Prepare full mask: */
393	QRegion maskFull(m_maskGuest);
394
395	/* Shift full mask if left or top spacer width is NOT zero: */
396	if (m_pLeftSpacer->geometry().width() \|\| m_pTopSpacer->geometry().height())
397	maskFull.translate(m_pLeftSpacer->geometry().width(), m_pTopSpacer->geometry().height());
398
399	/* Seamless-window for empty full mask should be empty too,
400	* but the QWidget::setMask() wrapper doesn't allow this.
401	* Instead, we see a full guest-screen of available-geometry size.
402	* So we have to make sure full mask have at least one pixel. */
403	if (maskFull.isEmpty())
404	maskFull += QRect(0, 0, 1, 1);
405
406	/* Make sure full mask had changed: */
407	if (m_maskFull != maskFull)
408	{
409	/* Compose viewport region to update: */
410	QRegion toUpdate = m_maskFull + maskFull;
411	/* Remember new full mask: */
412	m_maskFull = maskFull;
413	/* Assign new full mask: */
414	UIMachineWindow::setMask(m_maskFull);
415	/* Update viewport region finally: */
416	if (m_pMachineView)
417	m_pMachineView->viewport()->update(toUpdate);
418	}
419	}
420	#endif /* VBOX_WITH_MASKED_SEAMLESS */

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

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

Download in other formats: