Changeset 26950 in vbox for trunk/src/VBox/Frontends

Timestamp:

Mar 2, 2010 3:08:43 PM (15 years ago)

Author:

vboxsync

Message:

FE/Qt4: new core: Make it possible to prevent a mode switch in case the new mode isn't available.

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• globals/VBoxProblemReporter.cpp (modified) (1 diff)
• globals/VBoxProblemReporter.h (modified) (1 diff)
• runtime/UIMachine.cpp (modified) (11 diffs)
• runtime/UIMachineLogic.h (modified) (1 diff)
• runtime/fullscreen/UIMachineLogicFullscreen.cpp (modified) (2 diffs)
• runtime/fullscreen/UIMachineLogicFullscreen.h (modified) (1 diff)
• runtime/normal/UIMachineLogicNormal.cpp (modified) (2 diffs)
• runtime/normal/UIMachineLogicNormal.h (modified) (1 diff)

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxProblemReporter.cpp

@@ -1015 +1015 @@
 }
 
+int VBoxProblemReporter::cannotEnterFullscreenMode()
+{
+    return message(mainMachineWindowShown(), Error,
+             tr ("<p>Can not switch the guest display to fullscreen mode. You "
+                 "have more virtual screens configured than physical screens are "
+                 "attached to your host.</p><p>Please either lower the virtual "
+                 "screens in your VM configuration or attach additional screens "
+                 "to your host.</p>"),
+             0, /* aAutoConfirmId */
+             QIMessageBox::Ok | QIMessageBox::Default);
+}
+
 bool VBoxProblemReporter::confirmMachineDeletion (const CMachine &machine)
 {

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxProblemReporter.h

@@ -227 +227 @@
                                    ULONG aBpp, ULONG64 aMinVRAM);
 
+    int cannotEnterFullscreenMode();
+
     bool confirmMachineDeletion (const CMachine &machine);
     bool confirmDiscardSavedState (const CMachine &machine);

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

@@ -37 +37 @@
 
     /* Visual state holder constructor: */
-    UIVisualState(QObject *pParent) : QObject(pParent), m_pMachineLogic(0)
+    UIVisualState(QObject *pParent, UISession *pSession, UIActionsPool *pActionsPool)
+        : QObject(pParent)
+        , m_pSession(pSession)
+        , m_pActionsPool(pActionsPool)
+        , m_pMachineLogic(0)
     {
         /* Connect state-change handler: */
@@ -45 +49 @@
     /* Public getters: */
     UIMachineLogic* machineLogic() const  { return m_pMachineLogic; }
-
+    virtual UIVisualStateType visualStateType() const = 0;
+
+    virtual bool prepareChange()
+    {
+        m_pMachineLogic = UIMachineLogic::create(this, m_pSession, m_pActionsPool, visualStateType());
+        return m_pMachineLogic->checkAvailability();
+    }
+
+    virtual void change() = 0;
+    virtual void finishChange() {}
 signals:
 
@@ -54 +67 @@
 
     /* Protected members: */
+    UISession *m_pSession;
+    UIActionsPool *m_pActionsPool;
     UIMachineLogic *m_pMachineLogic;
 };
@@ -65 +80 @@
     /* Normal visual state holder constructor: */
     UIVisualStateNormal(QObject *pParent, UISession *pSession, UIActionsPool *pActionsPool)
-        : UIVisualState(pParent)
+        : UIVisualState(pParent, pSession, pActionsPool)
+    {}
+
+    UIVisualStateType visualStateType() const { return UIVisualStateType_Normal; }
+
+    void change()
     {
         /* Connect action handlers: */
-        connect(pActionsPool->action(UIActionIndex_Toggle_Fullscreen), SIGNAL(triggered(bool)),
+        connect(m_pActionsPool->action(UIActionIndex_Toggle_Fullscreen), SIGNAL(triggered(bool)),
                 this, SLOT(sltGoToFullscreenMode()));
-        connect(pActionsPool->action(UIActionIndex_Toggle_Seamless), SIGNAL(triggered(bool)),
+        connect(m_pActionsPool->action(UIActionIndex_Toggle_Seamless), SIGNAL(triggered(bool)),
                 this, SLOT(sltGoToSeamlessMode()));
 
-        /* Create state logic: */
-        m_pMachineLogic = UIMachineLogic::create(this, pSession, pActionsPool, UIVisualStateType_Normal);
+        /* Initialize the logic object */
+        m_pMachineLogic->initialize();
     }
 
@@ -100 +120 @@
     /* Fullscreen visual state holder constructor: */
     UIVisualStateFullscreen(QObject *pParent, UISession *pSession, UIActionsPool *pActionsPool)
-        : UIVisualState(pParent)
+        : UIVisualState(pParent, pSession, pActionsPool)
+    {}
+
+    UIVisualStateType visualStateType() const { return UIVisualStateType_Fullscreen; }
+
+    void change()
     {
         /* Connect action handlers: */
-        connect(pActionsPool->action(UIActionIndex_Toggle_Fullscreen), SIGNAL(triggered(bool)),
+        connect(m_pActionsPool->action(UIActionIndex_Toggle_Fullscreen), SIGNAL(triggered(bool)),
                 this, SLOT(sltGoToNormalMode()));
-        connect(pActionsPool->action(UIActionIndex_Toggle_Seamless), SIGNAL(triggered(bool)),
+        connect(m_pActionsPool->action(UIActionIndex_Toggle_Seamless), SIGNAL(triggered(bool)),
                 this, SLOT(sltGoToSeamlessMode()));
 
-        /* Create state logic: */
-        m_pMachineLogic = UIMachineLogic::create(this, pSession, pActionsPool, UIVisualStateType_Fullscreen);
+        /* Initialize the logic object */
+        m_pMachineLogic->initialize();
     }
 
@@ -135 +160 @@
     /* Seamless visual state holder constructor: */
     UIVisualStateSeamless(QObject *pParent, UISession *pSession, UIActionsPool *pActionsPool)
-        : UIVisualState(pParent)
+        : UIVisualState(pParent, pSession, pActionsPool)
+    {}
+
+    UIVisualStateType visualStateType() const { return UIVisualStateType_Seamless; }
+
+    void change()
     {
         /* Connect action handlers */
-        connect(pActionsPool->action(UIActionIndex_Toggle_Fullscreen), SIGNAL(triggered(bool)),
+        connect(m_pActionsPool->action(UIActionIndex_Toggle_Fullscreen), SIGNAL(triggered(bool)),
                 this, SLOT(sltGoToFullscreenMode()));
-        connect(pActionsPool->action(UIActionIndex_Toggle_Seamless), SIGNAL(triggered(bool)),
+        connect(m_pActionsPool->action(UIActionIndex_Toggle_Seamless), SIGNAL(triggered(bool)),
                 this, SLOT(sltGoToNormalMode()));
 
-        /* Create state logic */
-        m_pMachineLogic = UIMachineLogic::create(this, pSession, pActionsPool, UIVisualStateType_Seamless);
+        /* Initialize the logic object */
+        m_pMachineLogic->initialize();
     }
 
@@ -225 +255 @@
 void UIMachine::sltChangeVisualState(UIVisualStateType visualStateType)
 {
-    /* Delete previous state: */
-    delete m_pVisualState;
-    m_pVisualState = 0;
-
+    UIVisualState *pNewVisualState = 0;
     /* Create new state: */
     switch (visualStateType)
@@ -235 +262 @@
         {
             /* Create normal visual state: */
-            m_pVisualState = new UIVisualStateNormal(this, m_pSession, m_pActionsPool);
+            pNewVisualState = new UIVisualStateNormal(this, m_pSession, m_pActionsPool);
             break;
         }
@@ -241 +268 @@
         {
             /* Create fullscreen visual state: */
-            m_pVisualState = new UIVisualStateFullscreen(this, m_pSession, m_pActionsPool);
+            pNewVisualState = new UIVisualStateFullscreen(this, m_pSession, m_pActionsPool);
             break;
         }
@@ -247 +274 @@
         {
             /* Create seamless visual state: */
-            m_pVisualState = new UIVisualStateSeamless(this, m_pSession, m_pActionsPool);
+            pNewVisualState = new UIVisualStateSeamless(this, m_pSession, m_pActionsPool);
             break;
         }
@@ -253 +280 @@
             break;
     }
+
+    /* First we have to check if the selected mode is available at all. Only
+     * then we delete the old mode and switch to the new mode. */
+    if (pNewVisualState->prepareChange())
+    {
+        /* Delete previous state: */
+        delete m_pVisualState;
+
+        /* Set the new mode as current mode. */
+        m_pVisualState = pNewVisualState;
+        m_pVisualState->change();
+        /* Finish any setup. */
+        m_pVisualState->finishChange();
+    }
+    else
+        /* Discard the temporary create new state */
+        delete pNewVisualState;
 }
 

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

@@ -58 +58 @@
                                   UIVisualStateType visualStateType);
 
+    /* Check if this mode is available */
+    virtual bool checkAvailability() { return true; }
+
+    /* Do the real initialization of the object */
+    virtual void initialize() {}
+
     /* Main getters/setters: */
     UISession* uisession() { return m_pSession; }

trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineLogicFullscreen.cpp

@@ -48 +48 @@
     : UIMachineLogic(pParent, pSession, pActionsPool, UIVisualStateType_Fullscreen)
 {
-    /* Prepare console connections: */
-    prepareConsoleConnections();
-
-    /* Prepare action groups: */
-    prepareActionGroups();
-
-    /* Prepare action connections: */
-    prepareActionConnections();
-
+}
+
+UIMachineLogicFullscreen::~UIMachineLogicFullscreen()
+{
+    /* Cleanup machine window: */
+    cleanupMachineWindow();
+}
+
+bool UIMachineLogicFullscreen::checkAvailability()
+{
+    int cHostScreens = QApplication::desktop()->screenCount();
+    int cGuestScreens = uisession()->session().GetMachine().GetMonitorCount();
+    /* Check that there are enough physical screens are connected */
+    if (cHostScreens < cGuestScreens)
+    {
+        vboxProblem().cannotEnterFullscreenMode();
+        setPreventAutoStart(true);
+        return false;
+    }
+
+    return true;
+}
+
+void UIMachineLogicFullscreen::initialize()
+{
     /* Check the status of required features: */
     prepareRequiredFeatures();
 
-    /* Prepare machine window: */
-    prepareMachineWindows();
-
-    /* Initialization: */
-    sltMachineStateChanged();
-    sltAdditionsStateChanged();
-    sltMouseCapabilityChanged();
-}
-
-UIMachineLogicFullscreen::~UIMachineLogicFullscreen()
-{
-    /* Cleanup machine window: */
-    cleanupMachineWindow();
+    /* If required features are ready: */
+    if (!isPreventAutoStart())
+    {
+        /* Prepare console connections: */
+        prepareConsoleConnections();
+
+        /* Prepare action groups: */
+        prepareActionGroups();
+
+        /* Prepare action connections: */
+        prepareActionConnections();
+
+        /* Prepare machine window: */
+        prepareMachineWindows();
+
+        /* Initialization: */
+        sltMachineStateChanged();
+        sltAdditionsStateChanged();
+        sltMouseCapabilityChanged();
+    }
 }
 
@@ -117 +140 @@
     // TODO_NEW_CORE
 //    if (session().GetConsole().isAutoresizeGuestActive())
-    {
-//        QRect screen = QApplication::desktop()->screenGeometry(this);
-//        ULONG64 availBits = session().GetMachine().GetVRAMSize() /* vram */
-//                          * _1M /* mb to bytes */
-//                          * 8; /* to bits */
-//        ULONG guestBpp = mConsole->console().GetDisplay().GetBitsPerPixel();
-//        ULONG64 usedBits = (screen.width() /* display width */
-//                         * screen.height() /* display height */
-//                         * guestBpp
-//                         + _1M * 8) /* current cache per screen - may be changed in future */
-//                         * session().GetMachine().GetMonitorCount() /**< @todo fix assumption that all screens have same resolution */
-//                         + 4096 * 8; /* adapter info */
+//    {
+//        ULONG64 availBits = session().GetMachine().GetVRAMSize() /* VRAM */
+//            * _1M /* MB to bytes */
+//            * 8; /* to bits */
+//        for (ulong uScreenId = 0; uScreenId < uMonitorCount; ++ uScreenId)
+//        {
+//            QRect screen = QApplication::desktop()->screenGeometry(this);
+//            ULONG guestBpp = mConsole->console().GetDisplay().GetBitsPerPixel();
+//            ULONG64 usedBits = (screen.width() /* display width */
+//                                * screen.height() /* display height */
+//                                * guestBpp
+//                                + _1M * 8) /* current cache per screen - may be changed in future */
+//                * session().GetMachine().GetMonitorCount() /**< @todo fix assumption that all screens have same resolution */
+//                + 4096 * 8; /* adapter info */
+//        }
+//
 //        if (availBits < usedBits)
 //        {
 //            int result = vboxProblem().cannotEnterFullscreenMode(
-//                   screen.width(), screen.height(), guestBpp,
-//                   (((usedBits + 7) / 8 + _1M - 1) / _1M) * _1M);
+//                                                                 screen.width(), screen.height(), guestBpp,
+//                                                                 (((usedBits + 7) / 8 + _1M - 1) / _1M) * _1M);
 //            if (result == QIMessageBox::Cancel)
 //                sltClose();
 //        }
-    }
+//    }
+//
+    UIMachineLogic::prepareRequiredFeatures();
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineLogicFullscreen.h

@@ -42 +42 @@
     virtual ~UIMachineLogicFullscreen();
 
+    bool checkAvailability();
+    void initialize();
+
 private slots:
 

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

@@ -41 +41 @@
     : UIMachineLogic(pParent, pSession, pActionsPool, UIVisualStateType_Normal)
 {
+}
+
+UIMachineLogicNormal::~UIMachineLogicNormal()
+{
+    /* Cleanup normal machine window: */
+    cleanupMachineWindow();
+}
+
+void UIMachineLogicNormal::initialize()
+{
     /* Check the status of required features: */
     prepareRequiredFeatures();
@@ -64 +74 @@
         sltMouseCapabilityChanged();
     }
-}
-
-UIMachineLogicNormal::~UIMachineLogicNormal()
-{
-    /* Cleanup normal machine window: */
-    cleanupMachineWindow();
 }
 

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

@@ -42 +42 @@
     virtual ~UIMachineLogicNormal();
 
+    void initialize();
+
 private slots: