VirtualBox

source: vbox/trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIVMCloseDialog.cpp@ 104158

Last change on this file since 104158 was 103578, checked in by vboxsync, 9 months ago

FE/Qt: UIShortcutPool: macOS no more support CMD+? as the default one help Contents shortcut; Let's use another one like CMD+/ (which is same just with Shift modifier released, because CMD+Shift+? now used for system-wide help Search menu).

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 23.6 KB
Line 
1/* $Id: UIVMCloseDialog.cpp 103578 2024-02-26 17:29:33Z vboxsync $ */
2/** @file
3 * VBox Qt GUI - UIVMCloseDialog 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 <QButtonGroup>
30#include <QCheckBox>
31#include <QGridLayout>
32#include <QHBoxLayout>
33#include <QLabel>
34#include <QPushButton>
35#include <QRadioButton>
36#include <QStyle>
37#include <QVBoxLayout>
38#include <QWindow>
39
40/* GUI includes: */
41#include "QIDialogButtonBox.h"
42#include "UICommon.h"
43#include "UIConverter.h"
44#include "UIExtraDataManager.h"
45#include "UIHelpBrowserDialog.h"
46#include "UIIconPool.h"
47#include "UIMachine.h"
48#include "UIMessageCenter.h"
49#include "UIShortcutPool.h"
50#include "UIVMCloseDialog.h"
51
52
53UIVMCloseDialog::UIVMCloseDialog(QWidget *pParent, UIMachine *pMachine,
54 bool fIsACPIEnabled, MachineCloseAction restictedCloseActions)
55 : QIWithRetranslateUI<QIDialog>(pParent)
56 , m_pMachine(pMachine)
57 , m_fIsACPIEnabled(fIsACPIEnabled)
58 , m_restictedCloseActions(restictedCloseActions)
59 , m_fValid(false)
60 , m_pMainLayout(0)
61 , m_pTopLayout(0)
62 , m_pTopLeftLayout(0)
63 , m_pTopRightLayout(0)
64 , m_pChoiceLayout(0)
65 , m_pLabelIcon(0), m_pLabelText(0)
66 , m_pLabelIconDetach(0), m_pRadioButtonDetach(0)
67 , m_pLabelIconSave(0), m_pRadioButtonSave(0)
68 , m_pLabelIconShutdown(0), m_pRadioButtonShutdown(0)
69 , m_pLabelIconPowerOff(0), m_pRadioButtonPowerOff(0)
70 , m_pCheckBoxDiscard(0)
71 , m_enmLastCloseAction(MachineCloseAction_Invalid)
72{
73 prepare();
74}
75
76void UIVMCloseDialog::setIcon(const QIcon &icon)
77{
78 /* Make sure icon is valid: */
79 if (icon.isNull())
80 return;
81
82 /* Remember it: */
83 m_icon = icon;
84 /* Update pixmaps: */
85 updatePixmaps();
86}
87
88bool UIVMCloseDialog::eventFilter(QObject *pObject, QEvent *pEvent)
89{
90 /* Handle events realted to our radio-buttons only: */
91 if ( pObject != m_pRadioButtonDetach
92 && pObject != m_pRadioButtonSave
93 && pObject != m_pRadioButtonShutdown
94 && pObject != m_pRadioButtonPowerOff)
95 return QIWithRetranslateUI<QIDialog>::eventFilter(pObject, pEvent);
96
97 /* For now we are interested in double-click events only: */
98 if (pEvent->type() == QEvent::MouseButtonDblClick)
99 {
100 /* Make sure it's one of the radio-buttons
101 * which has this event-filter installed: */
102 if (qobject_cast<QRadioButton*>(pObject))
103 {
104 /* Since on double-click the button will be also selected
105 * we are just calling for the *accept* slot: */
106 accept();
107 }
108 }
109
110 /* Call to base-class: */
111 return QIWithRetranslateUI<QIDialog>::eventFilter(pObject, pEvent);
112}
113
114bool UIVMCloseDialog::event(QEvent *pEvent)
115{
116 /* Pre-process in base-class: */
117 const bool fResult = QIWithRetranslateUI<QIDialog>::event(pEvent);
118
119 /* Post-process know event types: */
120 switch (pEvent->type())
121 {
122 case QEvent::ScreenChangeInternal:
123 {
124 /* Update pixmaps: */
125 updatePixmaps();
126 break;
127 }
128 default:
129 break;
130 }
131
132 /* Return pre-processed result: */
133 return fResult;
134}
135
136void UIVMCloseDialog::showEvent(QShowEvent *pEvent)
137{
138 /* Update pixmaps: */
139 updatePixmaps();
140
141 /* Call to base-class: */
142 QIWithRetranslateUI<QIDialog>::showEvent(pEvent);
143}
144
145void UIVMCloseDialog::retranslateUi()
146{
147 /* Translate title: */
148 setWindowTitle(tr("Close Virtual Machine"));
149
150 /* Translate text label: */
151 m_pLabelText->setText(tr("You want to:"));
152
153 /* Translate radio-buttons: */
154 m_pRadioButtonDetach->setText(tr("&Continue running in the background"));
155 m_pRadioButtonDetach->setWhatsThis(tr("<p>Close the virtual machine windows but keep the virtual machine running.</p>"
156 "<p>You can use the VirtualBox Manager to return to running the virtual machine "
157 "in a window.</p>"));
158 m_pRadioButtonSave->setText(tr("&Save the machine state"));
159 m_pRadioButtonSave->setWhatsThis(tr("<p>Saves the current execution state of the virtual machine to the physical hard disk "
160 "of the host PC.</p>"
161 "<p>Next time this machine is started, it will be restored from the saved state and "
162 "continue execution from the same place you saved it at, which will let you continue "
163 "your work immediately.</p>"
164 "<p>Note that saving the machine state may take a long time, depending on the guest "
165 "operating system type and the amount of memory you assigned to the virtual "
166 "machine.</p>"));
167 m_pRadioButtonShutdown->setText(tr("S&end the shutdown signal"));
168 m_pRadioButtonShutdown->setWhatsThis(tr("<p>Sends the ACPI Power Button press event to the virtual machine.</p>"
169 "<p>Normally, the guest operating system running inside the virtual machine will "
170 "detect this event and perform a clean shutdown procedure. This is a recommended "
171 "way to turn off the virtual machine because all applications running inside it "
172 "will get a chance to save their data and state.</p>"
173 "<p>If the machine doesn't respond to this action then the guest operating system "
174 "may be misconfigured or doesn't understand ACPI Power Button events at all. In "
175 "this case you should select the <b>Power off the machine</b> action to stop "
176 "virtual machine execution.</p>"));
177 m_pRadioButtonPowerOff->setText(tr("&Power off the machine"));
178 m_pRadioButtonPowerOff->setWhatsThis(tr("<p>Turns off the virtual machine.</p>"
179 "<p>Note that this action will stop machine execution immediately so that the guest "
180 "operating system running inside it will not be able to perform a clean shutdown "
181 "procedure which may result in <i>data loss</i> inside the virtual machine. "
182 "Selecting this action is recommended only if the virtual machine does not respond "
183 "to the <b>Send the shutdown signal</b> action.</p>"));
184
185 /* Translate check-box: */
186 m_pCheckBoxDiscard->setText(tr("&Restore current snapshot '%1'").arg(m_strDiscardCheckBoxText));
187 m_pCheckBoxDiscard->setWhatsThis(tr("<p>When checked, the machine will be returned to the state stored in the current "
188 "snapshot after it is turned off. This is useful if you are sure that you want to "
189 "discard the results of your last sessions and start again at that snapshot.</p>"));
190}
191
192void UIVMCloseDialog::sltUpdateWidgetAvailability()
193{
194 /* Discard option should be enabled only on power-off action: */
195 m_pCheckBoxDiscard->setEnabled(m_pRadioButtonPowerOff->isChecked());
196}
197
198void UIVMCloseDialog::accept()
199{
200 /* Calculate result: */
201 if (m_pRadioButtonDetach->isChecked())
202 setResult(MachineCloseAction_Detach);
203 else if (m_pRadioButtonSave->isChecked())
204 setResult(MachineCloseAction_SaveState);
205 else if (m_pRadioButtonShutdown->isChecked())
206 setResult(MachineCloseAction_Shutdown);
207 else if (m_pRadioButtonPowerOff->isChecked())
208 {
209 if (!m_pCheckBoxDiscard->isChecked() || !m_pCheckBoxDiscard->isVisible())
210 setResult(MachineCloseAction_PowerOff);
211 else
212 setResult(MachineCloseAction_PowerOff_RestoringSnapshot);
213 }
214
215 /* Memorize the last user's choice for the given VM: */
216 MachineCloseAction newCloseAction = static_cast<MachineCloseAction>(result());
217 /* But make sure 'Shutdown' is preserved if temporary unavailable: */
218 if (newCloseAction == MachineCloseAction_PowerOff &&
219 m_enmLastCloseAction == MachineCloseAction_Shutdown && !m_fIsACPIEnabled)
220 newCloseAction = MachineCloseAction_Shutdown;
221 gEDataManager->setLastMachineCloseAction(newCloseAction, uiCommon().managedVMUuid());
222
223 /* Hide the dialog: */
224 hide();
225}
226
227void UIVMCloseDialog::setButtonEnabledDetach(bool fEnabled)
228{
229 m_pLabelIconDetach->setEnabled(fEnabled);
230 m_pRadioButtonDetach->setEnabled(fEnabled);
231}
232
233void UIVMCloseDialog::setButtonVisibleDetach(bool fVisible)
234{
235 m_pLabelIconDetach->setVisible(fVisible);
236 m_pRadioButtonDetach->setVisible(fVisible);
237}
238
239void UIVMCloseDialog::setButtonEnabledSave(bool fEnabled)
240{
241 m_pLabelIconSave->setEnabled(fEnabled);
242 m_pRadioButtonSave->setEnabled(fEnabled);
243}
244
245void UIVMCloseDialog::setButtonVisibleSave(bool fVisible)
246{
247 m_pLabelIconSave->setVisible(fVisible);
248 m_pRadioButtonSave->setVisible(fVisible);
249}
250
251void UIVMCloseDialog::setButtonEnabledShutdown(bool fEnabled)
252{
253 m_pLabelIconShutdown->setEnabled(fEnabled);
254 m_pRadioButtonShutdown->setEnabled(fEnabled);
255}
256
257void UIVMCloseDialog::setButtonVisibleShutdown(bool fVisible)
258{
259 m_pLabelIconShutdown->setVisible(fVisible);
260 m_pRadioButtonShutdown->setVisible(fVisible);
261}
262
263void UIVMCloseDialog::setButtonEnabledPowerOff(bool fEnabled)
264{
265 m_pLabelIconPowerOff->setEnabled(fEnabled);
266 m_pRadioButtonPowerOff->setEnabled(fEnabled);
267}
268
269void UIVMCloseDialog::setButtonVisiblePowerOff(bool fVisible)
270{
271 m_pLabelIconPowerOff->setVisible(fVisible);
272 m_pRadioButtonPowerOff->setVisible(fVisible);
273}
274
275void UIVMCloseDialog::setCheckBoxVisibleDiscard(bool fVisible)
276{
277 m_pCheckBoxDiscard->setVisible(fVisible);
278}
279
280void UIVMCloseDialog::prepare()
281{
282 /* Choose default dialog icon: */
283 m_icon = UIIconPool::iconSet(":/os_unknown.png");
284
285 /* Prepare size-grip token: */
286 setSizeGripEnabled(false);
287
288 /* Prepare main layout: */
289 prepareMainLayout();
290
291 /* Update pixmaps: */
292 updatePixmaps();
293
294 /* Configure: */
295 configure();
296
297 /* Apply language settings: */
298 retranslateUi();
299}
300
301void UIVMCloseDialog::prepareMainLayout()
302{
303 /* Create main layout: */
304 m_pMainLayout = new QVBoxLayout(this);
305 if (m_pMainLayout)
306 {
307 /* Configure layout: */
308#ifdef VBOX_WS_MAC
309 m_pMainLayout->setContentsMargins(40, 20, 40, 20);
310 m_pMainLayout->setSpacing(15);
311#else
312 m_pMainLayout->setSpacing(qApp->style()->pixelMetric(QStyle::PM_LayoutVerticalSpacing) * 2);
313#endif
314
315 /* Prepare top layout: */
316 prepareTopLayout();
317
318 /* Add stretch between top and bottom: */
319 m_pMainLayout->addStretch(1);
320
321 /* Prepare button-box: */
322 prepareButtonBox();
323 }
324}
325
326void UIVMCloseDialog::prepareTopLayout()
327{
328 /* Create top layout: */
329 m_pTopLayout = new QHBoxLayout;
330 if (m_pTopLayout)
331 {
332 /* Configure layout: */
333#ifdef VBOX_WS_MAC
334 m_pTopLayout->setSpacing(20);
335#else
336 m_pTopLayout->setSpacing(qApp->style()->pixelMetric(QStyle::PM_LayoutHorizontalSpacing) * 2);
337#endif
338
339 /* Prepare top-left layout: */
340 prepareTopLeftLayout();
341 /* Prepare top-right layout: */
342 prepareTopRightLayout();
343
344 /* Add into layout: */
345 m_pMainLayout->addLayout(m_pTopLayout);
346 }
347}
348
349void UIVMCloseDialog::prepareTopLeftLayout()
350{
351 /* Create top-left layout: */
352 m_pTopLeftLayout = new QVBoxLayout;
353 if (m_pTopLeftLayout)
354 {
355 /* Create icon label: */
356 m_pLabelIcon = new QLabel;
357 if (m_pLabelIcon)
358 {
359 /* Configure label: */
360 m_pLabelIcon->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
361
362 /* Add into layout: */
363 m_pTopLeftLayout->addWidget(m_pLabelIcon);
364 }
365
366 /* Add vertical stretch under icon label: */
367 m_pTopLeftLayout->addStretch();
368
369 /* Add into layout: */
370 m_pTopLayout->addLayout(m_pTopLeftLayout);
371 }
372}
373
374void UIVMCloseDialog::prepareTopRightLayout()
375{
376 /* Create top-right layout: */
377 m_pTopRightLayout = new QVBoxLayout;
378 if (m_pTopRightLayout)
379 {
380 /* Configure layout: */
381#ifdef VBOX_WS_MAC
382 m_pTopRightLayout->setSpacing(10);
383#else
384 m_pTopRightLayout->setSpacing(qApp->style()->pixelMetric(QStyle::PM_LayoutVerticalSpacing));
385#endif
386
387 /* Create text label: */
388 m_pLabelText = new QLabel;
389 if (m_pLabelText)
390 {
391 /* Add into layout: */
392 m_pTopRightLayout->addWidget(m_pLabelText);
393 }
394
395 /* Prepare choice layout: */
396 prepareChoiceLayout();
397
398 /* Add into layout: */
399 m_pTopLayout->addLayout(m_pTopRightLayout);
400 }
401}
402
403void UIVMCloseDialog::prepareChoiceLayout()
404{
405 /* Create 'choice' layout: */
406 m_pChoiceLayout = new QGridLayout;
407 if (m_pChoiceLayout)
408 {
409 /* Configure layout: */
410#ifdef VBOX_WS_MAC
411 m_pChoiceLayout->setSpacing(10);
412#else
413 m_pChoiceLayout->setSpacing(qApp->style()->pixelMetric(QStyle::PM_LayoutVerticalSpacing));
414#endif
415
416 /* Create button-group: */
417 QButtonGroup *pButtonGroup = new QButtonGroup(this);
418 if (pButtonGroup)
419 connect(pButtonGroup, &QButtonGroup::buttonClicked,
420 this, &UIVMCloseDialog::sltUpdateWidgetAvailability);
421
422 /* Create 'detach' icon label: */
423 m_pLabelIconDetach = new QLabel;
424 if (m_pLabelIconDetach)
425 {
426 /* Configure label: */
427 m_pLabelIconDetach->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
428 /* Add into layout: */
429 m_pChoiceLayout->addWidget(m_pLabelIconDetach, 0, 0);
430 }
431 /* Create 'detach' radio-button: */
432 m_pRadioButtonDetach = new QRadioButton;
433 if (m_pRadioButtonDetach)
434 {
435 /* Configure button: */
436 m_pRadioButtonDetach->installEventFilter(this);
437 /* Add into group/layout: */
438 pButtonGroup->addButton(m_pRadioButtonDetach);
439 m_pChoiceLayout->addWidget(m_pRadioButtonDetach, 0, 1);
440 }
441
442 /* Create 'save' icon label: */
443 m_pLabelIconSave = new QLabel;
444 if (m_pLabelIconSave)
445 {
446 /* Configure label: */
447 m_pLabelIconSave->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
448 /* Add into layout: */
449 m_pChoiceLayout->addWidget(m_pLabelIconSave, 1, 0);
450 }
451 /* Create 'save' radio-button: */
452 m_pRadioButtonSave = new QRadioButton;
453 if (m_pRadioButtonSave)
454 {
455 /* Configure button: */
456 m_pRadioButtonSave->installEventFilter(this);
457 /* Add into group/layout: */
458 pButtonGroup->addButton(m_pRadioButtonSave);
459 m_pChoiceLayout->addWidget(m_pRadioButtonSave, 1, 1);
460 }
461
462 /* Create 'shutdown' icon label: */
463 m_pLabelIconShutdown = new QLabel;
464 if (m_pLabelIconShutdown)
465 {
466 /* Configure label: */
467 m_pLabelIconShutdown->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
468 /* Add into layout: */
469 m_pChoiceLayout->addWidget(m_pLabelIconShutdown, 2, 0);
470 }
471 /* Create 'shutdown' radio-button: */
472 m_pRadioButtonShutdown = new QRadioButton;
473 if (m_pRadioButtonShutdown)
474 {
475 /* Configure button: */
476 m_pRadioButtonShutdown->installEventFilter(this);
477 /* Add into group/layout: */
478 pButtonGroup->addButton(m_pRadioButtonShutdown);
479 m_pChoiceLayout->addWidget(m_pRadioButtonShutdown, 2, 1);
480 }
481
482 /* Create 'power-off' icon label: */
483 m_pLabelIconPowerOff = new QLabel;
484 if (m_pLabelIconPowerOff)
485 {
486 /* Configure label: */
487 m_pLabelIconPowerOff->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
488 /* Add into layout: */
489 m_pChoiceLayout->addWidget(m_pLabelIconPowerOff, 3, 0);
490 }
491 /* Create 'shutdown' radio-button: */
492 m_pRadioButtonPowerOff = new QRadioButton;
493 if (m_pRadioButtonPowerOff)
494 {
495 /* Configure button: */
496 m_pRadioButtonPowerOff->installEventFilter(this);
497 /* Add into group/layout: */
498 pButtonGroup->addButton(m_pRadioButtonPowerOff);
499 m_pChoiceLayout->addWidget(m_pRadioButtonPowerOff, 3, 1);
500 }
501
502 /* Create 'discard' check-box: */
503 m_pCheckBoxDiscard = new QCheckBox;
504 if (m_pCheckBoxDiscard)
505 {
506 /* Add into layout: */
507 m_pChoiceLayout->addWidget(m_pCheckBoxDiscard, 4, 1);
508 }
509
510 /* Add into layout: */
511 m_pTopRightLayout->addLayout(m_pChoiceLayout);
512 }
513}
514
515void UIVMCloseDialog::prepareButtonBox()
516{
517 /* Create button-box: */
518 QIDialogButtonBox *pButtonBox = new QIDialogButtonBox;
519 if (pButtonBox)
520 {
521 /* Configure button-box: */
522 pButtonBox->setStandardButtons( QDialogButtonBox::Cancel
523 | QDialogButtonBox::Help
524 | QDialogButtonBox::NoButton
525 | QDialogButtonBox::Ok);
526 connect(pButtonBox, &QIDialogButtonBox::accepted, this, &UIVMCloseDialog::accept);
527 connect(pButtonBox, &QIDialogButtonBox::rejected, this, &UIVMCloseDialog::reject);
528 uiCommon().setHelpKeyword(pButtonBox->button(QIDialogButtonBox::Help), "intro-save-machine-state");
529 connect(pButtonBox->button(QIDialogButtonBox::Help), &QPushButton::pressed,
530 pButtonBox, &QIDialogButtonBox::sltHandleHelpRequest);
531 pButtonBox->button(QIDialogButtonBox::Help)->setShortcut(UIShortcutPool::standardSequence(QKeySequence::HelpContents));
532
533 /* Add into layout: */
534 m_pMainLayout->addWidget(pButtonBox);
535 }
536}
537
538void UIVMCloseDialog::configure()
539{
540 /* Get actual machine-state: */
541 KMachineState enmActualState = KMachineState_Null;
542 m_pMachine->acquireLiveMachineState(enmActualState);
543
544 /* Check which close-actions are resticted: */
545 bool fIsDetachAllowed = uiCommon().isSeparateProcess() && !(m_restictedCloseActions & MachineCloseAction_Detach);
546 bool fIsStateSavingAllowed = !(m_restictedCloseActions & MachineCloseAction_SaveState);
547 bool fIsACPIShutdownAllowed = !(m_restictedCloseActions & MachineCloseAction_Shutdown);
548 bool fIsPowerOffAllowed = !(m_restictedCloseActions & MachineCloseAction_PowerOff);
549 bool fIsPowerOffAndRestoreAllowed = fIsPowerOffAllowed && !(m_restictedCloseActions & MachineCloseAction_PowerOff_RestoringSnapshot);
550
551 /* Make 'Detach' button visible/hidden depending on restriction: */
552 setButtonVisibleDetach(fIsDetachAllowed);
553 /* Make 'Detach' button enabled/disabled depending on machine-state: */
554 setButtonEnabledDetach(enmActualState != KMachineState_Stuck);
555
556 /* Make 'Save state' button visible/hidden depending on restriction: */
557 setButtonVisibleSave(fIsStateSavingAllowed);
558 /* Make 'Save state' button enabled/disabled depending on machine-state: */
559 setButtonEnabledSave(enmActualState != KMachineState_Stuck);
560
561 /* Make 'Shutdown' button visible/hidden depending on restriction: */
562 setButtonVisibleShutdown(fIsACPIShutdownAllowed);
563 /* Make 'Shutdown' button enabled/disabled depending on console and machine-state: */
564 setButtonEnabledShutdown(m_fIsACPIEnabled && enmActualState != KMachineState_Stuck);
565
566 /* Make 'Power off' button visible/hidden depending on restriction: */
567 setButtonVisiblePowerOff(fIsPowerOffAllowed);
568 /* Make the Restore Snapshot checkbox visible/hidden depending on snapshot count & restrictions: */
569 ulong uSnapshotCount = 0;
570 m_pMachine->acquireSnapshotCount(uSnapshotCount);
571 setCheckBoxVisibleDiscard(fIsPowerOffAndRestoreAllowed && uSnapshotCount > 0);
572 /* Assign Restore Snapshot checkbox text: */
573 if (uSnapshotCount > 0)
574 {
575 QString strCurrentSnapshotName;
576 m_pMachine->acquireCurrentSnapshotName(strCurrentSnapshotName);
577 m_strDiscardCheckBoxText = strCurrentSnapshotName;
578 }
579
580 /* Check which radio-button should be initially chosen: */
581 QRadioButton *pRadioButtonToChoose = 0;
582 /* If choosing 'last choice' is possible: */
583 m_enmLastCloseAction = gEDataManager->lastMachineCloseAction(uiCommon().managedVMUuid());
584 if (m_enmLastCloseAction == MachineCloseAction_Detach && fIsDetachAllowed)
585 {
586 pRadioButtonToChoose = m_pRadioButtonDetach;
587 }
588 else if (m_enmLastCloseAction == MachineCloseAction_SaveState && fIsStateSavingAllowed)
589 {
590 pRadioButtonToChoose = m_pRadioButtonSave;
591 }
592 else if (m_enmLastCloseAction == MachineCloseAction_Shutdown && fIsACPIShutdownAllowed && m_fIsACPIEnabled)
593 {
594 pRadioButtonToChoose = m_pRadioButtonShutdown;
595 }
596 else if (m_enmLastCloseAction == MachineCloseAction_PowerOff && fIsPowerOffAllowed)
597 {
598 pRadioButtonToChoose = m_pRadioButtonPowerOff;
599 }
600 else if (m_enmLastCloseAction == MachineCloseAction_PowerOff_RestoringSnapshot && fIsPowerOffAndRestoreAllowed)
601 {
602 pRadioButtonToChoose = m_pRadioButtonPowerOff;
603 }
604 /* Else 'default choice' will be used: */
605 else
606 {
607 if (fIsDetachAllowed)
608 pRadioButtonToChoose = m_pRadioButtonDetach;
609 else if (fIsStateSavingAllowed)
610 pRadioButtonToChoose = m_pRadioButtonSave;
611 else if (fIsACPIShutdownAllowed && m_fIsACPIEnabled)
612 pRadioButtonToChoose = m_pRadioButtonShutdown;
613 else if (fIsPowerOffAllowed)
614 pRadioButtonToChoose = m_pRadioButtonPowerOff;
615 }
616
617 /* If some radio-button chosen: */
618 if (pRadioButtonToChoose)
619 {
620 /* Check and focus it: */
621 pRadioButtonToChoose->setChecked(true);
622 pRadioButtonToChoose->setFocus();
623 sltUpdateWidgetAvailability();
624 m_fValid = true;
625 }
626}
627
628void UIVMCloseDialog::updatePixmaps()
629{
630 /* Acquire hints: */
631 const int iMetricSmall = QApplication::style()->pixelMetric(QStyle::PM_SmallIconSize);
632 const int iMetricLarge = QApplication::style()->pixelMetric(QStyle::PM_LargeIconSize);
633
634 /* Re-apply pixmap: */
635 const qreal fDevicePixelRatio = windowHandle() ? windowHandle()->devicePixelRatio() : 1;
636 m_pLabelIcon->setPixmap(m_icon.pixmap(QSize(iMetricLarge, iMetricLarge), fDevicePixelRatio));
637
638 QIcon icon;
639 icon = UIIconPool::iconSet(":/vm_create_shortcut_16px.png");
640 m_pLabelIconDetach->setPixmap(icon.pixmap(QSize(iMetricSmall, iMetricSmall), fDevicePixelRatio));
641 icon = UIIconPool::iconSet(":/vm_save_state_16px.png");
642 m_pLabelIconSave->setPixmap(icon.pixmap(QSize(iMetricSmall, iMetricSmall), fDevicePixelRatio));
643 icon = UIIconPool::iconSet(":/vm_shutdown_16px.png");
644 m_pLabelIconShutdown->setPixmap(icon.pixmap(QSize(iMetricSmall, iMetricSmall), fDevicePixelRatio));
645 icon = UIIconPool::iconSet(":/vm_poweroff_16px.png");
646 m_pLabelIconPowerOff->setPixmap(icon.pixmap(QSize(iMetricSmall, iMetricSmall), fDevicePixelRatio));
647}
Note: See TracBrowser for help on using the repository browser.

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