Changeset 45203 in vbox for trunk/src

Timestamp:

Mar 27, 2013 11:03:05 AM (12 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

84561

Message:

FE/Qt: Runtime UI: Close-event rework/cleanup (part 1).

File:

• trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineWindow.cpp (modified) (1 diff)

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineWindow.cpp

@@ -251 +251 @@
     pEvent->ignore();
 
-    /* Should we close application? */
-    bool fCloseApplication = false;
-    switch (uisession()->machineState())
-    {
-        case KMachineState_Running:
-        case KMachineState_Paused:
-        case KMachineState_Stuck:
-        case KMachineState_LiveSnapshotting:
-        case KMachineState_Teleporting: // TODO: Test this!
-        case KMachineState_TeleportingPausedVM: // TODO: Test this!
+    /* Should we shutdown UI session? */
+    bool fShutdownSession = false;
+
+    /* Make sure machine is in one of the allowed states: */
+    KMachineState machineState = uisession()->machineState();
+    if (   machineState != KMachineState_Running
+        && machineState != KMachineState_Paused
+        && machineState != KMachineState_Stuck
+        && machineState != KMachineState_LiveSnapshotting
+        && machineState != KMachineState_Teleporting
+        && machineState != KMachineState_TeleportingPausedVM)
+        return;
+
+    /* Get the machine: */
+    CMachine m = machine();
+
+    /* If there is a close hook script defined: */
+    const QString& strScript = m.GetExtraData(GUI_CloseActionHook);
+    if (!strScript.isEmpty())
+    {
+        /* Execute asynchronously and leave: */
+        QProcess::startDetached(strScript, QStringList() << m.GetId());
+        return;
+    }
+
+    /* Prepare close-dialog: */
+    QWidget *pParentDlg = mwManager().realParentWindow(this);
+    QPointer<UIVMCloseDialog> pCloseDlg = new UIVMCloseDialog(pParentDlg);
+    mwManager().registerNewParent(pCloseDlg, pParentDlg);
+
+    /* Assign close-dialog pixmap: */
+    pCloseDlg->pmIcon->setPixmap(vboxGlobal().vmGuestOSTypeIcon(m.GetOSTypeId()));
+
+    /* Check which close-actions are resticted: */
+    QStringList restictedActionsList = m.GetExtraData(GUI_RestrictedCloseActions).split(',');
+    bool fIsStateSavingAllowed = !restictedActionsList.contains("SaveState", Qt::CaseInsensitive);
+    bool fIsACPIShutdownAllowed = !restictedActionsList.contains("Shutdown", Qt::CaseInsensitive);
+    bool fIsPowerOffAllowed = !restictedActionsList.contains("PowerOff", Qt::CaseInsensitive);
+    bool fIsPowerOffAndRestoreAllowed = fIsPowerOffAllowed && !restictedActionsList.contains("Restore", Qt::CaseInsensitive);
+
+    /* Make 'Save state' button visible/hidden depending on restriction: */
+    pCloseDlg->mRbSave->setVisible(fIsStateSavingAllowed);
+    pCloseDlg->mTxSave->setVisible(fIsStateSavingAllowed);
+    /* Make 'Save state' button enabled/disabled depending on machine-state: */
+    pCloseDlg->mRbSave->setEnabled(machineState != KMachineState_Stuck);
+
+    /* Make 'ACPI shutdown button' visible/hidden depending on restriction: */
+    pCloseDlg->mRbShutdown->setVisible(fIsACPIShutdownAllowed);
+    pCloseDlg->mTxShutdown->setVisible(fIsACPIShutdownAllowed);
+    /* Make 'ACPI shutdown button' enabled/disabled depending on ACPI-state & machine-state: */
+    bool fIsACPIEnabled = session().GetConsole().GetGuestEnteredACPIMode();
+    pCloseDlg->mRbShutdown->setEnabled(fIsACPIEnabled && machineState != KMachineState_Stuck);
+
+    /* Make 'Power off' button visible/hidden depending on restriction: */
+    pCloseDlg->mRbPowerOff->setVisible(fIsPowerOffAllowed);
+    pCloseDlg->mTxPowerOff->setVisible(fIsPowerOffAllowed);
+
+    /* Make the Restore Snapshot checkbox visible/hidden depending on snapshot count & restrictions: */
+    pCloseDlg->mCbDiscardCurState->setVisible(fIsPowerOffAndRestoreAllowed && m.GetSnapshotCount() > 0);
+    if (!m.GetCurrentSnapshot().isNull())
+        pCloseDlg->mCbDiscardCurState->setText(pCloseDlg->mCbDiscardCurState->text().arg(m.GetCurrentSnapshot().GetName()));
+
+    /* Possible extra-data option values for close-dialog: */
+    QString strSave("save");
+    QString strShutdown("shutdown");
+    QString strPowerOff("powerOff");
+    QString strDiscardCurState("discardCurState");
+
+    /* Read the last user's choice for the given VM: */
+    QStringList lastAction = m.GetExtraData(GUI_LastCloseAction).split(',');
+
+    /* Check which button should be initially chosen: */
+    QRadioButton *pRadioButtonToChoose = 0;
+
+    /* If choosing 'last choice' is possible: */
+    if (lastAction[0] == strSave && fIsStateSavingAllowed)
+    {
+        pRadioButtonToChoose = pCloseDlg->mRbSave;
+    }
+    else if (lastAction[0] == strShutdown && fIsACPIShutdownAllowed && fIsACPIEnabled)
+    {
+        pRadioButtonToChoose = pCloseDlg->mRbShutdown;
+    }
+    else if (lastAction[0] == strPowerOff && fIsPowerOffAllowed)
+    {
+        pRadioButtonToChoose = pCloseDlg->mRbPowerOff;
+        if (fIsPowerOffAndRestoreAllowed)
+            pCloseDlg->mCbDiscardCurState->setChecked(lastAction.count() > 1 && lastAction[1] == strDiscardCurState);
+    }
+    /* Else 'default choice' will be used: */
+    else
+    {
+        if (fIsACPIShutdownAllowed && fIsACPIEnabled)
+            pRadioButtonToChoose = pCloseDlg->mRbShutdown;
+        else if (fIsPowerOffAllowed)
+            pRadioButtonToChoose = pCloseDlg->mRbPowerOff;
+        else if (fIsStateSavingAllowed)
+            pRadioButtonToChoose = pCloseDlg->mRbSave;
+    }
+
+    /* If some radio button chosen: */
+    if (pRadioButtonToChoose)
+    {
+        /* Check and focus it: */
+        pRadioButtonToChoose->setChecked(true);
+        pRadioButtonToChoose->setFocus();
+    }
+    /* If no one of radio buttons was chosen: */
+    else
+    {
+        /* Destroy and leave: */
+        delete pCloseDlg;
+        return;
+    }
+
+    /* This flag will keep the status of every further logical operation: */
+    bool fSuccess = true;
+    /* This flag determines if VM was paused before we called for close-event: */
+    bool fWasPaused = uisession()->isPaused();
+
+    if (fSuccess)
+    {
+        /* Pause VM if necessary: */
+        if (!fWasPaused)
+            fSuccess = uisession()->pause();
+    }
+
+    if (fSuccess)
+    {
+        /* Preventing auto-closure: */
+        machineLogic()->setPreventAutoClose(true);
+
+        /* Show the close-dialog: */
+        bool fDialogAccepted = pCloseDlg->exec() == QDialog::Accepted;
+
+        /* What was the decision? */
+        enum DialogDecision { DD_Cancel, DD_Save, DD_Shutdown, DD_PowerOff };
+        DialogDecision decision;
+        if (!fDialogAccepted)
+            decision = DD_Cancel;
+        else if (pCloseDlg->mRbSave->isChecked())
+            decision = DD_Save;
+        else if (pCloseDlg->mRbShutdown->isChecked())
+            decision = DD_Shutdown;
+        else
+            decision = DD_PowerOff;
+        bool fDiscardCurState = pCloseDlg->mCbDiscardCurState->isChecked();
+        bool fDiscardCheckboxVisible = pCloseDlg->mCbDiscardCurState->isVisibleTo(pCloseDlg);
+
+        /* Destroy the dialog early: */
+        delete pCloseDlg;
+
+        /* Was dialog accepted? */
+        if (fDialogAccepted)
         {
-            /* Get the machine: */
-            CMachine m = machine();
-
-            /* Check if there is a close hook script defined. */
-            const QString& strScript = m.GetExtraData(GUI_CloseActionHook);
-            if (!strScript.isEmpty())
+            /* Process decision: */
+            CConsole console = session().GetConsole();
+            switch (decision)
             {
-                QProcess::startDetached(strScript, QStringList() << m.GetId());
-                return;
+                case DD_Save:
+                {
+                    /* Prepare the saving progress: */
+                    CProgress progress = console.SaveState();
+                    fSuccess = console.isOk();
+                    if (fSuccess)
+                    {
+                        /* Show the saving progress dialog: */
+                        msgCenter().showModalProgressDialog(progress, m.GetName(), ":/progress_state_save_90px.png", this);
+                        fSuccess = progress.GetResultCode() == 0;
+                        if (fSuccess)
+                            fShutdownSession = true;
+                        else
+                            msgCenter().cannotSaveMachineState(progress);
+                    }
+                    else
+                        msgCenter().cannotSaveMachineState(console);
+                    break;
+                }
+                case DD_Shutdown:
+                {
+                    /* Unpause VM to let it grab the ACPI shutdown event: */
+                    fSuccess = uisession()->unpause();
+                    if (fSuccess)
+                    {
+                        /* Prevent subsequent unpause request: */
+                        fWasPaused = true;
+                        /* Signal ACPI shutdown (if there is no ACPI device, the operation will fail): */
+                        console.PowerButton();
+                        fSuccess = console.isOk();
+                        if (!fSuccess)
+                            msgCenter().cannotACPIShutdownMachine(console);
+                    }
+                    break;
+                }
+                case DD_PowerOff:
+                {
+                    /* Prepare the power down progress: */
+                    CProgress progress = console.PowerDown();
+                    fSuccess = console.isOk();
+                    if (fSuccess)
+                    {
+                        /* Show the power down progress: */
+                        msgCenter().showModalProgressDialog(progress, m.GetName(), ":/progress_poweroff_90px.png", this);
+                        fSuccess = progress.GetResultCode() == 0;
+                        if (fSuccess)
+                        {
+                            /* Discard the current state if requested: */
+                            if (fDiscardCurState && fDiscardCheckboxVisible)
+                            {
+                                /* Prepare the snapshot discard progress: */
+                                CSnapshot snapshot = m.GetCurrentSnapshot();
+                                CProgress progress = console.RestoreSnapshot(snapshot);
+                                fSuccess = console.isOk();
+                                if (fSuccess)
+                                {
+                                    /* Show the snapshot discard progress: */
+                                    msgCenter().showModalProgressDialog(progress, m.GetName(), ":/progress_snapshot_discard_90px.png", this);
+                                    fSuccess = progress.GetResultCode() == 0;
+                                    if (!fSuccess)
+                                        msgCenter().cannotRestoreSnapshot(progress, snapshot.GetName());
+                                }
+                                else
+                                    msgCenter().cannotRestoreSnapshot(console, snapshot.GetName());
+                            }
+                            if (fSuccess)
+                                fShutdownSession = true;
+                        }
+                        else
+                            msgCenter().cannotStopMachine(progress);
+                    }
+                    else
+                    {
+                        /* This can happen if VBoxSVC is not running: */
+                        COMResult res(console);
+                        if (FAILED_DEAD_INTERFACE(res.rc()))
+                            fShutdownSession = true;
+                        else
+                            msgCenter().cannotStopMachine(console);
+                    }
+                    break;
+                }
+                default:
+                    break;
             }
-
-            /* Prepare close-dialog: */
-            QWidget *pDlgParent = mwManager().realParentWindow(this);
-            UIVMCloseDialog *pDlg = new UIVMCloseDialog(pDlgParent);
-            mwManager().registerNewParent(pDlg, pDlgParent);
-
-            /* Assign close-dialog pixmap: */
-            pDlg->pmIcon->setPixmap(vboxGlobal().vmGuestOSTypeIcon(m.GetOSTypeId()));
-
-            /* Check which close actions are disallowed: */
-            QStringList restictedActionsList = m.GetExtraData(GUI_RestrictedCloseActions).split(',');
-            bool fIsStateSavingAllowed = !restictedActionsList.contains("SaveState", Qt::CaseInsensitive);
-            bool fIsACPIShutdownAllowed = !restictedActionsList.contains("Shutdown", Qt::CaseInsensitive);
-            bool fIsPowerOffAllowed = !restictedActionsList.contains("PowerOff", Qt::CaseInsensitive);
-            bool fIsPowerOffAndRestoreAllowed = fIsPowerOffAllowed && !restictedActionsList.contains("Restore", Qt::CaseInsensitive);
-
-            /* Make Save State button visible/hidden depending on restriction: */
-            pDlg->mRbSave->setVisible(fIsStateSavingAllowed);
-            pDlg->mTxSave->setVisible(fIsStateSavingAllowed);
-            /* Make Save State button enabled/disabled depending on machine state: */
-            pDlg->mRbSave->setEnabled(uisession()->machineState() != KMachineState_Stuck);
-
-            /* Make ACPI shutdown button visible/hidden depending on restriction: */
-            pDlg->mRbShutdown->setVisible(fIsACPIShutdownAllowed);
-            pDlg->mTxShutdown->setVisible(fIsACPIShutdownAllowed);
-            /* Make ACPI shutdown button enabled/disabled depending on ACPI state & machine state: */
-            bool isACPIEnabled = session().GetConsole().GetGuestEnteredACPIMode();
-            pDlg->mRbShutdown->setEnabled(isACPIEnabled && uisession()->machineState() != KMachineState_Stuck);
-
-            /* Make Power Off button visible/hidden depending on restriction: */
-            pDlg->mRbPowerOff->setVisible(fIsPowerOffAllowed);
-            pDlg->mTxPowerOff->setVisible(fIsPowerOffAllowed);
-
-            /* Make the Restore Snapshot checkbox visible/hidden depending on snapshots count & restrictions: */
-            pDlg->mCbDiscardCurState->setVisible(fIsPowerOffAndRestoreAllowed && m.GetSnapshotCount() > 0);
-            if (!m.GetCurrentSnapshot().isNull())
-                pDlg->mCbDiscardCurState->setText(pDlg->mCbDiscardCurState->text().arg(m.GetCurrentSnapshot().GetName()));
-
-            /* Choice string tags for close-dialog: */
-            QString strSave("save");
-            QString strShutdown("shutdown");
-            QString strPowerOff("powerOff");
-            QString strDiscardCurState("discardCurState");
-
-            /* Read the last user's choice for the given VM: */
-            QStringList lastAction = m.GetExtraData(GUI_LastCloseAction).split(',');
-
-            /* Check which button should be initially chosen: */
-            QRadioButton *pRadioButton = 0;
-
-            /* If choosing 'last choice' is possible: */
-            if (lastAction[0] == strSave && fIsStateSavingAllowed)
-            {
-                pRadioButton = pDlg->mRbSave;
-            }
-            else if (lastAction[0] == strShutdown && fIsACPIShutdownAllowed && isACPIEnabled)
-            {
-                pRadioButton = pDlg->mRbShutdown;
-            }
-            else if (lastAction[0] == strPowerOff && fIsPowerOffAllowed)
-            {
-                pRadioButton = pDlg->mRbPowerOff;
-                if (fIsPowerOffAndRestoreAllowed)
-                    pDlg->mCbDiscardCurState->setChecked(lastAction.count() > 1 && lastAction[1] == strDiscardCurState);
-            }
-            /* Else 'default choice' will be used: */
-            else
-            {
-                if (fIsACPIShutdownAllowed && isACPIEnabled)
-                    pRadioButton = pDlg->mRbShutdown;
-                else if (fIsPowerOffAllowed)
-                    pRadioButton = pDlg->mRbPowerOff;
-                else if (fIsStateSavingAllowed)
-                    pRadioButton = pDlg->mRbSave;
-            }
-
-            /* If some radio button was chosen: */
-            if (pRadioButton)
-            {
-                /* Check and focus it: */
-                pRadioButton->setChecked(true);
-                pRadioButton->setFocus();
-            }
-            /* If no one of radio buttons was chosen: */
-            else
-            {
-                /* Just break and leave: */
-                delete pDlg;
-                pDlg = 0;
-                break;
-            }
-
-            /* This flag will keep the status of every further logical operation: */
-            bool fSuccess = true;
-
-            /* This flag is set if we must terminate the VM, even if server calls fail */
-            bool fForce = false;
-
-            /* Pause before showing dialog if necessary: */
-            bool fWasPaused = uisession()->isPaused() || uisession()->machineState() == KMachineState_Stuck;
-            if (!fWasPaused)
-                fSuccess = uisession()->pause();
 
             if (fSuccess)
             {
-                /* Preventing auto-closure: */
-                machineLogic()->setPreventAutoClose(true);
-
-                /* Show the close-dialog: */
-                bool fDialogAccepted = pDlg->exec() == QDialog::Accepted;
-
-                /* What was the decision? */
-                enum DialogDecision { DD_Cancel, DD_Save, DD_Shutdown, DD_PowerOff };
-                DialogDecision decision;
-                if (!fDialogAccepted)
-                    decision = DD_Cancel;
-                else if (pDlg->mRbSave->isChecked())
-                    decision = DD_Save;
-                else if (pDlg->mRbShutdown->isChecked())
-                    decision = DD_Shutdown;
-                else
-                    decision = DD_PowerOff;
-                bool fDiscardCurState = pDlg->mCbDiscardCurState->isChecked();
-                bool fDiscardCheckboxVisible = pDlg->mCbDiscardCurState->isVisibleTo(pDlg);
-
-                /* Destroy the dialog early: */
-                delete pDlg;
-                pDlg = 0;
-
-                /* Was dialog accepted? */
-                if (fDialogAccepted)
+                /* Read the last user's choice for the given VM: */
+                QStringList prevAction = m.GetExtraData(GUI_LastCloseAction).split(',');
+                /* Memorize the last user's choice for the given VM: */
+                QString strLastAction = strPowerOff;
+                switch (decision)
                 {
-                    /* Process decision: */
-                    CConsole console = session().GetConsole();
-                    fSuccess = false;
-                    switch (decision)
+                    case DD_Save: strLastAction = strSave; break;
+                    case DD_Shutdown: strLastAction = strShutdown; break;
+                    case DD_PowerOff:
                     {
-                        case DD_Save:
-                        {
-                            /* Prepare the saving progress: */
-                            CProgress progress = console.SaveState();
-                            if (console.isOk())
-                            {
-                                /* Show the saving progress dialog: */
-                                msgCenter().showModalProgressDialog(progress, m.GetName(), ":/progress_state_save_90px.png", this);
-                                if (progress.GetResultCode() == 0)
-                                    fSuccess = true;
-                                else
-                                    msgCenter().cannotSaveMachineState(progress);
-                            }
-                            else
-                                msgCenter().cannotSaveMachineState(console);
-                            if (fSuccess)
-                                fCloseApplication = true;
-                            break;
-                        }
-                        case DD_Shutdown:
-                        {
-                            /* Unpause the VM to let it grab the ACPI shutdown event: */
-                            uisession()->unpause();
-                            /* Prevent the subsequent unpause request: */
-                            fWasPaused = true;
-                            /* Signal ACPI shutdown (if there is no ACPI device, the operation will fail): */
-                            console.PowerButton();
-                            if (console.isOk())
-                                fSuccess = true;
-                            else
-                                msgCenter().cannotACPIShutdownMachine(console);
-                            break;
-                        }
-                        case DD_PowerOff:
-                        {
-                            /* Prepare the power down progress: */
-                            CProgress progress = console.PowerDown();
-                            if (console.isOk())
-                            {
-                                /* Show the power down progress: */
-                                msgCenter().showModalProgressDialog(progress, m.GetName(), ":/progress_poweroff_90px.png", this);
-                                if (progress.GetResultCode() == 0)
-                                    fSuccess = true;
-                                else
-                                    msgCenter().cannotStopMachine(progress);
-                            }
-                            else
-                            {
-                                COMResult res(console);
-                                /* This can happen if VBoxSVC is not running */
-                                if (FAILED_DEAD_INTERFACE(res.rc()))
-                                    fForce = true;
-                                else
-                                    msgCenter().cannotStopMachine(console);
-                            }
-                            if (fSuccess)
-                            {
-                                /* Discard the current state if requested: */
-                                if (fDiscardCurState && fDiscardCheckboxVisible)
-                                {
-                                    /* Prepare the snapshot discard progress: */
-                                    CSnapshot snapshot = m.GetCurrentSnapshot();
-                                    CProgress progress = console.RestoreSnapshot(snapshot);
-                                    if (console.isOk())
-                                    {
-                                        /* Show the snapshot discard progress: */
-                                        msgCenter().showModalProgressDialog(progress, m.GetName(), ":/progress_snapshot_discard_90px.png", this);
-                                        if (progress.GetResultCode() != 0)
-                                            msgCenter().cannotRestoreSnapshot(progress, snapshot.GetName());
-                                    }
-                                    else
-                                        msgCenter().cannotRestoreSnapshot(console, snapshot.GetName());
-                                }
-                            }
-                            if (fSuccess || fForce)
-                                fCloseApplication = true;
-                            break;
-                        }
-                        default:
-                            break;
+                        if (prevAction[0] == strShutdown && !fIsACPIEnabled)
+                            strLastAction = strShutdown;
+                        else
+                            strLastAction = strPowerOff;
+                        break;
                     }
-
-                    if (fSuccess)
-                    {
-                        /* Read the last user's choice for the given VM: */
-                        QStringList prevAction = m.GetExtraData(GUI_LastCloseAction).split(',');
-                        /* Memorize the last user's choice for the given VM: */
-                        QString lastAction = strPowerOff;
-                        switch (decision)
-                        {
-                            case DD_Save: lastAction = strSave; break;
-                            case DD_Shutdown: lastAction = strShutdown; break;
-                            case DD_PowerOff:
-                            {
-                                if (prevAction[0] == strShutdown && !isACPIEnabled)
-                                    lastAction = strShutdown;
-                                else
-                                    lastAction = strPowerOff;
-                                break;
-                            }
-                            default: break;
-                        }
-                        /* Memorize additional options for the given VM: */
-                        if (fDiscardCurState)
-                            (lastAction += ",") += strDiscardCurState;
-                        m.SetExtraData(GUI_LastCloseAction, lastAction);
-                    }
+                    default: break;
                 }
-
-                /* Restore the running state if needed: */
-                if (fSuccess && !fCloseApplication && !fWasPaused && uisession()->machineState() == KMachineState_Paused)
-                    uisession()->unpause();
-
-                /* Allowing auto-closure: */
-                machineLogic()->setPreventAutoClose(false);
+                /* Memorize additional options for the given VM: */
+                if (fDiscardCurState)
+                    (strLastAction += ",") += strDiscardCurState;
+                /* Save the last user's choice for the given VM: */
+                m.SetExtraData(GUI_LastCloseAction, strLastAction);
             }
-            break;
         }
-        default:
-            break;
-    }
-    if (fCloseApplication)
+
+        /* Restore the running state if needed: */
+        if (fSuccess && !fShutdownSession && !fWasPaused && uisession()->machineState() == KMachineState_Paused)
+            uisession()->unpause();
+
+        /* Allowing auto-closure: */
+        machineLogic()->setPreventAutoClose(false);
+    }
+
+    if (fShutdownSession)
     {
         /* VM has been powered off or saved. We must *safely* close VM window(s): */