Changeset 24301 in vbox for trunk/src/VBox

Timestamp:

Nov 3, 2009 10:07:55 PM (15 years ago)

Author:

vboxsync

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

54298

Message:

Main,Frontends: Added two new running states: Teleporting and LiveSnapshotting. Also added TeleportingPausedVM. Renamed TeleportingFrom to TeleportingIn.

Location:

trunk/src/VBox

Files:

• Frontends/VBoxManage/VBoxManageInfo.cpp (modified) (4 diffs)
• Frontends/VBoxManage/VBoxManageList.cpp (modified) (1 diff)
• Frontends/VBoxSDL/VBoxSDL.cpp (modified) (10 diffs)
• Frontends/VirtualBox/include/VBoxConsoleView.h (modified) (2 diffs)
• Frontends/VirtualBox/src/VBoxConsoleView.cpp (modified) (3 diffs)
• Frontends/VirtualBox/src/VBoxConsoleWnd.cpp (modified) (8 diffs)
• Frontends/VirtualBox/src/VBoxGlobal.cpp (modified) (4 diffs)
• Frontends/VirtualBox/src/VBoxMediaManagerDlg.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/VBoxSelectorWnd.cpp (modified) (5 diffs)
• Frontends/VirtualBox/src/VBoxVMListView.cpp (modified) (2 diffs)
• Frontends/VirtualBox/src/darwin/VBoxDockIconPreview.cpp (modified) (1 diff)
• Main/ConsoleImpl.cpp (modified) (24 diffs)
• Main/ConsoleImplTeleporter.cpp (modified) (3 diffs)
• Main/DisplayImpl.cpp (modified) (1 diff)
• Main/Global.cpp (modified) (2 diffs)
• Main/MachineDebuggerImpl.cpp (modified) (1 diff)
• Main/MachineImpl.cpp (modified) (17 diffs)
• Main/SnapshotImpl.cpp (modified) (2 diffs)
• Main/cbinding/tstXPCOMCCall.c (modified) (3 diffs)
• Main/idl/VirtualBox.xidl (modified) (12 diffs)
• Main/include/Global.h (modified) (3 diffs)

trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

@@ -403 +403 @@
     {
         case MachineState_PoweredOff:
-            if (details == VMINFO_MACHINEREADABLE)
-                pszState = "poweroff";
-            else
-                pszState = "powered off";
+            pszState = details == VMINFO_MACHINEREADABLE ? "poweroff"            : "powered off";
             break;
         case MachineState_Saved:
@@ -414 +411 @@
             pszState = "aborted";
             break;
+        case MachineState_Teleported:
+            pszState = "teleported";
+            break;
         case MachineState_Running:
             pszState = "running";
@@ -419 +419 @@
         case MachineState_Paused:
             pszState = "paused";
+            break;
+        case MachineState_Stuck:
+            pszState = details == VMINFO_MACHINEREADABLE ? "gurumeditation"      : "guru meditation";
+            break;
+        case MachineState_LiveSnapshotting:
+            pszState = details == VMINFO_MACHINEREADABLE ? "livesnapshotting"    : "live snapshotting";
+            break;
+        case MachineState_Teleporting:
+            pszState = "teleporting";
             break;
         case MachineState_Starting:
@@ -432 +441 @@
             pszState = "restoring";
             break;
-        case MachineState_TeleportingFrom:
-            if (details == VMINFO_MACHINEREADABLE)
-                pszState = "teleportingfrom";
-            else
-                pszState = "teleporting from";
+        case MachineState_TeleportingPausedVM:
+            pszState = details == VMINFO_MACHINEREADABLE ? "teleportingpausedvm" : "teleporting paused vm";
+            break;
+        case MachineState_TeleportingIn:
+            pszState = details == VMINFO_MACHINEREADABLE ? "teleportingin"       : "teleporting (incoming)";
+            break;
+        case MachineState_RestoringSnapshot:
+            pszState = details == VMINFO_MACHINEREADABLE ? "restoringsnapshot"   : "restoring snapshot";
+        case MachineState_DeletingSnapshot:
+            pszState = details == VMINFO_MACHINEREADABLE ? "deletingsnapshot"    : "deleting snapshot";
+        case MachineState_SettingUp:
+            pszState = details == VMINFO_MACHINEREADABLE ? "settingup"           : "setting up";
             break;
         default:

trunk/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp

@@ -230 +230 @@
                             {
                                 case MachineState_Running:
+                                case MachineState_Teleporting:
+                                case MachineState_LiveSnapshotting:
                                 case MachineState_Paused:
+                                case MachineState_TeleportingPausedVM:
                                     rc = showVMInfo(a->virtualBox,
                                                     machines[i],

trunk/src/VBox/Frontends/VBoxSDL/VBoxSDL.cpp

@@ -463 +463 @@
 
         if (     machineState == MachineState_Aborted
+            ||   machineState == MachineState_Teleported
             ||  (machineState == MachineState_Saved      && !m_fIgnorePowerOffEvents)
-            ||  (machineState == MachineState_PoweredOff && !m_fIgnorePowerOffEvents))
+            ||  (machineState == MachineState_PoweredOff && !m_fIgnorePowerOffEvents)
+           )
         {
             /*
@@ -472 +474 @@
             event.user.type = SDL_USER_EVENT_TERMINATE;
             event.user.code = machineState == MachineState_Aborted
-                                           ? VBOXSDL_TERM_ABEND
-                                           : VBOXSDL_TERM_NORMAL;
+                            ? VBOXSDL_TERM_ABEND
+                            : VBOXSDL_TERM_NORMAL;
         }
         else
@@ -605 +607 @@
             case MachineState_PoweredOff:           return "PoweredOff";
             case MachineState_Saved:                return "Saved";
+            case MachineState_Teleported:           return "Teleported";
             case MachineState_Aborted:              return "Aborted";
             case MachineState_Running:              return "Running";
+            case MachineState_Teleporting:          return "Teleporting";
+            case MachineState_LiveSnapshotting:     return "LiveSnapshotting";
             case MachineState_Paused:               return "Paused";
             case MachineState_Stuck:                return "GuruMeditation";
@@ -613 +618 @@
             case MachineState_Saving:               return "Saving";
             case MachineState_Restoring:            return "Restoring";
-            case MachineState_TeleportingFrom:      return "TeleportingFrom";
+            case MachineState_TeleportingPausedVM:  return "TeleportingPausedVM";
+            case MachineState_TeleportingIn:        return "TeleportingIn";
             case MachineState_RestoringSnapshot:    return "RestoringSnapshot";
             case MachineState_DeletingSnapshot:     return "DeletingSnapshot";
@@ -2143 +2149 @@
             &&  (   machineState == MachineState_Starting
                  || machineState == MachineState_Restoring
-                 || machineState == MachineState_TeleportingFrom)
+                 || machineState == MachineState_TeleportingIn
+                )
             )
         {
@@ -2239 +2246 @@
              && (   machineState == MachineState_Starting
                  || machineState == MachineState_Restoring
-                 || machineState == MachineState_TeleportingFrom)
+                 || machineState == MachineState_TeleportingIn
+                )
             );
 
@@ -2774 +2782 @@
      */
     if (   gConsole
-        && machineState == MachineState_Running)
+        && (   machineState == MachineState_Running
+            || machineState == MachineState_Teleporting
+            || machineState == MachineState_LiveSnapshotting
+            /** @todo power off paused VMs too? */
+           )
+       )
     {
         cbConsoleImpl->ignorePowerOffEvents(true);
@@ -4338 +4351 @@
                                 " - Restoring...");
             }
-            else if (machineState == MachineState_TeleportingFrom)
+            else if (machineState == MachineState_TeleportingIn)
             {
                 ULONG cPercentNow;
@@ -4770 +4783 @@
             MachineState_T machineState;
             gMachine->COMGETTER(State)(&machineState);
-            if (machineState == MachineState_Running)
+            bool fPauseIt = machineState == MachineState_Running
+                         || machineState == MachineState_Teleporting
+                         || machineState == MachineState_LiveSnapshotting;
+            if (fPauseIt)
                 gConsole->Pause();
             SetFullscreen(!gpFramebuffer[0]->getFullscreen());
-            if (machineState == MachineState_Running)
+            if (fPauseIt)
                 gConsole->Resume();
 
@@ -4794 +4810 @@
             MachineState_T machineState;
             gMachine->COMGETTER(State)(&machineState);
-            if (machineState == MachineState_Running)
+            if (   machineState == MachineState_Running
+                || machineState == MachineState_Teleporting
+                || machineState == MachineState_LiveSnapshotting
+               )
             {
                 if (gfGrabbed)

trunk/src/VBox/Frontends/VirtualBox/include/VBoxConsoleView.h

@@ -88 +88 @@
 
     bool pause (bool on);
-    bool isPaused() { return mLastState == KMachineState_Paused; }
+    bool isPaused()
+    {
+        return mLastState == KMachineState_Paused
+            || mLastState == KMachineState_TeleportingPausedVM;
+    }
     const QPixmap& pauseShot() const { return mPausedShot; }
 
@@ -231 +235 @@
     void setPointerShape (MousePointerChangeEvent *me);
 
-    bool isRunning() { return mLastState == KMachineState_Running; }
+    bool isRunning()
+    {
+        return mLastState == KMachineState_Running
+            || mLastState == KMachineState_Teleporting
+            || mLastState == KMachineState_LiveSnapshotting;
+    }
 
     static void dimImage (QImage &img);

trunk/src/VBox/Frontends/VirtualBox/src/VBoxConsoleView.cpp

@@ -3294 +3294 @@
     {
         case KMachineState_Paused:
+        case KMachineState_TeleportingPausedVM: /** @todo Live Migration: Check out this */
         {
             if (mode != VBoxDefs::TimerMode && mFrameBuf)
@@ -3328 +3329 @@
         case KMachineState_Running:
         {
-            if (mLastState == KMachineState_Paused)
+            if (   mLastState == KMachineState_Paused
+                || mLastState == KMachineState_TeleportingPausedVM
+               )
             {
                 if (mode != VBoxDefs::TimerMode && mFrameBuf)
@@ -4227 +4230 @@
         (mLastState == KMachineState_Running ||
          mLastState == KMachineState_Paused ||
+         mLastState == KMachineState_Teleporting ||
+         mLastState == KMachineState_LiveSnapshotting ||
          mLastState == KMachineState_Restoring ||
-         mLastState == KMachineState_TeleportingFrom ||
+         mLastState == KMachineState_TeleportingPausedVM ||
+         mLastState == KMachineState_TeleportingIn ||
          mLastState == KMachineState_Saving))
         updateDockIcon();

trunk/src/VBox/Frontends/VirtualBox/src/VBoxConsoleWnd.cpp

@@ -1273 +1273 @@
     }
 
-    if (mMachineState > KMachineState_Paused && mMachineState != KMachineState_Stuck)
-    {
-        /* The machine is in some temporary state like Saving or Stopping.
-         * Ignore the close event. When it is Stopping, it will be soon closed anyway from updateMachineState().
-         * In all other cases, an appropriate progress dialog will be shown within a few seconds. */
-        aEvent->ignore();
-    }
-    else if (mMachineState < KMachineState_Running)
-    {
-        /* The machine has been already powered off or saved or aborted -- close the window immediately. */
-        aEvent->accept();
-    }
-    else
-    {
-        /* Start with ignore the close event */
-        aEvent->ignore();
-
-        bool isACPIEnabled = mSession.GetConsole().GetGuestEnteredACPIMode();
-
-        bool success = true;
-
-        bool wasPaused = mMachineState == KMachineState_Paused || mMachineState == KMachineState_Stuck;
-        if (!wasPaused)
-        {
-            /* Suspend the VM and ignore the close event if failed to do so.
-             * pause() will show the error message to the user. */
-            success = mConsole->pause (true);
-        }
-
-        if (success)
-        {
-            success = false;
-
-            CMachine machine = mSession.GetMachine();
-            VBoxCloseVMDlg dlg (this);
-            QString typeId = machine.GetOSTypeId();
-            dlg.pmIcon->setPixmap (vboxGlobal().vmGuestOSTypeIcon (typeId));
-
-            /* Make the Discard checkbox invisible if there are no snapshots */
-            dlg.mCbDiscardCurState->setVisible (machine.GetSnapshotCount() > 0);
-
-            if (mMachineState != KMachineState_Stuck)
+    switch (mMachineState)
+    {
+        case KMachineState_PoweredOff:
+        case KMachineState_Saved:
+        case KMachineState_Teleported:
+        case KMachineState_Aborted:
+            /* The machine has been already powered off or saved or aborted -- close the window immediately. */
+            aEvent->accept();
+            break;
+
+        default:
+            /* The machine is in some temporary state like Saving or Stopping.
+             * Ignore the close event. When it is Stopping, it will be soon closed anyway from updateMachineState().
+             * In all other cases, an appropriate progress dialog will be shown within a few seconds. */
+            aEvent->ignore();
+            break;
+
+        case KMachineState_Teleporting:      /** @todo Live Migration: Test closing a VM that's being teleported or snapshotted. */
+        case KMachineState_LiveSnapshotting:
+        case KMachineState_Running:
+        case KMachineState_Paused:
+        case KMachineState_TeleportingPausedVM: /** @todo Live Migration: Check out this. */
+        case KMachineState_Stuck:
+            /* Start with ignoring the close event */
+            aEvent->ignore();
+
+            bool isACPIEnabled = mSession.GetConsole().GetGuestEnteredACPIMode();
+
+            bool success = true;
+
+            bool wasPaused = mMachineState == KMachineState_Paused
+                          || mMachineState == KMachineState_Stuck
+                          || mMachineState == KMachineState_TeleportingPausedVM;
+            if (!wasPaused)
             {
-                /* Read the last user's choice for the given VM */
-                QStringList lastAction = machine.GetExtraData (VBoxDefs::GUI_LastCloseAction).split (',');
-                AssertWrapperOk (machine);
-                if (lastAction [0] == kSave)
+                /* Suspend the VM and ignore the close event if failed to do so.
+                 * pause() will show the error message to the user. */
+                success = mConsole->pause (true);
+            }
+
+            if (success)
+            {
+                success = false;
+
+                CMachine machine = mSession.GetMachine();
+                VBoxCloseVMDlg dlg (this);
+                QString typeId = machine.GetOSTypeId();
+                dlg.pmIcon->setPixmap (vboxGlobal().vmGuestOSTypeIcon (typeId));
+
+                /* Make the Discard checkbox invisible if there are no snapshots */
+                dlg.mCbDiscardCurState->setVisible (machine.GetSnapshotCount() > 0);
+
+                if (mMachineState != KMachineState_Stuck)
                 {
-                    dlg.mRbSave->setChecked (true);
-                    dlg.mRbSave->setFocus();
+                    /* Read the last user's choice for the given VM */
+                    QStringList lastAction = machine.GetExtraData (VBoxDefs::GUI_LastCloseAction).split (',');
+                    AssertWrapperOk (machine);
+                    if (lastAction [0] == kSave)
+                    {
+                        dlg.mRbSave->setChecked (true);
+                        dlg.mRbSave->setFocus();
+                    }
+                    else if (lastAction [0] == kPowerOff || !isACPIEnabled)
+                    {
+                        dlg.mRbShutdown->setEnabled (isACPIEnabled);
+                        dlg.mRbPowerOff->setChecked (true);
+                        dlg.mRbPowerOff->setFocus();
+                    }
+                    else /* The default is ACPI Shutdown */
+                    {
+                        dlg.mRbShutdown->setChecked (true);
+                        dlg.mRbShutdown->setFocus();
+                    }
+                    dlg.mCbDiscardCurState->setChecked (lastAction.count() > 1 && lastAction [1] == kDiscardCurState);
                 }
-                else if (lastAction [0] == kPowerOff || !isACPIEnabled)
+                else
                 {
-                    dlg.mRbShutdown->setEnabled (isACPIEnabled);
+                    /* The stuck VM can only be powered off; disable anything else and choose PowerOff */
+                    dlg.mRbSave->setEnabled (false);
+                    dlg.mRbShutdown->setEnabled (false);
                     dlg.mRbPowerOff->setChecked (true);
-                    dlg.mRbPowerOff->setFocus();
                 }
-                else /* The default is ACPI Shutdown */
+
+                bool wasShutdown = false;
+
+                if (dlg.exec() == QDialog::Accepted)
                 {
-                    dlg.mRbShutdown->setChecked (true);
-                    dlg.mRbShutdown->setFocus();
+                    /* Disable auto closure because we want to have a chance to show
+                     * the error dialog on save state / power off failure. */
+                    mNoAutoClose = true;
+
+                    CConsole console = mConsole->console();
+
+                    if (dlg.mRbSave->isChecked())
+                    {
+                        CProgress progress = console.SaveState();
+
+                        if (console.isOk())
+                        {
+                            /* Show the "VM saving" progress dialog */
+                            vboxProblem().showModalProgressDialog (progress, machine.GetName(), this, 0);
+                            if (progress.GetResultCode() != 0)
+                                vboxProblem().cannotSaveMachineState (progress);
+                            else
+                                success = true;
+                        }
+                        else
+                            vboxProblem().cannotSaveMachineState (console);
+                    }
+                    else if (dlg.mRbShutdown->isChecked())
+                    {
+                        /* Unpause the VM to let it grab the ACPI shutdown event */
+                        mConsole->pause (false);
+                        /* Prevent the subsequent unpause request */
+                        wasPaused = true;
+                        /* Signal ACPI shutdown (if there is no ACPI device, the
+                         * operation will fail) */
+                        console.PowerButton();
+                        wasShutdown = console.isOk();
+                        if (!wasShutdown)
+                            vboxProblem().cannotACPIShutdownMachine (console);
+                        /* Success is always false because we never accept the close
+                         * window action when doing ACPI shutdown */
+                        success = false;
+                    }
+                    else if (dlg.mRbPowerOff->isChecked())
+                    {
+                        CProgress progress = console.PowerDown();
+
+                        if (console.isOk())
+                        {
+                            /* Show the power down progress dialog */
+                            vboxProblem().showModalProgressDialog (progress, machine.GetName(), this, 0);
+                            if (progress.GetResultCode() != 0)
+                                vboxProblem().cannotStopMachine (progress);
+                            else
+                                success = true;
+                        }
+                        else
+                            vboxProblem().cannotStopMachine (console);
+
+                        if (success)
+                        {
+                            /* Note: leave success = true even if we fail to
+                             * discard the current state later -- the console window
+                             * will closed anyway */
+
+                            /* Discard the current state if requested */
+                            if (dlg.mCbDiscardCurState->isChecked() && dlg.mCbDiscardCurState->isVisibleTo (&dlg))
+                            {
+                                CSnapshot snapshot = machine.GetCurrentSnapshot();
+                                CProgress progress = console.RestoreSnapshot (snapshot);
+                                if (console.isOk())
+                                {
+                                    /* Show the progress dialog */
+                                    vboxProblem().showModalProgressDialog (progress, machine.GetName(), this);
+                                    if (progress.GetResultCode() != 0)
+                                        vboxProblem().cannotRestoreSnapshot (progress, snapshot.GetName());
+                                }
+                                else
+                                    vboxProblem().cannotRestoreSnapshot (console, snapshot.GetName());
+                            }
+                        }
+                    }
+
+                    if (success)
+                    {
+                        /* Accept the close action on success */
+                        aEvent->accept();
+                    }
+
+                    if (success || wasShutdown)
+                    {
+                        /* Read the last user's choice for the given VM */
+                        QStringList prevAction = machine.GetExtraData (VBoxDefs::GUI_LastCloseAction).split (',');
+                        /* Memorize the last user's choice for the given VM */
+                        QString lastAction = kPowerOff;
+                        if (dlg.mRbSave->isChecked())
+                            lastAction = kSave;
+                        else if (dlg.mRbShutdown->isChecked() ||
+                                 (dlg.mRbPowerOff->isChecked() && prevAction [0] == kShutdown && !isACPIEnabled))
+                            lastAction = kShutdown;
+                        else if (dlg.mRbPowerOff->isChecked())
+                            lastAction = kPowerOff;
+                        else
+                            AssertFailed();
+                        if (dlg.mCbDiscardCurState->isChecked())
+                            (lastAction += ",") += kDiscardCurState;
+                        machine.SetExtraData (VBoxDefs::GUI_LastCloseAction, lastAction);
+                        AssertWrapperOk (machine);
+                    }
                 }
-                dlg.mCbDiscardCurState->setChecked (lastAction.count() > 1 && lastAction [1] == kDiscardCurState);
+            }
+
+            mNoAutoClose = false;
+
+            if (   mMachineState == KMachineState_PoweredOff
+                || mMachineState == KMachineState_Saved
+                || mMachineState == KMachineState_Teleported
+                || mMachineState == KMachineState_Aborted
+               )
+            {
+                /* The machine has been stopped while showing the Close or the Pause
+                 * failure dialog -- accept the close event immediately. */
+                aEvent->accept();
             }
             else
             {
-                /* The stuck VM can only be powered off; disable anything else and choose PowerOff */
-                dlg.mRbSave->setEnabled (false);
-                dlg.mRbShutdown->setEnabled (false);
-                dlg.mRbPowerOff->setChecked (true);
-            }
-
-            bool wasShutdown = false;
-
-            if (dlg.exec() == QDialog::Accepted)
-            {
-                /* Disable auto closure because we want to have a chance to show
-                 * the error dialog on save state / power off failure. */
-                mNoAutoClose = true;
-
-                CConsole console = mConsole->console();
-
-                if (dlg.mRbSave->isChecked())
+                if (!success)
                 {
-                    CProgress progress = console.SaveState();
-
-                    if (console.isOk())
-                    {
-                        /* Show the "VM saving" progress dialog */
-                        vboxProblem().showModalProgressDialog (progress, machine.GetName(), this, 0);
-                        if (progress.GetResultCode() != 0)
-                            vboxProblem().cannotSaveMachineState (progress);
-                        else
-                            success = true;
-                    }
-                    else
-                        vboxProblem().cannotSaveMachineState (console);
-                }
-                else if (dlg.mRbShutdown->isChecked())
-                {
-                    /* Unpause the VM to let it grab the ACPI shutdown event */
-                    mConsole->pause (false);
-                    /* Prevent the subsequent unpause request */
-                    wasPaused = true;
-                    /* Signal ACPI shutdown (if there is no ACPI device, the
-                     * operation will fail) */
-                    console.PowerButton();
-                    wasShutdown = console.isOk();
-                    if (!wasShutdown)
-                        vboxProblem().cannotACPIShutdownMachine (console);
-                    /* Success is always false because we never accept the close
-                     * window action when doing ACPI shutdown */
-                    success = false;
-                }
-                else if (dlg.mRbPowerOff->isChecked())
-                {
-                    CProgress progress = console.PowerDown();
-
-                    if (console.isOk())
-                    {
-                        /* Show the power down progress dialog */
-                        vboxProblem().showModalProgressDialog (progress, machine.GetName(), this, 0);
-                        if (progress.GetResultCode() != 0)
-                            vboxProblem().cannotStopMachine (progress);
-                        else
-                            success = true;
-                    }
-                    else
-                        vboxProblem().cannotStopMachine (console);
-
-                    if (success)
-                    {
-                        /* Note: leave success = true even if we fail to
-                         * discard the current state later -- the console window
-                         * will closed anyway */
-
-                        /* Discard the current state if requested */
-                        if (dlg.mCbDiscardCurState->isChecked() && dlg.mCbDiscardCurState->isVisibleTo (&dlg))
-                        {
-                            CSnapshot snapshot = machine.GetCurrentSnapshot();
-                            CProgress progress = console.RestoreSnapshot (snapshot);
-                            if (console.isOk())
-                            {
-                                /* Show the progress dialog */
-                                vboxProblem().showModalProgressDialog (progress, machine.GetName(), this);
-                                if (progress.GetResultCode() != 0)
-                                    vboxProblem().cannotRestoreSnapshot (progress, snapshot.GetName());
-                            }
-                            else
-                                vboxProblem().cannotRestoreSnapshot (console, snapshot.GetName());
-                        }
-                    }
-                }
-
-                if (success)
-                {
-                    /* Accept the close action on success */
-                    aEvent->accept();
-                }
-
-                if (success || wasShutdown)
-                {
-                    /* Read the last user's choice for the given VM */
-                    QStringList prevAction = machine.GetExtraData (VBoxDefs::GUI_LastCloseAction).split (',');
-                    /* Memorize the last user's choice for the given VM */
-                    QString lastAction = kPowerOff;
-                    if (dlg.mRbSave->isChecked())
-                        lastAction = kSave;
-                    else if (dlg.mRbShutdown->isChecked() ||
-                             (dlg.mRbPowerOff->isChecked() && prevAction [0] == kShutdown && !isACPIEnabled))
-                        lastAction = kShutdown;
-                    else if (dlg.mRbPowerOff->isChecked())
-                        lastAction = kPowerOff;
-                    else
-                        AssertFailed();
-                    if (dlg.mCbDiscardCurState->isChecked())
-                        (lastAction += ",") += kDiscardCurState;
-                    machine.SetExtraData (VBoxDefs::GUI_LastCloseAction, lastAction);
-                    AssertWrapperOk (machine);
+                    /* Restore the running state if needed */
+                    if (!wasPaused && mMachineState == KMachineState_Paused)
+                        mConsole->pause (false);
                 }
             }
-        }
-
-        mNoAutoClose = false;
-
-        if (mMachineState < KMachineState_Running)
-        {
-            /* The machine has been stopped while showing the Close or the Pause
-             * failure dialog -- accept the close event immediately. */
-            aEvent->accept();
-        }
-        else
-        {
-            if (!success)
-            {
-                /* Restore the running state if needed */
-                if (!wasPaused && mMachineState == KMachineState_Paused)
-                    mConsole->pause (false);
-            }
-        }
+            break;
     }
 
@@ -1773 +1789 @@
     /* Check if we missed a really quick termination after successful
      * startup, and process it if we did. */
-    if (mMachineState < KMachineState_Running)
+    if (   mMachineState == KMachineState_PoweredOff
+        || mMachineState == KMachineState_Saved
+        || mMachineState == KMachineState_Teleported
+        || mMachineState == KMachineState_Aborted
+       )
     {
         close();
@@ -2475 +2495 @@
     if (mConsole && mMachineState != aState)
     {
-        if (aState >= KMachineState_Running)
-        {
-            switch (aState)
+        switch (aState)
+        {
+            case KMachineState_Stuck:
             {
-                case KMachineState_Stuck:
-                {
-                    guruMeditation = true;
-                    break;
-                }
-                case KMachineState_Paused:
-                {
-                    if (!mVmPauseAction->isChecked())
-                        mVmPauseAction->setChecked (true);
-                    break;
-                }
-                case KMachineState_Running:
-                {
-                    if (mMachineState == KMachineState_Paused && mVmPauseAction->isChecked())
-                        mVmPauseAction->setChecked (false);
-                    break;
-                }
+                guruMeditation = true;
+                break;
+            }
+            case KMachineState_Paused:
+            {
+                if (!mVmPauseAction->isChecked())
+                    mVmPauseAction->setChecked (true);
+                break;
+            }
+            case KMachineState_Running:
+            case KMachineState_Teleporting:         /** @todo Live Migration: Check out this. */
+            case KMachineState_LiveSnapshotting:
+            {
+                if (   (   mMachineState == KMachineState_Paused
+                        || mMachineState == KMachineState_TeleportingPausedVM)
+                    && mVmPauseAction->isChecked()
+                   )
+                    mVmPauseAction->setChecked (false);
+                break;
+            }
 #ifdef Q_WS_X11
-                case KMachineState_Starting:
-                {
-                    /* The keyboard handler may wish to do some release logging
-                       on startup.  Tell it that the logger is now active. */
-                    doXKeyboardLogging (QX11Info::display());
-                    break;
-                }
-#endif
-                default:
-                    break;
+            case KMachineState_Starting:
+            case KMachineState_Restoring:
+            case KMachineState_TeleportingIn:
+            {
+                /* The keyboard handler may wish to do some release logging
+                   on startup.  Tell it that the logger is now active. */
+                doXKeyboardLogging (QX11Info::display());
+                break;
             }
-        }
-
-        bool isRunningOrPaused = aState == KMachineState_Running || aState == KMachineState_Paused;
+#endif
+            default:
+                break;
+        }
+
+        bool isRunningOrPaused = aState == KMachineState_Running
+                              || aState == KMachineState_Teleporting
+                              || aState == KMachineState_LiveSnapshotting /** @todo Live Migration: Check out this. */
+                              || aState == KMachineState_Paused;
 
         /* Enable/Disable actions that are not managed by updateAppearanceOf() */
 
-        mRunningActions->setEnabled (aState == KMachineState_Running);
+        mRunningActions->setEnabled (   aState == KMachineState_Running
+                                     || aState == KMachineState_Teleporting
+                                     || aState == KMachineState_LiveSnapshotting  /** @todo Live Migration: Check out this. */
+                                    );
         mRunningOrPausedActions->setEnabled (isRunningOrPaused);
 
@@ -2524 +2554 @@
                             PauseAction | DisableMouseIntegrAction);
 
-        if (aState < KMachineState_Running)
+        if (   aState == KMachineState_PoweredOff
+            || aState == KMachineState_Saved
+            || aState == KMachineState_Teleported
+            || aState == KMachineState_Aborted
+           )
         {
             /* VM has been powered off or saved or aborted, no matter
@@ -2773 +2807 @@
     CConsole console = mConsole->console();
 
-    bool isRunningOrPaused = mMachineState == KMachineState_Running || mMachineState == KMachineState_Paused;
+    bool isStrictRunningOrPaused = mMachineState == KMachineState_Running
+                                || mMachineState == KMachineState_Paused;
+    bool isRunningOrPaused = isStrictRunningOrPaused
+                          || mMachineState == KMachineState_Teleporting
+                          || mMachineState == KMachineState_LiveSnapshotting;
 
     if (aElement & Caption)
@@ -2896 +2934 @@
         mNetLed->setState (count > 0 ? KDeviceActivity_Idle : KDeviceActivity_Null);
 
-        mDevicesNetworkDialogAction->setEnabled (isRunningOrPaused && count > 0);
-        mDevicesNetworkMenu->setEnabled (isRunningOrPaused && count > 0);
+        mDevicesNetworkDialogAction->setEnabled (isStrictRunningOrPaused && count > 0);
+        mDevicesNetworkMenu->setEnabled (isStrictRunningOrPaused && count > 0);
 
         QString tip = tr ("<p style='white-space:pre'><nobr>Indicates the activity of the "
@@ -2931 +2969 @@
             if (!usbctl.isNull() && usbctl.GetEnabled())
             {
-                mDevicesUSBMenu->setEnabled (isRunningOrPaused);
+                mDevicesUSBMenu->setEnabled (isStrictRunningOrPaused);
 
                 CUSBDeviceVector devsvec = console.GetUSBDevices();
@@ -3069 +3107 @@
             mVmDisableMouseIntegrAction->setStatusTip (tr ("Enable temporarily disabled host mouse pointer integration"));
         }
-        if (mMachineState == KMachineState_Running)
+        if (   mMachineState == KMachineState_Running
+            || mMachineState == KMachineState_Teleporting
+            || mMachineState == KMachineState_LiveSnapshotting
+           )
             mVmDisableMouseIntegrAction->setEnabled (mConsole->isMouseAbsolute());
         else

trunk/src/VBox/Frontends/VirtualBox/src/VBoxGlobal.cpp

@@ -2634 +2634 @@
     mMachineStates [KMachineState_PoweredOff] = tr ("Powered Off", "MachineState");
     mMachineStates [KMachineState_Saved] =      tr ("Saved", "MachineState");
+    mMachineStates [KMachineState_Teleported] = tr ("Teleported", "MachineState");
     mMachineStates [KMachineState_Aborted] =    tr ("Aborted", "MachineState");
     mMachineStates [KMachineState_Running] =    tr ("Running", "MachineState");
     mMachineStates [KMachineState_Paused] =     tr ("Paused", "MachineState");
-    mMachineStates [KMachineState_Stuck] =      tr ("Stuck", "MachineState");
+    mMachineStates [KMachineState_Stuck] =      tr ("Guru Meditation", "MachineState");
+    mMachineStates [KMachineState_Teleporting] = tr ("Teleporting", "MachineState");
+    mMachineStates [KMachineState_LiveSnapshotting] = tr ("Live Snapshotting", "MachineState");
     mMachineStates [KMachineState_Starting] =   tr ("Starting", "MachineState");
     mMachineStates [KMachineState_Stopping] =   tr ("Stopping", "MachineState");
     mMachineStates [KMachineState_Saving] =     tr ("Saving", "MachineState");
     mMachineStates [KMachineState_Restoring] =  tr ("Restoring", "MachineState");
-    mMachineStates [KMachineState_TeleportingFrom] = tr ("Teleporting", "MachineState");
+    mMachineStates [KMachineState_TeleportingPausedVM] = tr ("Teleporting Paused VM", "MachineState");
+    mMachineStates [KMachineState_TeleportingIn] = tr ("Teleporting", "MachineState");
     mMachineStates [KMachineState_RestoringSnapshot] = tr ("Restoring Snapshot", "MachineState");
     mMachineStates [KMachineState_DeletingSnapshot] = tr ("Deleting Snapshot", "MachineState");
@@ -4606 +4610 @@
         {KMachineState_Saved, ":/state_saved_16px.png"},
         {KMachineState_Aborted, ":/state_aborted_16px.png"},
+        {KMachineState_Teleported, ":/state_saved_16px.png"},           /** @todo Live Migration: New icon? (not really important) */
         {KMachineState_Running, ":/state_running_16px.png"},
         {KMachineState_Paused, ":/state_paused_16px.png"},
+        {KMachineState_Teleporting, ":/state_running_16px.png"},        /** @todo Live Migration: New icon? (not really important) */
+        {KMachineState_LiveSnapshotting, ":/state_running_16px.png"},   /** @todo Live Migration: New icon? (not really important) */
         {KMachineState_Stuck, ":/state_stuck_16px.png"},
         {KMachineState_Starting, ":/state_running_16px.png"}, /// @todo (dmik) separate icon?
@@ -4613 +4620 @@
         {KMachineState_Saving, ":/state_saving_16px.png"},
         {KMachineState_Restoring, ":/state_restoring_16px.png"},
-        {KMachineState_TeleportingFrom, ":/state_restoring_16px.png"}, /** @todo Live Migration: New icon? (not really important) */
+        {KMachineState_TeleportingPausedVM, ":/state_saving_16px.png"}, /** @todo Live Migration: New icon? (not really important) */
+        {KMachineState_TeleportingIn, ":/state_restoring_16px.png"},    /** @todo Live Migration: New icon? (not really important) */
         {KMachineState_RestoringSnapshot, ":/state_discarding_16px.png"},
         {KMachineState_DeletingSnapshot, ":/state_discarding_16px.png"},
@@ -4629 +4637 @@
     mVMStateColors.insert (KMachineState_Saved,         new QColor (Qt::yellow));
     mVMStateColors.insert (KMachineState_Aborted,       new QColor (Qt::darkRed));
+    mVMStateColors.insert (KMachineState_Teleported,    new QColor (Qt::red));
     mVMStateColors.insert (KMachineState_Running,       new QColor (Qt::green));
     mVMStateColors.insert (KMachineState_Paused,        new QColor (Qt::darkGreen));
     mVMStateColors.insert (KMachineState_Stuck,         new QColor (Qt::darkMagenta));
+    mVMStateColors.insert (KMachineState_Teleporting,   new QColor (Qt::blue));
+    mVMStateColors.insert (KMachineState_LiveSnapshotting, new QColor (Qt::green));
     mVMStateColors.insert (KMachineState_Starting,      new QColor (Qt::green));
     mVMStateColors.insert (KMachineState_Stopping,      new QColor (Qt::green));
     mVMStateColors.insert (KMachineState_Saving,        new QColor (Qt::green));
     mVMStateColors.insert (KMachineState_Restoring,     new QColor (Qt::green));
-    mVMStateColors.insert (KMachineState_TeleportingFrom, new QColor (Qt::green));
+    mVMStateColors.insert (KMachineState_TeleportingPausedVM, new QColor (Qt::blue));
+    mVMStateColors.insert (KMachineState_TeleportingIn, new QColor (Qt::blue));
     mVMStateColors.insert (KMachineState_RestoringSnapshot, new QColor (Qt::green));
     mVMStateColors.insert (KMachineState_DeletingSnapshot, new QColor (Qt::green));

trunk/src/VBox/Frontends/VirtualBox/src/VBoxMediaManagerDlg.cpp

@@ -1437 +1437 @@
         case KMachineState_Aborted:
         case KMachineState_Saved:
+        case KMachineState_Teleported:
         case KMachineState_Starting:
         case KMachineState_Restoring:
-        case KMachineState_TeleportingFrom:
+        case KMachineState_TeleportingIn:
         {
             refreshAll();

trunk/src/VBox/Frontends/VirtualBox/src/VBoxSelectorWnd.cpp

@@ -980 +980 @@
     }
 
-    AssertMsg (item->state() < KMachineState_Running,
-               ("Machine must be PoweredOff/Saved/Aborted"));
+    AssertMsg (   item->state() == KMachineState_PoweredOff
+               || item->state() == KMachineState_Saved
+               || item->state() == KMachineState_Teleported
+               || item->state() == KMachineState_Aborted
+               , ("Machine must be PoweredOff/Saved/Aborted (%d)", item->state()));
 
     QString id = item->id();
@@ -1455 +1458 @@
         mVmDeleteAction->setEnabled (modifyEnabled);
         mVmDiscardAction->setEnabled (state == KMachineState_Saved && !running);
-        mVmPauseAction->setEnabled (state == KMachineState_Running ||
-                                   state == KMachineState_Paused);
+        mVmPauseAction->setEnabled (   state == KMachineState_Running
+                                    || state == KMachineState_Teleporting
+                                    || state == KMachineState_LiveSnapshotting
+                                    || state == KMachineState_Paused
+                                    || state == KMachineState_TeleportingPausedVM /** @todo Live Migration: does this make sense? */
+                                   );
 
         /* change the Start button text accordingly */
-        if (state >= KMachineState_Running)
+        if (   state == KMachineState_PoweredOff
+            || state == KMachineState_Saved
+            || state == KMachineState_Teleported
+            || state == KMachineState_Aborted
+           )
+        {
+            mVmStartAction->setText (tr ("S&tart"));
+            mVmStartAction->setStatusTip (
+                tr ("Start the selected virtual machine"));
+
+            mVmStartAction->setEnabled (!running);
+        }
+        else
         {
             mVmStartAction->setText (tr ("S&how"));
@@ -1467 +1486 @@
             mVmStartAction->setEnabled (item->canSwitchTo());
         }
-        else
-        {
-            mVmStartAction->setText (tr ("S&tart"));
-            mVmStartAction->setStatusTip (
-                tr ("Start the selected virtual machine"));
-
-            mVmStartAction->setEnabled (!running);
-        }
 
         /* change the Pause/Resume button text accordingly */
-        if (state == KMachineState_Paused)
+        if (   state == KMachineState_Paused
+            || state == KMachineState_TeleportingPausedVM /*?*/
+           )
         {
             mVmPauseAction->setText (tr ("R&esume"));
@@ -1865 +1878 @@
 
         /* Change the Start button text accordingly */
-        if (s >= KMachineState_Running)
+        if (   s == KMachineState_PoweredOff
+            || s == KMachineState_Saved
+            || s == KMachineState_Teleported
+            || s == KMachineState_Aborted
+           )
+        {
+            mVmStartAction->setText (VBoxVMListView::tr ("S&tart"));
+            mVmStartAction->setStatusTip (
+                  VBoxVMListView::tr ("Start the selected virtual machine"));
+            mVmStartAction->setEnabled (!running);
+        }
+        else
         {
             mVmStartAction->setText (VBoxVMListView::tr ("S&how"));
@@ -1872 +1896 @@
             mVmStartAction->setEnabled (pItem->canSwitchTo());
         }
-        else
-        {
-            mVmStartAction->setText (VBoxVMListView::tr ("S&tart"));
-            mVmStartAction->setStatusTip (
-                  VBoxVMListView::tr ("Start the selected virtual machine"));
-            mVmStartAction->setEnabled (!running);
-        }
 
         /* Change the Pause/Resume button text accordingly */
-        mVmPauseAction->setEnabled (s == KMachineState_Running ||
-                                    s == KMachineState_Paused);
-
-        if (s == KMachineState_Paused)
+        mVmPauseAction->setEnabled (   s == KMachineState_Running
+                                    || s == KMachineState_Teleporting
+                                    || s == KMachineState_LiveSnapshotting
+                                    || s == KMachineState_Paused
+                                    || s == KMachineState_TeleportingPausedVM
+                                   );
+
+        if (   s == KMachineState_Paused
+            || s == KMachineState_TeleportingPausedVM /*?*/
+           )
         {
             mVmPauseAction->setText (VBoxVMListView::tr ("R&esume"));

trunk/src/VBox/Frontends/VirtualBox/src/VBoxVMListView.cpp

@@ -213 +213 @@
         mSnapshotCount = mMachine.GetSnapshotCount();
 
-        if (mState >= KMachineState_Running)
+        if (   mState == KMachineState_PoweredOff
+            || mState == KMachineState_Saved
+            || mState == KMachineState_Teleported
+            || mState == KMachineState_Aborted
+           )
+        {
+            mPid = (ULONG) ~0;
+    /// @todo Remove. See @c todo in #switchTo() below.
+#if 0
+            mWinId = (WId) ~0;
+#endif
+        }
+        else
         {
             mPid = mMachine.GetSessionPid();
@@ -219 +231 @@
 #if 0
             mWinId = FindWindowIdFromPid (mPid);
-#endif
-        }
-        else
-        {
-            mPid = (ULONG) ~0;
-    /// @todo Remove. See @c todo in #switchTo() below.
-#if 0
-            mWinId = (WId) ~0;
 #endif
         }

trunk/src/VBox/Frontends/VirtualBox/src/darwin/VBoxDockIconPreview.cpp

@@ -117 +117 @@
 {
     CGImageRef img;
-    if (mMainWnd->machineState() == KMachineState_Paused)
+    if (   mMainWnd->machineState() == KMachineState_Paused
+        || mMainWnd->machineState() == KMachineState_TeleportingPausedVM)
         img = mStatePaused;
     else if (   mMainWnd->machineState() == KMachineState_Restoring
-             || mMainWnd->machineState() == KMachineState_TeleportingFrom)
+             || mMainWnd->machineState() == KMachineState_TeleportingIn)
         img = mStateRestoring;
-    else if (mMainWnd->machineState() == KMachineState_Saving)
+    else if (   mMainWnd->machineState() == KMachineState_Saving
+             || mMainWnd->machineState() == KMachineState_LiveSnapshotting)
         img = mStateSaving;
     else

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -1504 +1504 @@
     AutoWriteLock alock(this);
 
-    if (!Global::IsActive(mMachineState))
-    {
+    /** @todo Live Migration: Support powering down while teleporting. Maybe also
+     *        while taking a live snapshot.  (In case they never finish and you
+     *        or some other operator wish to shut down the VM.) */
+    switch (mMachineState)
+    {
+        case MachineState_Running:
+        case MachineState_Paused:
+        case MachineState_Stuck:
+            break;
+
         /* extra nice error message for a common case */
-        if (mMachineState == MachineState_Saved)
+        case MachineState_Saved:
+            return setError(VBOX_E_INVALID_VM_STATE, tr("Cannot power down a saved virtual machine"));
+        case MachineState_Stopping:
+            return setError(VBOX_E_INVALID_VM_STATE, tr("Virtual machine is being powered down."));
+        default:
             return setError(VBOX_E_INVALID_VM_STATE,
-                tr("Cannot power down a saved virtual machine"));
-        else if (mMachineState == MachineState_Stopping)
-            return setError(VBOX_E_INVALID_VM_STATE,
-                tr("Virtual machine is being powered down."));
-        else
-            return setError(VBOX_E_INVALID_VM_STATE,
-                tr("Invalid machine state: %s (must be Running, Paused or Stuck)"),
-                Global::stringifyMachineState(mMachineState));
+                            tr("Invalid machine state: %s (must be Running, Paused or Stuck)"),
+                            Global::stringifyMachineState(mMachineState));
     }
 
@@ -1564 +1570 @@
     AutoWriteLock alock(this);
 
-    if (mMachineState != MachineState_Running)
+    if (   mMachineState != MachineState_Running
+        && mMachineState != MachineState_Teleporting
+        && mMachineState != MachineState_LiveSnapshotting
+        /** @todo r=bird: This should be allowed on paused VMs as well. Later.  */
+       )
         return setError(VBOX_E_INVALID_VM_STATE,
             tr("Invalid machine state: %s"),
@@ -1597 +1607 @@
     AutoWriteLock alock(this);
 
-    if (mMachineState != MachineState_Running)
+    if (   mMachineState != MachineState_Running
+        && mMachineState != MachineState_Teleporting
+        && mMachineState != MachineState_LiveSnapshotting
+       )
         return setError(VBOX_E_INVALID_VM_STATE,
             tr("Invalid machine state: %s"),
@@ -1671 +1684 @@
     AutoWriteLock alock(this);
 
-    if (mMachineState != MachineState_Running)
+    if (   mMachineState != MachineState_Running
+        && mMachineState != MachineState_Teleporting
+        && mMachineState != MachineState_LiveSnapshotting
+       )
         return setError(VBOX_E_INVALID_VM_STATE,
             tr("Invalid machine state: %s"),
@@ -1712 +1728 @@
     AutoWriteLock alock(this);
 
-    if (mMachineState != MachineState_Running)
+    if (   mMachineState != MachineState_Running
+        && mMachineState != MachineState_Teleporting
+        && mMachineState != MachineState_LiveSnapshotting
+       )
         return setError(VBOX_E_INVALID_VM_STATE,
             tr("Invalid machine state: %s"),
@@ -1756 +1775 @@
     AutoWriteLock alock(this);
 
-    if (mMachineState != MachineState_Running)
+    if (   mMachineState != MachineState_Running
+        && mMachineState != MachineState_Teleporting
+        && mMachineState != MachineState_LiveSnapshotting
+       )
         return setError(VBOX_E_INVALID_VM_STATE,
             tr("Invalid machine state %s when checking if the guest entered the ACPI mode)"),
@@ -1791 +1813 @@
     AutoWriteLock alock(this);
 
-    if (mMachineState != MachineState_Running)
+    if (mMachineState != MachineState_Running) /** @todo Live Migration: ??? */
         return setError(VBOX_E_INVALID_VM_STATE,
             tr("Invalid machine state: %s)"),
@@ -1832 +1854 @@
     AutoWriteLock alock(this);
 
-    if (mMachineState != MachineState_Running &&
-        mMachineState != MachineState_Paused)
+    if (   mMachineState != MachineState_Running
+        && mMachineState != MachineState_Paused)
     {
         return setError(VBOX_E_INVALID_VM_STATE,
@@ -1970 +1992 @@
     AutoWriteLock alock(this);
 
-    if (mMachineState != MachineState_PoweredOff &&
-        mMachineState != MachineState_Aborted)
+    if (   mMachineState != MachineState_PoweredOff
+        && mMachineState != MachineState_Teleported
+        && mMachineState != MachineState_Aborted
+       )
         return setError(VBOX_E_INVALID_VM_STATE,
-            tr("Cannot adopt the saved machine state as the machine is not in Powered Off or Aborted state (machine state: %s)"),
+            tr("Cannot adopt the saved machine state as the machine is not in Powered Off, Teleported or Aborted state (machine state: %s)"),
             Global::stringifyMachineState(mMachineState));
 
@@ -2109 +2133 @@
     AutoWriteLock alock(this);
 
-    if (mMachineState != MachineState_Running &&
-        mMachineState != MachineState_Paused)
+    if (   mMachineState != MachineState_Running
+        && mMachineState != MachineState_Paused)
         return setError(VBOX_E_INVALID_VM_STATE,
             tr("Cannot attach a USB device to the machine which is not running or paused (machine state: %s)"),
@@ -2288 +2312 @@
         return setError(VBOX_E_INVALID_VM_STATE,
             tr("Cannot create a transient shared folder on the machine in the saved state"));
-    if (mMachineState > MachineState_Paused)
+    if (   mMachineState != MachineState_PoweredOff
+        && mMachineState != MachineState_Teleported
+        && mMachineState != MachineState_Aborted
+        && mMachineState != MachineState_Running
+        && mMachineState != MachineState_Paused
+       )
         return setError(VBOX_E_INVALID_VM_STATE,
             tr("Cannot create a transient shared folder on the machine while it is changing the state (machine state: %s)"),
@@ -2350 +2379 @@
         return setError(VBOX_E_INVALID_VM_STATE,
             tr("Cannot remove a transient shared folder from the machine in the saved state"));
-    if (mMachineState > MachineState_Paused)
+    if (   mMachineState != MachineState_PoweredOff
+        && mMachineState != MachineState_Teleported
+        && mMachineState != MachineState_Aborted
+        && mMachineState != MachineState_Running
+        && mMachineState != MachineState_Paused
+       )
         return setError(VBOX_E_INVALID_VM_STATE,
             tr("Cannot remove a transient shared folder from the machine while it is changing the state (machine state: %s)"),
@@ -3514 +3548 @@
     HRESULT rc = S_OK;
 
-    if (mVRDPServer && mMachineState == MachineState_Running)
+    if (    mVRDPServer
+        &&  (   mMachineState == MachineState_Running
+             || mMachineState == MachineState_Teleporting
+             || mMachineState == MachineState_LiveSnapshotting
+            )
+       )
     {
         BOOL vrdpEnabled = FALSE;
@@ -4008 +4047 @@
     AutoWriteLock alock(this);
 
-    AssertReturn(    mMachineState == MachineState_Saving
-                  || mMachineState == MachineState_RestoringSnapshot
-                  || mMachineState == MachineState_DeletingSnapshot,
-                 E_FAIL);
+    AssertReturn(   mMachineState == MachineState_Saving
+                 || mMachineState == MachineState_LiveSnapshotting
+                 || mMachineState == MachineState_RestoringSnapshot
+                 || mMachineState == MachineState_DeletingSnapshot
+                 , E_FAIL);
 
     return setMachineStateLocally(aMachineState);
@@ -4712 +4752 @@
         setMachineState(MachineState_Restoring);
     else if (fTeleporterEnabled)
-        setMachineState(MachineState_TeleportingFrom);
+        setMachineState(MachineState_TeleportingIn);
     else
         setMachineState(MachineState_Starting);
@@ -4772 +4812 @@
     Assert(mpVM != NULL);
 
-    AssertMsg(mMachineState == MachineState_Running ||
-              mMachineState == MachineState_Paused ||
-              mMachineState == MachineState_Stuck ||
-              mMachineState == MachineState_Saving ||
-              mMachineState == MachineState_Starting ||
-              mMachineState == MachineState_Restoring ||
-              mMachineState == MachineState_TeleportingFrom || /** @todo Teleportation ???*/
-              mMachineState == MachineState_Stopping,
-              ("Invalid machine state: %s\n", Global::stringifyMachineState(mMachineState)));
+    AssertMsg(   mMachineState == MachineState_Running
+              || mMachineState == MachineState_Paused
+              || mMachineState == MachineState_Teleporting           /** @todo Live Migration: ???*/
+              || mMachineState == MachineState_LiveSnapshotting      /** @todo Live Migration: ???*/
+              || mMachineState == MachineState_Stuck
+              || mMachineState == MachineState_Starting
+              || mMachineState == MachineState_Stopping
+              || mMachineState == MachineState_Saving
+              || mMachineState == MachineState_Restoring
+              || mMachineState == MachineState_TeleportingPausedVM   /** @todo Teleportation ???*/
+              || mMachineState == MachineState_TeleportingIn         /** @todo Teleportation ???*/
+              , ("Invalid machine state: %s\n", Global::stringifyMachineState(mMachineState)));
 
     LogRel(("Console::powerDown(): A request to power off the VM has been issued (mMachineState=%d, InUninit=%d)\n",
@@ -4793 +4836 @@
         && (   mMachineState == MachineState_Starting
             || mMachineState == MachineState_Restoring
-            || mMachineState == MachineState_TeleportingFrom)
+            || mMachineState == MachineState_TeleportingIn)
        )
         mVMPoweredOff = true;
@@ -4801 +4844 @@
      * set the state to Saved on VMSTATE_TERMINATED. In terms of protecting from
      * inappropriate operations while leaving the lock below, Saving or
-     * Restoring should be fine too */
+     * Restoring should be fine too.  Ditto for Teleporting* -> Teleported. */
     if (   mMachineState != MachineState_Saving
         && mMachineState != MachineState_Restoring
-        && mMachineState != MachineState_TeleportingFrom
         && mMachineState != MachineState_Stopping
+        && mMachineState != MachineState_TeleportingIn
+        && mMachineState != MachineState_Teleporting /** @todo Live Migration: what should really happen here? */
+        && mMachineState != MachineState_TeleportingPausedVM
+        && mMachineState != MachineState_LiveSnapshotting /** @todo Live Migration: what should really happen here? */
        )
         setMachineState(MachineState_Stopping);
@@ -4862 +4908 @@
                 uint32_t fFlags;
                 guestProp::validateFlags(Utf8Str(flagsOut[i]).raw(), &fFlags);
-                if (   !( fFlags & guestProp::TRANSIENT)
-                    || (mMachineState == MachineState_Saving)
+                if (   !(fFlags & guestProp::TRANSIENT)
+                    || mMachineState == MachineState_Saving
+                    || mMachineState == MachineState_LiveSnapshotting
                   )
                 {
@@ -5490 +5537 @@
                 && that->mMachineState != MachineState_Saving
                 && that->mMachineState != MachineState_Restoring
-                && that->mMachineState != MachineState_TeleportingFrom
+                && that->mMachineState != MachineState_TeleportingIn
+                && that->mMachineState != MachineState_LiveSnapshotting
+                && that->mMachineState != MachineState_Teleporting
+                && that->mMachineState != MachineState_TeleportingPausedVM
                )
             {
@@ -5585 +5635 @@
                     that->setMachineState(MachineState_Saved);
                     break;
-                case MachineState_TeleportingFrom:
+                case MachineState_TeleportingIn:
                     /* Teleportation failed or was cancelled.  Back to powered off. */
                     that->setMachineState(MachineState_PoweredOff);
                     break;
+                case MachineState_Teleporting:
+                case MachineState_TeleportingPausedVM:
+                    /* Successfully teleported the VM. */
+                    that->setMachineState(MachineState_Teleported);
+                    break;
             }
             break;
@@ -5595 +5650 @@
         case VMSTATE_SUSPENDED:
         {
-            /** @todo state/live VMSTATE_SUSPENDING_LS. */
+            /** @todo Live Migration: state/live VMSTATE_SUSPENDING_LS. */
             if (aOldState == VMSTATE_SUSPENDING)
             {
@@ -5626 +5681 @@
                            && aOldState == VMSTATE_POWERING_ON)
                        || (   (   that->mMachineState == MachineState_Restoring
-                               || that->mMachineState == MachineState_TeleportingFrom
+                               || that->mMachineState == MachineState_TeleportingIn
                                || that->mMachineState == MachineState_Paused)
                            && aOldState == VMSTATE_RESUMING));
@@ -6821 +6876 @@
     if (   console->mMachineState == MachineState_Starting
         || console->mMachineState == MachineState_Restoring
-        || console->mMachineState == MachineState_TeleportingFrom
+        || console->mMachineState == MachineState_TeleportingIn
        )
     {

trunk/src/VBox/Main/ConsoleImplTeleporter.cpp

@@ -684 +684 @@
      */
     AutoWriteLock autoLock(pState->mptrConsole);
-    if (pState->mptrConsole->mMachineState == MachineState_Saving)
-    {
+    if (   pState->mptrConsole->mMachineState == MachineState_Teleporting
+        || pState->mptrConsole->mMachineState == MachineState_TeleportingPausedVM
+       )
+    {
+/** @todo shut down the VM and deal with Pause() and PowerDown() calls!! */
         VMSTATE enmVMState = VMR3GetState(pState->mpVM);
         if (SUCCEEDED(hrc))
         {
             if (enmVMState == VMSTATE_SUSPENDED)
-                pState->mptrConsole->setMachineState(MachineState_Paused);
+                pState->mptrConsole->setMachineState(MachineState_TeleportingPausedVM);
         }
         else
@@ -779 +782 @@
         default:
             return setError(VBOX_E_INVALID_VM_STATE,
-                tr("Invalid machine state: %s (must be Running, Paused or Stuck)"),
+                tr("Invalid machine state: %s (must be Running or Paused)"),
                 Global::stringifyMachineState(mMachineState));
     }
@@ -810 +813 @@
     if (RT_SUCCESS(vrc))
     {
-        hrc = setMachineState(MachineState_Saving);
+        if (mMachineState == MachineState_Running)
+            hrc = setMachineState(MachineState_Teleporting);
+        else
+            hrc = setMachineState(MachineState_TeleportingPausedVM);
         if (SUCCEEDED(hrc))
             ptrProgress.queryInterfaceTo(aProgress);

trunk/src/VBox/Main/DisplayImpl.cpp

@@ -281 +281 @@
 STDMETHODIMP Display::OnStateChange(MachineState_T machineState)
 {
-    if (machineState == MachineState_Running)
-    {
-        LogFlowFunc (("Machine is running.\n"));
+    if (   machineState == MachineState_Running
+        || machineState == MachineState_Teleporting
+        || machineState == MachineState_LiveSnapshotting
+       )
+    {
+        LogFlowFunc(("Machine is running.\n"));
 
         mfMachineRunning = true;

trunk/src/VBox/Main/Global.cpp

@@ -189 +189 @@
         case MachineState_PoweredOff:           return "PoweredOff";
         case MachineState_Saved:                return "Saved";
+        case MachineState_Teleported:           return "Teleported";
         case MachineState_Aborted:              return "Aborted";
         case MachineState_Running:              return "Running";
+        case MachineState_Teleporting:          return "Teleporting";
+        case MachineState_LiveSnapshotting:     return "LiveSnapshotting";
         case MachineState_Paused:               return "Paused";
         case MachineState_Stuck:                return "GuruMeditation";
@@ -197 +200 @@
         case MachineState_Saving:               return "Saving";
         case MachineState_Restoring:            return "Restoring";
-        case MachineState_TeleportingFrom:      return "TeleportingFrom";
+        case MachineState_TeleportingPausedVM:  return "TeleportingPausedVM";
+        case MachineState_TeleportingIn:        return "TeleportingIn";
         case MachineState_RestoringSnapshot:    return "RestoringSnapshot";
         case MachineState_DeletingSnapshot:     return "DeletingSnapshot";

trunk/src/VBox/Main/MachineDebuggerImpl.cpp

@@ -789 +789 @@
         MachineState_T machineState;
         mParent->COMGETTER(State) (&machineState);
-        if (!Global::IsActive (machineState))
+        switch (machineState)
+        {
             // queue the request
-            return true;
+            default:
+                return true;
+
+            case MachineState_Running:
+            case MachineState_Paused:
+            case MachineState_Stuck:
+            case MachineState_LiveSnapshotting:
+            case MachineState_Teleporting:
+                break;
+        }
     }
     return false;

trunk/src/VBox/Main/MachineImpl.cpp

@@ -2017 +2017 @@
         &&  (   mType != IsSessionMachine
              || (   mData->mMachineState != MachineState_PoweredOff
-                 && mData->mMachineState != MachineState_Aborted)
+                 && mData->mMachineState != MachineState_Teleported
+                 && mData->mMachineState != MachineState_Aborted
+                )
             )
        )
@@ -4908 +4910 @@
         case MutableStateDep:
         {
-            if (mData->mRegistered &&
-                (mType != IsSessionMachine ||
-                 mData->mMachineState > MachineState_Paused ||
-                 mData->mMachineState == MachineState_Saved))
+            if (   mData->mRegistered
+                && (   mType != IsSessionMachine  /** @todo This was just convered raw; Check if Running and Paused should actually be included here... (Live Migration) */
+                    || (   mData->mMachineState != MachineState_Paused
+                        && mData->mMachineState != MachineState_Running
+                        && mData->mMachineState != MachineState_Aborted
+                        && mData->mMachineState != MachineState_Teleported
+                        && mData->mMachineState != MachineState_PoweredOff
+                       )
+                   )
+               )
                 return setError(VBOX_E_INVALID_VM_STATE,
                                 tr("The machine is not mutable (state is %s)"),
@@ -4919 +4927 @@
         case MutableOrSavedStateDep:
         {
-            if (mData->mRegistered &&
-                (mType != IsSessionMachine ||
-                 mData->mMachineState > MachineState_Paused))
+            if (   mData->mRegistered
+                && (   mType != IsSessionMachine  /** @todo This was just convered raw; Check if Running and Paused should actually be included here... (Live Migration) */
+                    || (   mData->mMachineState != MachineState_Paused
+                        && mData->mMachineState != MachineState_Running
+                        && mData->mMachineState != MachineState_Aborted
+                        && mData->mMachineState != MachineState_Teleported
+                        && mData->mMachineState != MachineState_Saved
+                        && mData->mMachineState != MachineState_PoweredOff
+                       )
+                   )
+               )
                 return setError(VBOX_E_INVALID_VM_STATE,
                                 tr("The machine is not mutable (state is %s)"),
@@ -6353 +6369 @@
         mData->m_pMachineConfigFile->timeLastStateChange = mData->mLastStateChange;
         mData->m_pMachineConfigFile->fAborted = (mData->mMachineState == MachineState_Aborted);
+/// @todo Live Migration:        mData->m_pMachineConfigFile->fTeleported = (mData->mMachineState == MachineState_Teleported);
 
         mData->m_pMachineConfigFile->fTeleporterEnabled    = !!mUserData->mTeleporterEnabled;
@@ -6761 +6778 @@
 
             mData->m_pMachineConfigFile->fAborted = (mData->mMachineState == MachineState_Aborted);
+//@todo live migration             mData->m_pMachineConfigFile->fTeleported = (mData->mMachineState == MachineState_Teleported);
         }
 
@@ -6819 +6837 @@
 
     /* must be in a protective state because we leave the lock below */
-    AssertReturn(    mData->mMachineState == MachineState_Saving
-                  || mData->mMachineState == MachineState_RestoringSnapshot
-                  || mData->mMachineState == MachineState_DeletingSnapshot,
-                 E_FAIL);
+    AssertReturn(   mData->mMachineState == MachineState_Saving
+                 || mData->mMachineState == MachineState_LiveSnapshotting
+                 || mData->mMachineState == MachineState_RestoringSnapshot
+                 || mData->mMachineState == MachineState_DeletingSnapshot
+                 , E_FAIL);
 
     HRESULT rc = S_OK;
@@ -7038 +7057 @@
         MachineState_T oldState = mData->mMachineState;
         if (    oldState != MachineState_Saving
+             && oldState != MachineState_LiveSnapshotting
              && oldState != MachineState_RestoringSnapshot
              && oldState != MachineState_DeletingSnapshot
@@ -8662 +8682 @@
     AutoWriteLock alock(this);
 
-    AssertReturn(mData->mMachineState == MachineState_PoweredOff ||
-                  mData->mMachineState == MachineState_Aborted,
-                  E_FAIL);
+    AssertReturn(   mData->mMachineState == MachineState_PoweredOff
+                 || mData->mMachineState == MachineState_Teleported
+                 || mData->mMachineState == MachineState_Aborted
+                 , E_FAIL); /** @todo setError. */
 
     Utf8Str stateFilePathFull = aSavedStateFile;
@@ -9163 +9184 @@
         case MachineState_Starting:
         case MachineState_Restoring:
-        case MachineState_TeleportingFrom:
+        case MachineState_TeleportingIn:
         case MachineState_Paused:
         case MachineState_Running:
+        /** @todo Live Migration: snapshoting & teleporting. Need to fend things of
+         *        elsewhere... */
             return mUSBController->hasMatchingFilter (aDevice, aMaskedIfs);
         default: break;
@@ -9319 +9342 @@
     AssertReturn(   mData->mMachineState == MachineState_Starting
                  || mData->mMachineState == MachineState_Restoring
-                 || mData->mMachineState == MachineState_TeleportingFrom, E_FAIL);
+                 || mData->mMachineState == MachineState_TeleportingIn, E_FAIL);
 
     typedef std::list <ComPtr<IMedium> > MediaList;
@@ -9495 +9518 @@
     if (   (   oldMachineState == MachineState_Saved
             && aMachineState   == MachineState_Restoring)
-        || (   oldMachineState == MachineState_PoweredOff
-            && aMachineState   == MachineState_TeleportingFrom)
-        || (   oldMachineState <  MachineState_Running /* any other OFF state */
-            && aMachineState   == MachineState_Starting)
+        || (   (   oldMachineState == MachineState_PoweredOff
+                || oldMachineState == MachineState_Teleported
+                || oldMachineState == MachineState_Aborted
+               )
+            && (   aMachineState   == MachineState_TeleportingIn
+                || aMachineState   == MachineState_Starting
+               )
+           )
        )
     {
@@ -9508 +9535 @@
         /// change anything when in the Starting/Restoring state
     }
-    else if (   oldMachineState >= MachineState_Running
-             && oldMachineState != MachineState_RestoringSnapshot
-             && oldMachineState != MachineState_DeletingSnapshot
-             && oldMachineState != MachineState_SettingUp
-             && aMachineState < MachineState_Running
+    else if (   (   oldMachineState == MachineState_Running
+                 || oldMachineState == MachineState_Paused
+                 || oldMachineState == MachineState_Teleporting
+                 || oldMachineState == MachineState_LiveSnapshotting
+                 || oldMachineState == MachineState_Stuck
+                 || oldMachineState == MachineState_Starting
+                 || oldMachineState == MachineState_Stopping
+                 || oldMachineState == MachineState_Saving
+                 || oldMachineState == MachineState_Restoring
+                 || oldMachineState == MachineState_TeleportingPausedVM
+                 || oldMachineState == MachineState_TeleportingIn
+                 )
+             && (   aMachineState == MachineState_PoweredOff
+                 || aMachineState == MachineState_Saved
+                 || aMachineState == MachineState_Teleported
+                 || aMachineState == MachineState_Aborted
+                )
              /* ignore PoweredOff->Saving->PoweredOff transition when taking a
               * snapshot */
              && (   mSnapshotData.mSnapshot.isNull()
-                 || mSnapshotData.mLastState >= MachineState_Running)
+                 || mSnapshotData.mLastState >= MachineState_Running /** @todo Live Migration: clean up (lazy bird) */
+                )
             )
     {
@@ -9543 +9583 @@
     else if (   oldMachineState == MachineState_Saved
              && (   aMachineState == MachineState_PoweredOff
-                 || aMachineState == MachineState_Aborted)
+                 || aMachineState == MachineState_Aborted
+                 || aMachineState == MachineState_Teleported
+                )
             )
     {
@@ -9569 +9611 @@
     if (   aMachineState == MachineState_Starting
         || aMachineState == MachineState_Restoring
-        || aMachineState == MachineState_TeleportingFrom
+        || aMachineState == MachineState_TeleportingIn
        )
     {
@@ -9596 +9638 @@
     mPeer->setMachineState (aMachineState);
 
-    if (aMachineState == MachineState_PoweredOff ||
-        aMachineState == MachineState_Aborted ||
-        aMachineState == MachineState_Saved)
+    if (   aMachineState == MachineState_PoweredOff
+        || aMachineState == MachineState_Teleported
+        || aMachineState == MachineState_Aborted
+        || aMachineState == MachineState_Saved)
     {
         /* the machine has stopped execution
@@ -9605 +9648 @@
     }
 
-    if ((oldMachineState == MachineState_PoweredOff ||
-         oldMachineState == MachineState_Aborted) &&
-        aMachineState == MachineState_Saved)
+    if (   (   oldMachineState == MachineState_PoweredOff
+            || oldMachineState == MachineState_Aborted
+            || oldMachineState == MachineState_Teleported
+           )
+        && aMachineState == MachineState_Saved)
     {
         /* the saved state file was adopted */
@@ -9616 +9661 @@
     rc = saveStateSettings (stsFlags);
 
-    if ((oldMachineState != MachineState_PoweredOff &&
-         oldMachineState != MachineState_Aborted) &&
-        (aMachineState == MachineState_PoweredOff ||
-         aMachineState == MachineState_Aborted))
+    if (   (   oldMachineState != MachineState_PoweredOff
+            && oldMachineState != MachineState_Aborted
+            && oldMachineState != MachineState_Teleported
+           )
+        && (   aMachineState == MachineState_PoweredOff
+            || aMachineState == MachineState_Aborted
+            || aMachineState == MachineState_Teleported
+           )
+       )
     {
         /* we've been shut down for any reason */

trunk/src/VBox/Main/SnapshotImpl.cpp

@@ -1272 +1272 @@
         mMediaData.backup();
 
-        /* set the state to Saving (this is expected by Console::TakeSnapshot()) */
-        setMachineState(MachineState_Saving);
+        /* Console::fntTakeSnapshotWorker and friends expects this. */
+        if (mSnapshotData.mLastState == MachineState_Running)
+            setMachineState(MachineState_LiveSnapshotting);
+        else
+            setMachineState(MachineState_Saving); /** @todo Confusing! Saving is used for both online and offline snapshots. */
 
         /* create new differencing hard disks and attach them to this machine */
@@ -1351 +1354 @@
     AutoWriteLock alock(this);
 
-    AssertReturn(!aSuccess ||
-                  (mData->mMachineState == MachineState_Saving &&
-                   mSnapshotData.mLastState != MachineState_Null &&
-                   !mSnapshotData.mSnapshot.isNull()),
-                  E_FAIL);
+    AssertReturn(   !aSuccess
+                 || (    (    mData->mMachineState == MachineState_Saving
+                          ||  mData->mMachineState == MachineState_LiveSnapshotting)
+                     &&  mSnapshotData.mLastState != MachineState_Null
+                     &&  !mSnapshotData.mSnapshot.isNull()
+                    )
+                 , E_FAIL);
 
     /*

trunk/src/VBox/Main/cbinding/tstXPCOMCCall.c

@@ -76 +76 @@
         case MachineState_PoweredOff:          return "PoweredOff";
         case MachineState_Saved:               return "Saved";
+        case MachineState_Teleported:          return "Teleported";
         case MachineState_Aborted:             return "Aborted";
         case MachineState_Running:             return "Running";
+        case MachineState_Teleporting:         return "Teleporting";
+        case MachineState_LiveSnapshotting:    return "LiveSnapshotting";
         case MachineState_Paused:              return "Paused";
         case MachineState_Stuck:               return "Stuck";
@@ -84 +87 @@
         case MachineState_Saving:              return "Saving";
         case MachineState_Restoring:           return "Restoring";
-        case MachineState_TeleportingFrom:     return "TeleportingFrom";
+        case MachineState_TeleportingPausedVM: return "TeleportingPausedVM";
+        case MachineState_TeleportingIn:       return "TeleportingIn";
         case MachineState_Discarding:          return "Discarding";
         case MachineState_SettingUp:           return "SettingUp";
@@ -130 +134 @@
     printf("OnStateChange: %s\n", GetStateName(state));
     fflush(stdout);
-    if (state == MachineState_PoweredOff)
+    if (   state == MachineState_PoweredOff
+        || state == MachineState_Saved
+        || state == MachineState_Teleported
+        || state == MachineState_Aborted
+       )
         g_fStop = 1;
     return 0;

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -473 +473 @@
   <enum
     name="MachineState"
-    uuid="0f4cc50c-e1cc-4cde-ae7a-e6164bac5ba2"
+    uuid="36518cf6-cdf0-4d0d-ad2a-5ee9c60c7494"
   >
     <desc>
@@ -616 +616 @@
       </desc>
     </const>
-    <const name="Aborted"               value="3">
+    <const name="Teleported"            value="3">
+      <desc>
+        The machine was teleported to a different host (or process) and then
+        powered off.  Take care when powering it on again may corrupt resources
+        it shares with the teleportation target (e.g. disk and network).
+      </desc>
+    </const>
+    <const name="Aborted"               value="4">
       <desc>
         The process running the machine has terminated abnormally. This may
@@ -623 +630 @@
       </desc>
     </const>
-    <const name="Running"               value="4">
+    <const name="Running"               value="5">
       <desc>
         The machine is currently being executed.
@@ -630 +637 @@
           comparisons in the old source code valid, this state must immediately
           precede the Paused state.
+          TODO: Lift this spectacularly wonderful restriction.
         </note>
       </desc>
     </const>
-    <const name="Paused"                value="5">
+    <const name="Paused"                value="6">
       <desc>
         Execution of the machine has been paused.
@@ -640 +648 @@
           comparisons in the old source code valid, this state must immediately
           follow the Running state.
+          TODO: Lift this spectacularly wonderful restriction.
         </note>
       </desc>
     </const>
-    <const name="Stuck"                 value="6">
+    <const name="Stuck"                 value="7">
       <desc>
         Execution of the machine has reached the "Guru Meditation"
         condition. This indicates a severe error in the hypervisor itself.
-      </desc>
-    </const>
-    <const name="Starting"              value="7">
+        <note internal="yes">
+          bird: Why this uncool name? Could we rename it to "GuruMeditation" or
+                "Guru", perhaps? Or are there some other VMM states that are
+                intended to be lumped in here as well?
+        </note>
+      </desc>
+    </const>
+    <const name="Teleporting"           value="8">
+      <desc>
+        The machine is about to be teleported to a different host or process.
+        It is possible to pause a machine in this state, but it will go to the
+        <link to="MachineState::PausedTeleporting"/> state and it will not be
+        possible to resume it again unless the teleportation fails.
+      </desc>
+    </const>
+    <const name="LiveSnapshotting"      value="9">
+      <desc>
+        A live snapshot is being taken.  The machine is running normally, but
+        some of the runtime configuration options are inaccessible.  Also, if
+        paused while in this state it will transition to
+        <link to="MachineState::Saving"/> and it will not be resume the
+        execution until the snapshot operation has completed.
+      </desc>
+    </const>
+    <const name="Starting"              value="10">
       <desc>
         Machine is being started after powering it on from a
@@ -655 +686 @@
       </desc>
     </const>
-    <const name="Stopping"              value="8">
+    <const name="Stopping"              value="11">
       <desc>
         Machine is being normally stopped powering it off, or after the guest OS
@@ -661 +692 @@
       </desc>
     </const>
-    <const name="Saving"                value="9">
+    <const name="Saving"                value="12">
       <desc>
         Machine is saving its execution state to a file, or an online
@@ -667 +698 @@
       </desc>
     </const>
-    <const name="Restoring"             value="10">
+    <const name="Restoring"             value="13">
       <desc>
         Execution state of the machine is being restored from a file
@@ -673 +704 @@
       </desc>
     </const>
-    <const name="TeleportingFrom"       value="11">
-      <desc>
-        Teleporting the machine state from another host or process.
-      </desc>
-    </const>
-    <const name="RestoringSnapshot"     value="12">
+    <const name="TeleportingPausedVM"   value="14">
+      <desc>
+        The machine is being teleported to another host or process, but it is
+        not running.  This is the paused variant of the
+        <link to="MachineState::Teleporting"/> state.
+      </desc>
+    </const>
+    <const name="TeleportingIn"         value="15">
+      <desc>
+        Teleporting the machine state in from another host or process.
+      </desc>
+    </const>
+    <const name="RestoringSnapshot"     value="16">
       <desc>
         A machine snapshot is being restored; this typically does not take long.
       </desc>
     </const>
-    <const name="DeletingSnapshot"      value="13">
+    <const name="DeletingSnapshot"      value="17">
       <desc>
         A machine snapshot is being deleted; this can take a long time since this
@@ -689 +727 @@
       </desc>
     </const>
-    <const name="SettingUp"             value="14">
+    <const name="SettingUp"             value="18">
       <desc>
         Lengthy setup operation is in progress.
@@ -695 +733 @@
     </const>
 
-    <const name="FirstOnline" value="4" wsmap="suppress"> <!-- Running -->
+    <const name="FirstOnline" value="5" wsmap="suppress"> <!-- Running -->
       <desc>
         Pseudo-state: first online state (for use in relational expressions).
       </desc>
     </const>
-    <const name="LastOnline"  value="11" wsmap="suppress"> <!-- Restoring -->
+    <const name="LastOnline"  value="13" wsmap="suppress"> <!-- TeleportingIn -->
       <desc>
         Pseudo-state: last online state (for use in relational expressions).
@@ -706 +744 @@
     </const>
 
-    <const name="FirstTransient" value="7" wsmap="suppress"> <!-- Starting -->
+    <const name="FirstTransient" value="8" wsmap="suppress"> <!-- Teleporting -->
       <desc>
         Pseudo-state: first transient state (for use in relational expressions).
       </desc>
     </const>
-    <const name="LastTransient"  value="14" wsmap="suppress"> <!-- SettingUp -->
+    <const name="LastTransient"  value="18" wsmap="suppress"> <!-- SettingUp -->
       <desc>
         Pseudo-state: last transient state (for use in relational expressions).

trunk/src/VBox/Main/include/Global.h

@@ -73 +73 @@
      * dedicated process) or not. Note that some online states are also
      * transitional states (see #IsTransitional()).
+     *
+     * @remarks Saving may actually be an offline state according to the
+     *          documentation (offline snapshot).
      */
     static bool IsOnline(MachineState_T aState)
     {
+#if 0
         return aState >= MachineState_FirstOnline &&
                aState <= MachineState_LastOnline;
+#else
+        switch (aState)
+        {
+            case MachineState_Running:
+            case MachineState_Paused:
+            case MachineState_Teleporting:
+            case MachineState_LiveSnapshotting:
+            case MachineState_Stuck:
+            case MachineState_Starting:
+            case MachineState_Stopping:
+            case MachineState_Saving:
+            case MachineState_Restoring:
+            case MachineState_TeleportingPausedVM:
+            case MachineState_TeleportingIn:
+                return true;
+            default:
+                return false;
+        }
+#endif
     }
 
@@ -89 +112 @@
     static bool IsTransient(MachineState_T aState)
     {
+#if 0
         return aState >= MachineState_FirstTransient &&
                aState <= MachineState_LastTransient;
+#else
+        switch (aState)
+        {
+            case MachineState_Teleporting:
+            case MachineState_LiveSnapshotting:
+            case MachineState_Starting:
+            case MachineState_Stopping:
+            case MachineState_Saving:
+            case MachineState_Restoring:
+            case MachineState_TeleportingPausedVM:
+            case MachineState_TeleportingIn:
+            case MachineState_RestoringSnapshot:
+            case MachineState_DeletingSnapshot:
+            case MachineState_SettingUp:
+                return true;
+            default:
+                return false;
+        }
+#endif
     }
 
     /**
-     * Shortcut to <tt>IsOnline (aState) || IsTransient (aState)</tt>. When it
-     * returns @false, the VM is turned off (no VM process) and not busy with
+     * Shortcut to <tt>IsOnline(aState) || IsTransient(aState)</tt>. When it returns
+     * @false, the VM is turned off (no VM process) and not busy with
      * another exclusive operation.
      */
@@ -101 +144 @@
     {
         return IsOnline(aState) || IsTransient(aState);
-    }
-
-    /**
-     * Shortcut to <tt>IsOnline (aState) && !IsTransient (aState)</tt>. This is
-     * a recommended way to detect if the VM emulation thread is in action
-     * (either running, suspended, or stuck). When this method returns @false,
-     * then either the VM is not online or the emulation thread is being started
-     * or stopped, etc.
-     */
-    static bool IsActive(MachineState_T aState)
-    {
-        return IsOnline(aState) && !IsTransient(aState);
     }