Changeset 49506 in vbox for trunk/src/VBox

Timestamp:

Nov 15, 2013 2:38:02 PM (11 years ago)

Author:

vboxsync

Message:

FE/Qt: Runtime UI: Make sure last visual-state type chosen by user persist through GUI restart.

Location:

trunk/src/VBox/Frontends/VirtualBox/src/runtime

Files:

• UIMachine.cpp (modified) (3 diffs)
• UIMachineLogic.cpp (modified) (2 diffs)
• UIMachineLogic.h (modified) (2 diffs)
• UISession.cpp (modified) (6 diffs)
• UISession.h (modified) (5 diffs)
• normal/UIMachineLogicNormal.cpp (modified) (1 diff)
• normal/UIMachineLogicNormal.h (modified) (1 diff)
• seamless/UIMachineLogicSeamless.cpp (modified) (2 diffs)
• seamless/UIMachineLogicSeamless.h (modified) (1 diff)

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

@@ -249 +249 @@
     /* Load extra-data settings: */
     {
-        /* Machine while saving own settings will save "yes" only for current
+        /* Machine while saving own settings will save "on" only for current
          * visual representation mode if its differs from normal mode of course.
          * But user can alter extra data manually in machine xml file and set there
@@ -278 +278 @@
                 /* We can't enter seamless mode initially,
                  * so we should ask ui-session for that: */
-                uisession()->setSeamlessModeRequested(true);
+                uisession()->setRequestedVisualState(UIVisualStateType_Seamless);
             }
         }
@@ -303 +303 @@
     /* Save extra-data settings: */
     {
-        /* Set 'scale' flag: */
-        machine.SetExtraData(GUI_Scale, m_pVisualState &&
-                             m_pVisualState->visualStateType() == UIVisualStateType_Scale ? "on" : QString());
-
-        /* Set 'seamless' flag: */
-        machine.SetExtraData(GUI_Seamless, m_pVisualState &&
-                             m_pVisualState->visualStateType() == UIVisualStateType_Seamless ? "on" : QString());
-
-        /* Set 'fullscreen' flag: */
-        machine.SetExtraData(GUI_Fullscreen, m_pVisualState &&
-                             m_pVisualState->visualStateType() == UIVisualStateType_Fullscreen ? "on" : QString());
+        /* Prepare extra-data values: */
+        QString strFullscreenRequested;
+        QString strSeamlessRequested;
+        QString strScaleRequested;
+        /* Check if some state was requested: */
+        if (uisession()->requestedVisualState() != UIVisualStateType_Invalid)
+        {
+            switch (uisession()->requestedVisualState())
+            {
+                case UIVisualStateType_Fullscreen: strFullscreenRequested = "on"; break;
+                case UIVisualStateType_Seamless: strSeamlessRequested = "on"; break;
+                case UIVisualStateType_Scale: strScaleRequested = "on"; break;
+                default: break;
+            }
+        }
+        /* Check if some state still exists: */
+        else if (m_pVisualState)
+        {
+            switch (m_pVisualState->visualStateType())
+            {
+                case UIVisualStateType_Fullscreen: strFullscreenRequested = "on"; break;
+                case UIVisualStateType_Seamless: strSeamlessRequested = "on"; break;
+                case UIVisualStateType_Scale: strScaleRequested = "on"; break;
+                default: break;
+            }
+        }
+        /* Rewrite extra-data values: */
+        machine.SetExtraData(GUI_Fullscreen, strFullscreenRequested);
+        machine.SetExtraData(GUI_Seamless, strSeamlessRequested);
+        machine.SetExtraData(GUI_Scale, strScaleRequested);
     }
 }

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

@@ -709 +709 @@
 {
     /* We should check for entering/exiting requested modes: */
-    connect(uisession(), SIGNAL(sigMachineStarted()), this, SLOT(sltCheckRequestedModes()));
-    connect(uisession(), SIGNAL(sigAdditionsStateChange()), this, SLOT(sltCheckRequestedModes()));
+    connect(uisession(), SIGNAL(sigMachineStarted()), this, SLOT(sltCheckForRequestedVisualStateType()));
+    connect(uisession(), SIGNAL(sigAdditionsStateChange()), this, SLOT(sltCheckForRequestedVisualStateType()));
 
     /* Machine state-change updater: */
@@ -1090 +1090 @@
     /* Call to base-class: */
     return QIWithRetranslateUI3<QObject>::eventFilter(pWatched, pEvent);
-}
-
-void UIMachineLogic::sltCheckRequestedModes()
-{
-    /* Do not try to enter extended mode if machine was not started yet: */
-    if (!uisession()->isRunning() && !uisession()->isPaused())
-        return;
-
-    /* If seamless mode is requested, supported and we are NOT currently in seamless mode: */
-    if (uisession()->isSeamlessModeRequested() &&
-        uisession()->isGuestSupportsSeamless() &&
-        visualStateType() != UIVisualStateType_Seamless)
-    {
-        uisession()->setSeamlessModeRequested(false);
-        QAction *pSeamlessModeAction = gActionPool->action(UIActionIndexRuntime_Toggle_Seamless);
-        AssertMsg(!pSeamlessModeAction->isChecked(), ("Seamless action should not be triggered before us!\n"));
-        QTimer::singleShot(0, pSeamlessModeAction, SLOT(trigger()));
-    }
-    /* If seamless mode is NOT requested, NOT supported and we are currently in seamless mode: */
-    else if (!uisession()->isSeamlessModeRequested() &&
-             !uisession()->isGuestSupportsSeamless() &&
-             visualStateType() == UIVisualStateType_Seamless)
-    {
-        uisession()->setSeamlessModeRequested(true);
-        QAction *pSeamlessModeAction = gActionPool->action(UIActionIndexRuntime_Toggle_Seamless);
-        AssertMsg(pSeamlessModeAction->isChecked(), ("Seamless action should not be triggered before us!\n"));
-        QTimer::singleShot(0, pSeamlessModeAction, SLOT(trigger()));
-    }
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineLogic.h

@@ -100 +100 @@
 protected slots:
 
+    /** Checks if some visual-state type was requested. */
+    virtual void sltCheckForRequestedVisualStateType() {}
+
     /* Console callback handlers: */
     virtual void sltMachineStateChanged();
@@ -172 +175 @@
 
 private slots:
-
-    /* Mode request watch dog: */
-    void sltCheckRequestedModes();
 
     /* "Machine" menu functionality: */

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

@@ -124 +124 @@
     , m_machineStatePrevious(KMachineState_Null)
     , m_machineState(session().GetMachine().GetState())
+    , m_requestedVisualStateType(UIVisualStateType_Invalid)
 #ifdef Q_WS_WIN
     , m_alphaCursor(0)
@@ -138 +139 @@
     , m_fIsIgnoreRuntimeMediumsChanging(false)
     , m_fIsGuestResizeIgnored(false)
-    , m_fIsSeamlessModeRequested(false)
     , m_fIsAutoCaptureDisabled(false)
     , m_fReconfigurable(false)
@@ -651 +651 @@
 {
     /* Reset requests: */
-    setSeamlessModeRequested(false);
+    setRequestedVisualState(UIVisualStateType_Invalid);
     /* Request change: */
     m_pMachine->asyncChangeVisualState(UIVisualStateType_Normal);
@@ -659 +659 @@
 {
     /* Reset requests: */
-    setSeamlessModeRequested(false);
+    setRequestedVisualState(UIVisualStateType_Invalid);
     /* Request change: */
     m_pMachine->asyncChangeVisualState(UIVisualStateType_Fullscreen);
@@ -667 +667 @@
 {
     /* Reset requests: */
-    setSeamlessModeRequested(false);
+    setRequestedVisualState(UIVisualStateType_Invalid);
     /* Request change: */
     m_pMachine->asyncChangeVisualState(UIVisualStateType_Seamless);
@@ -675 +675 @@
 {
     /* Reset requests: */
-    setSeamlessModeRequested(false);
+    setRequestedVisualState(UIVisualStateType_Invalid);
     /* Request change: */
     m_pMachine->asyncChangeVisualState(UIVisualStateType_Scale);

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UISession.h

@@ -125 +125 @@
     /** Requests visual-state change. */
     void changeVisualState(UIVisualStateType visualStateType);
+    /** Requests visual-state to be entered when possible. */
+    void setRequestedVisualState(UIVisualStateType visualStateType) { m_requestedVisualStateType = visualStateType; }
+    /** Returns requested visual-state to be entered when possible. */
+    UIVisualStateType requestedVisualState() const { return m_requestedVisualStateType; }
 
     bool isSaved() const { return machineState() == KMachineState_Saved; }
@@ -142 +146 @@
     bool isIgnoreRuntimeMediumsChanging() const { return m_fIsIgnoreRuntimeMediumsChanging; }
     bool isGuestResizeIgnored() const { return m_fIsGuestResizeIgnored; }
-    bool isSeamlessModeRequested() const { return m_fIsSeamlessModeRequested; }
     bool isAutoCaptureDisabled() const { return m_fIsAutoCaptureDisabled; }
 
@@ -172 +175 @@
     bool setPause(bool fOn);
     void setGuestResizeIgnored(bool fIsGuestResizeIgnored) { m_fIsGuestResizeIgnored = fIsGuestResizeIgnored; }
-    void setSeamlessModeRequested(bool fIsSeamlessModeRequested) { m_fIsSeamlessModeRequested = fIsSeamlessModeRequested; }
     void setAutoCaptureDisabled(bool fIsAutoCaptureDisabled) { m_fIsAutoCaptureDisabled = fIsAutoCaptureDisabled; }
     void forgetPreviousMachineState() { m_machineStatePrevious = m_machineState; }
@@ -324 +326 @@
     QCursor m_cursor;
 
+    /** @name Visual-state configuration variables.
+     ** @{ */
+    /** Determines which visual-state should be entered when possible. */
+    UIVisualStateType m_requestedVisualStateType;
+    /** @} */
+
 #if defined(Q_WS_WIN)
     HCURSOR m_alphaCursor;
@@ -358 +366 @@
     bool m_fIsIgnoreRuntimeMediumsChanging : 1;
     bool m_fIsGuestResizeIgnored : 1;
-    bool m_fIsSeamlessModeRequested : 1;
     bool m_fIsAutoCaptureDisabled : 1;
     bool m_fReconfigurable : 1;

trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineLogicNormal.cpp

@@ -42 +42 @@
     /* Normal mode is always available: */
     return true;
+}
+
+void UIMachineLogicNormal::sltCheckForRequestedVisualStateType()
+{
+    /* Do not try to change visual-state type if machine was not started yet: */
+    if (!uisession()->isRunning() && !uisession()->isPaused())
+        return;
+
+    /* Check requested visual-state types: */
+    switch (uisession()->requestedVisualState())
+    {
+        /* If 'seamless' visual-state type is requested: */
+        case UIVisualStateType_Seamless:
+        {
+            /* And supported: */
+            if (uisession()->isGuestSupportsSeamless())
+            {
+                LogRel(("UIMachineLogicNormal: Going 'seamless' as requested...\n"));
+                uisession()->setRequestedVisualState(UIVisualStateType_Invalid);
+                uisession()->changeVisualState(UIVisualStateType_Seamless);
+            }
+            break;
+        }
+        default:
+            break;
+    }
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineLogicNormal.h

@@ -36 +36 @@
 private slots:
 
+    /** Checks if some visual-state type was requested. */
+    void sltCheckForRequestedVisualStateType();
+
     /* Windowed mode functionality: */
     void sltPrepareNetworkAdaptersMenu();

trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineLogicSeamless.cpp

@@ -109 +109 @@
 }
 
+void UIMachineLogicSeamless::sltCheckForRequestedVisualStateType()
+{
+    /* Do not try to change visual-state type if machine was not started yet: */
+    if (!uisession()->isRunning() && !uisession()->isPaused())
+        return;
+
+    /* If 'seamless' visual-state type is no more supported: */
+    if (!uisession()->isGuestSupportsSeamless())
+    {
+        LogRel(("UIMachineLogicSeamless: Leaving 'seamless' as it is no more supported...\n"));
+        uisession()->setRequestedVisualState(UIVisualStateType_Seamless);
+        uisession()->changeVisualState(UIVisualStateType_Normal);
+    }
+}
+
 void UIMachineLogicSeamless::sltMachineStateChanged()
 {
@@ -245 +260 @@
 void UIMachineLogicSeamless::cleanupActionConnections()
 {
-    /* "View" actions connections: */
+    /* "View" actions disconnections: */
     disconnect(gActionPool->action(UIActionIndexRuntime_Toggle_Seamless), SIGNAL(triggered(bool)),
                uisession(), SLOT(sltChangeVisualStateToNormal()));

trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineLogicSeamless.h

@@ -48 +48 @@
 private slots:
 
+    /** Checks if some visual-state type was requested. */
+    void sltCheckForRequestedVisualStateType();
+
     /* Handler: Console callback stuff: */
     void sltMachineStateChanged();