Changeset 98518 in vbox for trunk/src/VBox/Frontends/VirtualBox

Timestamp:

Feb 9, 2023 1:21:53 PM (2 years ago)

Author:

vboxsync

Message:

FE/Qt: bugref:10322: Runtime UI: Heavy cleanup for UIMultiScreenLayout class; Quite dangerous in theory.

Location:

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

Files:

• UIMultiScreenLayout.cpp (modified) (15 diffs)
• UIMultiScreenLayout.h (modified) (2 diffs)

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

@@ -26 +26 @@
  */
 
-/* Qt includes: */
-#include <QApplication>
-#include <QMenu>
-
 /* GUI includes: */
-#include "UIDefs.h"
+#include "UIActionPoolRuntime.h"
+#include "UICommon.h"
+#include "UIDesktopWidgetWatchdog.h"
+#include "UIExtraDataManager.h"
+#include "UIMachine.h"
+#include "UIMachineLogic.h"
+#include "UIMessageCenter.h"
 #include "UIMultiScreenLayout.h"
-#include "UIActionPoolRuntime.h"
-#include "UIMachineLogic.h"
-#include "UIMachine.h"
-#include "UIMessageCenter.h"
-#include "UIExtraDataManager.h"
-#include "UIDesktopWidgetWatchdog.h"
-#include "UICommon.h"
 
 /* COM includes: */
 #include "COMEnums.h"
-#include "CSession.h"
-#include "CConsole.h"
+#include "CDisplay.h"
 #include "CMachine.h"
-#include "CDisplay.h"
 #include "CGraphicsAdapter.h"
 
@@ -53 +46 @@
     : m_pMachineLogic(pMachineLogic)
     , m_cGuestScreens(m_pMachineLogic->machine().GetGraphicsAdapter().GetMonitorCount())
-    , m_cHostScreens(0)
-{
-    /* Calculate host/guest screen count: */
-    calculateHostMonitorCount();
-    calculateGuestScreenCount();
-
-    /* Prpeare connections: */
-    prepareConnections();
+    , m_cHostMonitors(0)
+{
+    prepare();
+}
+
+bool UIMultiScreenLayout::hasHostScreenForGuestScreen(int iScreenId) const
+{
+    return m_screenMap.contains(iScreenId);
+}
+
+int UIMultiScreenLayout::hostScreenForGuestScreen(int iScreenId) const
+{
+    return m_screenMap.value(iScreenId, 0);
+}
+
+quint64 UIMultiScreenLayout::memoryRequirements() const
+{
+    return memoryRequirements(m_screenMap);
 }
 
@@ -72 +75 @@
     /* Make a pool of available host screens: */
     QList<int> availableScreens;
-    for (int i = 0; i < m_cHostScreens; ++i)
+    for (int i = 0; i < m_cHostMonitors; ++i)
         availableScreens << i;
 
     /* Load all combinations stored in the settings file.
      * We have to make sure they are valid, which means there have to be unique combinations
-     * and all guests screens need there own host screen. */
-    bool fShouldWeAutoMountGuestScreens = gEDataManager->autoMountGuestScreensEnabled(uiCommon().managedVMUuid());
+     * and all guests screens need there own host-monitor. */
+    const bool fShouldWeAutoMountGuestScreens = gEDataManager->autoMountGuestScreensEnabled(uiCommon().managedVMUuid());
     LogRel(("GUI: UIMultiScreenLayout::update: GUI/AutomountGuestScreens is %s\n", fShouldWeAutoMountGuestScreens ? "enabled" : "disabled"));
     foreach (int iGuestScreen, m_guestScreens)
@@ -91 +94 @@
             iHostScreen = gEDataManager->hostScreenForPassedGuestScreen(iGuestScreen, uiCommon().managedVMUuid());
             /* Revalidate: */
-            fValid =    iHostScreen >= 0 && iHostScreen < m_cHostScreens /* In the host screen bounds? */
+            fValid =    iHostScreen >= 0 && iHostScreen < m_cHostMonitors /* In the host-monitor bounds? */
                      && m_screenMap.key(iHostScreen, -1) == -1; /* Not taken already? */
         }
@@ -110 +113 @@
                 iHostScreen = UIDesktopWidgetWatchdog::screenNumber(topLeftPosition);
                 /* Revalidate: */
-                fValid =    iHostScreen >= 0 && iHostScreen < m_cHostScreens /* In the host screen bounds? */
+                fValid =    iHostScreen >= 0 && iHostScreen < m_cHostMonitors /* In the host-monitor bounds? */
                          && m_screenMap.key(iHostScreen, -1) == -1; /* Not taken already? */
             }
@@ -118 +121 @@
         {
             /* If still not valid, pick the next one
-             * if there is still available host screen: */
+             * if there is still available host-monitor: */
             if (!availableScreens.isEmpty())
             {
@@ -128 +131 @@
         if (fValid)
         {
-            /* Register host screen for the guest screen: */
+            /* Register host-monitor for the guest-screen: */
             m_screenMap.insert(iGuestScreen, iHostScreen);
             /* Remove it from the list of available host screens: */
@@ -138 +141 @@
             /* Then we have to disable excessive guest-screen: */
             LogRel(("GUI: UIMultiScreenLayout::update: Disabling excessive guest-screen %d\n", iGuestScreen));
-            m_pMachineLogic->uimachine()->setScreenVisibleHostDesires(iGuestScreen, false);
-            m_pMachineLogic->display().SetVideoModeHint(iGuestScreen, false, false, 0, 0, 0, 0, 0, true);
+            uimachine()->setScreenVisibleHostDesires(iGuestScreen, false);
+            machineLogic()->display().SetVideoModeHint(iGuestScreen, false, false, 0, 0, 0, 0, 0, true);
         }
     }
@@ -160 +163 @@
             /* Try to get previous guest-screen arguments: */
             const int iGuestScreen = m_disabledGuestScreens.at(iGuestScreenIndex);
-            const QSize guestScreenSize = m_pMachineLogic->uimachine()->guestScreenSize(iGuestScreen);
+            const QSize guestScreenSize = uimachine()->guestScreenSize(iGuestScreen);
             {
                 if (guestScreenSize.width() > 0)
@@ -170 +173 @@
             LogRel(("GUI: UIMultiScreenLayout::update: Enabling guest-screen %d with following resolution: %dx%d\n",
                     iGuestScreen, uWidth, uHeight));
-            m_pMachineLogic->uimachine()->setScreenVisibleHostDesires(iGuestScreen, true);
-            m_pMachineLogic->display().SetVideoModeHint(iGuestScreen, true, false, 0, 0, uWidth, uHeight, 32, true);
+            uimachine()->setScreenVisibleHostDesires(iGuestScreen, true);
+            machineLogic()->display().SetVideoModeHint(iGuestScreen, true, false, 0, 0, uWidth, uHeight, 32, true);
         }
     }
 
     /* Make sure action-pool knows whether multi-screen layout has host-screen for guest-screen: */
-    m_pMachineLogic->actionPool()->toRuntime()->setHostScreenForGuestScreenMap(m_screenMap);
+    actionPool()->toRuntime()->setHostScreenForGuestScreenMap(m_screenMap);
 
     LogRelFlow(("UIMultiScreenLayout::update: Finished!\n"));
@@ -188 +191 @@
     calculateHostMonitorCount();
     calculateGuestScreenCount();
+
     /* Update layout: */
     update();
@@ -194 +198 @@
 }
 
-int UIMultiScreenLayout::hostScreenCount() const
-{
-    return m_cHostScreens;
-}
-
-int UIMultiScreenLayout::guestScreenCount() const
-{
-    return m_guestScreens.size();
-}
-
-int UIMultiScreenLayout::hostScreenForGuestScreen(int iScreenId) const
-{
-    return m_screenMap.value(iScreenId, 0);
-}
-
-bool UIMultiScreenLayout::hasHostScreenForGuestScreen(int iScreenId) const
-{
-    return m_screenMap.contains(iScreenId);
-}
-
-quint64 UIMultiScreenLayout::memoryRequirements() const
-{
-    return memoryRequirements(m_screenMap);
-}
-
-void UIMultiScreenLayout::sltHandleScreenLayoutChange(int iRequestedGuestScreen, int iRequestedHostScreen)
+void UIMultiScreenLayout::sltHandleScreenLayoutChange(int iRequestedGuestScreen, int iRequestedHostMonitor)
 {
     /* Search for the virtual screen which is currently displayed on the
-     * requested host screen. When there is one found, we swap both. */
+     * requested host-monitor. When there is one found, we swap both. */
     QMap<int,int> tmpMap(m_screenMap);
-    int iCurrentGuestScreen = tmpMap.key(iRequestedHostScreen, -1);
+    const int iCurrentGuestScreen = tmpMap.key(iRequestedHostMonitor, -1);
     if (iCurrentGuestScreen != -1 && tmpMap.contains(iRequestedGuestScreen))
         tmpMap.insert(iCurrentGuestScreen, tmpMap.value(iRequestedGuestScreen));
     else
         tmpMap.remove(iCurrentGuestScreen);
-    tmpMap.insert(iRequestedGuestScreen, iRequestedHostScreen);
+    tmpMap.insert(iRequestedGuestScreen, iRequestedHostMonitor);
 
     /* Check the memory requirements first: */
     bool fSuccess = true;
-    if (m_pMachineLogic->uimachine()->isGuestSupportsGraphics())
-    {
-        quint64 availBits = m_pMachineLogic->machine().GetGraphicsAdapter().GetVRAMSize() * _1M * 8;
-        quint64 usedBits = memoryRequirements(tmpMap);
-        fSuccess = availBits >= usedBits;
+    if (uimachine()->isGuestSupportsGraphics())
+    {
+        quint64 uAvailBits = machineLogic()->machine().GetGraphicsAdapter().GetVRAMSize() * _1M * 8;
+        quint64 uUsedBits = memoryRequirements(tmpMap);
+        fSuccess = uAvailBits >= uUsedBits;
         if (!fSuccess)
         {
             /* We have too little video memory for the new layout, so say it to the user and revert all the changes: */
-            if (m_pMachineLogic->visualStateType() == UIVisualStateType_Seamless)
-                msgCenter().cannotSwitchScreenInSeamless((((usedBits + 7) / 8 + _1M - 1) / _1M) * _1M);
+            if (machineLogic()->visualStateType() == UIVisualStateType_Seamless)
+                msgCenter().cannotSwitchScreenInSeamless((((uUsedBits + 7) / 8 + _1M - 1) / _1M) * _1M);
             else
-                fSuccess = msgCenter().cannotSwitchScreenInFullscreen((((usedBits + 7) / 8 + _1M - 1) / _1M) * _1M);
+                fSuccess = msgCenter().cannotSwitchScreenInFullscreen((((uUsedBits + 7) / 8 + _1M - 1) / _1M) * _1M);
         }
     }
@@ -255 +234 @@
 
     /* Make sure action-pool knows whether multi-screen layout has host-screen for guest-screen: */
-    m_pMachineLogic->actionPool()->toRuntime()->setHostScreenForGuestScreenMap(m_screenMap);
+    actionPool()->toRuntime()->setHostScreenForGuestScreenMap(m_screenMap);
 
     /* Save guest-to-host mapping: */
-    saveScreenMapping();
+    foreach (const int &iGuestScreen, m_guestScreens)
+    {
+        const int iHostScreen = m_screenMap.value(iGuestScreen, -1);
+        gEDataManager->setHostScreenForPassedGuestScreen(iGuestScreen, iHostScreen, uiCommon().managedVMUuid());
+    }
 
     /* Notifies about layout change: */
@@ -264 +247 @@
 }
 
+void UIMultiScreenLayout::prepare()
+{
+    /* Make sure logic is always set: */
+    AssertPtrReturnVoid(machineLogic());
+
+    /* Recalculate host/guest screen count: */
+    calculateHostMonitorCount();
+    calculateGuestScreenCount();
+
+    /* Prepare connections: */
+    prepareConnections();
+}
+
+void UIMultiScreenLayout::prepareConnections()
+{
+    /* Connect action-pool: */
+    connect(actionPool()->toRuntime(), &UIActionPoolRuntime::sigNotifyAboutTriggeringViewScreenRemap,
+            this, &UIMultiScreenLayout::sltHandleScreenLayoutChange);
+}
+
+UIMachine *UIMultiScreenLayout::uimachine() const
+{
+    return machineLogic() ? machineLogic()->uimachine() : 0;
+}
+
+UIActionPool *UIMultiScreenLayout::actionPool() const
+{
+    return machineLogic() ? machineLogic()->actionPool() : 0;
+}
+
 void UIMultiScreenLayout::calculateHostMonitorCount()
 {
-    m_cHostScreens = UIDesktopWidgetWatchdog::screenCount();
+    m_cHostMonitors = UIDesktopWidgetWatchdog::screenCount();
 }
 
 void UIMultiScreenLayout::calculateGuestScreenCount()
 {
-    /* Enumerate all the guest screens: */
     m_guestScreens.clear();
     m_disabledGuestScreens.clear();
     for (uint iGuestScreen = 0; iGuestScreen < m_cGuestScreens; ++iGuestScreen)
-        if (m_pMachineLogic->uimachine()->isScreenVisible(iGuestScreen))
+        if (uimachine()->isScreenVisible(iGuestScreen))
             m_guestScreens << iGuestScreen;
         else
@@ -281 +293 @@
 }
 
-void UIMultiScreenLayout::prepareConnections()
-{
-    /* Connect action-pool: */
-    connect(m_pMachineLogic->actionPool()->toRuntime(), &UIActionPoolRuntime::sigNotifyAboutTriggeringViewScreenRemap,
-            this, &UIMultiScreenLayout::sltHandleScreenLayoutChange);
-}
-
-void UIMultiScreenLayout::saveScreenMapping()
-{
-    foreach (const int &iGuestScreen, m_guestScreens)
-    {
-        const int iHostScreen = m_screenMap.value(iGuestScreen, -1);
-        gEDataManager->setHostScreenForPassedGuestScreen(iGuestScreen, iHostScreen, uiCommon().managedVMUuid());
-    }
-}
-
 quint64 UIMultiScreenLayout::memoryRequirements(const QMap<int, int> &screenLayout) const
 {
-    ULONG width = 0;
-    ULONG height = 0;
-    ULONG guestBpp = 0;
+    ULONG uWidth = 0;
+    ULONG uHeight = 0;
+    ULONG uGuestBpp = 0;
     LONG xOrigin = 0;
     LONG yOrigin = 0;
-    quint64 usedBits = 0;
+    quint64 uUsedBits = 0;
+    KGuestMonitorStatus enmMonitorStatus = KGuestMonitorStatus_Enabled;
+    const UIVisualStateType enmVisualStateType = machineLogic()->visualStateType();
     foreach (int iGuestScreen, m_guestScreens)
     {
-        QRect screen;
-        if (m_pMachineLogic->visualStateType() == UIVisualStateType_Seamless)
-            screen = gpDesktop->availableGeometry(screenLayout.value(iGuestScreen, 0));
-        else
-            screen = gpDesktop->screenGeometry(screenLayout.value(iGuestScreen, 0));
-        KGuestMonitorStatus monitorStatus = KGuestMonitorStatus_Enabled;
-        m_pMachineLogic->display().GetScreenResolution(iGuestScreen, width, height, guestBpp, xOrigin, yOrigin, monitorStatus);
-        usedBits += screen.width() * /* display width */
-                    screen.height() * /* display height */
-                    guestBpp + /* guest bits per pixel */
-                    _1M * 8; /* current cache per screen - may be changed in future */
-    }
-    usedBits += 4096 * 8; /* adapter info */
-    return usedBits;
-}
-
+        /* Make sure corresponding screen is valid: */
+        const QRect screen = enmVisualStateType == UIVisualStateType_Fullscreen
+                           ? gpDesktop->screenGeometry(screenLayout.value(iGuestScreen, 0))
+                           : enmVisualStateType == UIVisualStateType_Seamless
+                           ? gpDesktop->availableGeometry(screenLayout.value(iGuestScreen, 0))
+                           : QRect();
+        AssertReturn(screen.isValid(), 0);
+
+        /* Get some useful screen info: */
+        machineLogic()->display().GetScreenResolution(iGuestScreen, uWidth, uHeight, uGuestBpp,
+                                                      xOrigin, yOrigin, enmMonitorStatus);
+        uUsedBits += screen.width() * /* display width */
+                     screen.height() * /* display height */
+                     uGuestBpp + /* guest bits per pixel */
+                     _1M * 8; /* current cache per screen - may be changed in future */
+    }
+    uUsedBits += 4096 * 8; /* adapter info */
+    return uUsedBits;
+}

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

@@ -33 +33 @@
 
 /* Qt includes: */
+#include <QMap>
 #include <QObject>
-#include <QMap>
 
 /* Forward declarations: */
+class UIActionPool;
+class UIMachine;
 class UIMachineLogic;
-class QMenu;
-class QAction;
 
-/* Multi-screen layout manager: */
+/** QObject subclass containing a part of
+  * machine-logic related to multi-screen layout handling.
+  * Used in such modes as Full-screen and Seamless. */
 class UIMultiScreenLayout : public QObject
 {
@@ -53 +55 @@
 public:
 
-    /* Constructor/destructor: */
+    /** Constructs multi-screen layout passing @a pMachineLogic to the base-class.
+      * @param  pMachineLogic  Brings the parent machine-logic reference. */
     UIMultiScreenLayout(UIMachineLogic *pMachineLogic);
 
-    /* API: Update stuff: */
+    /** Returns whether there is host-monitor suitable for guest-screen with @a iScreenId specified. */
+    bool hasHostScreenForGuestScreen(int iScreenId) const;
+    /** Returns a host-monitor suitable for guest-screen with @a iScreenId specified. */
+    int hostScreenForGuestScreen(int iScreenId) const;
+
+    /** Returns video memory requirements for currently cached multi-screen layout. */
+    quint64 memoryRequirements() const;
+
+    /** Updates multi-screen layout on the basis
+      * of known host/guest screen count. */
     void update();
+    /** Updates everything.
+      * Recalculates host/guest screen count
+      * and calls for update wrapper above. */
     void rebuild();
-
-    /* API: Getters: */
-    int hostScreenCount() const;
-    int guestScreenCount() const;
-    int hostScreenForGuestScreen(int iScreenId) const;
-    bool hasHostScreenForGuestScreen(int iScreenId) const;
-    quint64 memoryRequirements() const;
 
 private slots:
 
-    /* Handler: Screen change stuff: */
-    void sltHandleScreenLayoutChange(int iRequestedGuestScreen, int iRequestedHostScreen);
+    /** Handles screen layout change request.
+      * @param  iRequestedGuestScreen  Brings the index of guest-screen which needs to be mapped to certain host-monitor.
+      * @param  iRequestedHostMonitor  Brings the index of host-monitor which needs to be mapped to certain guest-screen.*/
+    void sltHandleScreenLayoutChange(int iRequestedGuestScreen, int iRequestedHostMonitor);
 
 private:
 
-    /* Helpers: Prepare stuff: */
-    void calculateHostMonitorCount();
-    void calculateGuestScreenCount();
+    /** Prepares everything. */
+    void prepare();
+    /** Prepares connections. */
     void prepareConnections();
 
-    /* Other helpers: */
-    void saveScreenMapping();
+    /** Returns parent machine-logic reference. */
+    UIMachineLogic *machineLogic() const { return m_pMachineLogic; }
+    /** Returns machine UI reference. */
+    UIMachine *uimachine() const;
+    /** Returns action-pool reference. */
+    UIActionPool *actionPool() const;
+
+    /** Recalculates host-monitor count. */
+    void calculateHostMonitorCount();
+    /** Recalculates guest-screen count. */
+    void calculateGuestScreenCount();
+
+    /** Calculates memory requirements for passed @a screenLayout. */
     quint64 memoryRequirements(const QMap<int, int> &screenLayout) const;
 
-    /* Variables: */
+    /** Holds the machine-logic reference. */
     UIMachineLogic *m_pMachineLogic;
-    QList<int> m_guestScreens;
-    QList<int> m_disabledGuestScreens;
-    const uint m_cGuestScreens;
-    int m_cHostScreens;
+
+    /** Holds the number of guest-screens. */
+    const uint  m_cGuestScreens;
+    /** Holds the number of host-monitors. */
+    int         m_cHostMonitors;
+
+    /** Holds currently cached enabled guest-screens. */
+    QList<int>  m_guestScreens;
+    /** Holds currently cached disabled guest-screens. */
+    QList<int>  m_disabledGuestScreens;
+
+    /** Holds the cached screens map.
+      * The keys used for guest-screens.
+      * The values used for host-monitors. */
     QMap<int, int> m_screenMap;
-    QList<QMenu*> m_screenMenuList;
 };