Changeset 78531 in vbox for trunk/src/VBox

Timestamp:

May 15, 2019 1:13:12 PM (6 years ago)

Author:

vboxsync

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

130575

Message:

FE/Qt: bugref:6247: VM Settings / Storage page: Extend AbstractControllerType with possibility to redefine bus type; recache it's content in that case.

Location:

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine

Files:

• UIMachineSettingsStorage.cpp (modified) (1 diff)
• UIMachineSettingsStorage.h (modified) (3 diffs)

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.cpp

@@ -386 +386 @@
     AssertMsg (mCtrType != KStorageControllerType_Null, ("Wrong Controller Type {%d}!\n", mCtrType));
 
-    for (int i = 0; i < State_MAX; ++ i)
-    {
-        mPixmaps << InvalidPixmap;
+    updateBusInfo();
+    updateTypeInfo();
+    updatePixmaps();
+}
+
+KStorageBus AbstractControllerType::busType() const
+{
+    return mBusType;
+}
+
+ControllerBusList AbstractControllerType::busTypes() const
+{
+    return m_buses;
+}
+
+KStorageControllerType AbstractControllerType::ctrType() const
+{
+    return mCtrType;
+}
+
+ControllerTypeList AbstractControllerType::ctrTypes() const
+{
+    return m_types;
+}
+
+PixmapType AbstractControllerType::pixmap(ItemState aState) const
+{
+    return m_pixmaps.at(aState);
+}
+
+void AbstractControllerType::setCtrBusType(KStorageBus enmCtrBusType)
+{
+    mBusType = enmCtrBusType;
+
+    updateBusInfo();
+    updateTypeInfo();
+    updatePixmaps();
+}
+
+void AbstractControllerType::setCtrType (KStorageControllerType aCtrType)
+{
+    mCtrType = aCtrType;
+}
+
+DeviceTypeList AbstractControllerType::deviceTypeList() const
+{
+    return vboxGlobal().virtualBox().GetSystemProperties().GetDeviceTypesForStorageBus (mBusType).toList();
+}
+
+void AbstractControllerType::updateBusInfo()
+{
+    m_buses.clear();
+
+    switch (mBusType)
+    {
+        case KStorageBus_IDE:
+        case KStorageBus_SATA:
+        case KStorageBus_SCSI:
+        case KStorageBus_SAS:
+        case KStorageBus_USB:
+        case KStorageBus_PCIe:
+        case KStorageBus_VirtioSCSI:
+        {
+            m_buses << KStorageBus_IDE << KStorageBus_SATA << KStorageBus_SCSI << KStorageBus_SAS
+                    << KStorageBus_USB << KStorageBus_PCIe << KStorageBus_VirtioSCSI;
+            m_buses.removeAll(mBusType);
+        }
+        RT_FALL_THRU();
+        default:
+        {
+            m_buses.prepend(mBusType);
+            break;
+        }
+    }
+}
+
+void AbstractControllerType::updateTypeInfo()
+{
+    m_types.clear();
+
+    KStorageControllerType enmFirstType = KStorageControllerType_Null;
+    switch (mBusType)
+    {
+        case KStorageBus_IDE:        enmFirstType = KStorageControllerType_PIIX3; break;
+        case KStorageBus_SATA:       enmFirstType = KStorageControllerType_IntelAhci; break;
+        case KStorageBus_SCSI:       enmFirstType = KStorageControllerType_LsiLogic; break;
+        case KStorageBus_Floppy:     enmFirstType = KStorageControllerType_I82078; break;
+        case KStorageBus_SAS:        enmFirstType = KStorageControllerType_LsiLogicSas; break;
+        case KStorageBus_USB:        enmFirstType = KStorageControllerType_USB; break;
+        case KStorageBus_PCIe:       enmFirstType = KStorageControllerType_NVMe; break;
+        case KStorageBus_VirtioSCSI: enmFirstType = KStorageControllerType_VirtioSCSI; break;
+        default:                     break;
+    }
+    AssertMsg(enmFirstType != KStorageControllerType_Null, ("Invalid item type!\n"));
+
+    uint uTypeAmount = 0;
+    switch (mBusType)
+    {
+        case KStorageBus_IDE:        uTypeAmount = 3; break;
+        case KStorageBus_SATA:       uTypeAmount = 1; break;
+        case KStorageBus_SCSI:       uTypeAmount = 2; break;
+        case KStorageBus_Floppy:     uTypeAmount = 1; break;
+        case KStorageBus_SAS:        uTypeAmount = 1; break;
+        case KStorageBus_USB:        uTypeAmount = 1; break;
+        case KStorageBus_PCIe:       uTypeAmount = 1; break;
+        case KStorageBus_VirtioSCSI: uTypeAmount = 1; break;
+        default:                     break;
+    }
+    AssertMsg(uTypeAmount != 0, ("Invalid item type count!\n"));
+
+    for (uint i = enmFirstType; i < enmFirstType + uTypeAmount; ++i)
+        m_types << static_cast<KStorageControllerType>(i);
+}
+
+void AbstractControllerType::updatePixmaps()
+{
+    m_pixmaps.clear();
+
+    for (int i = 0; i < State_MAX; ++i)
+    {
+        m_pixmaps << InvalidPixmap;
         switch (mBusType)
         {
-            case KStorageBus_IDE:
-                mPixmaps [i] = (PixmapType)(IDEControllerNormal + i);
-                break;
-            case KStorageBus_SATA:
-                mPixmaps [i] = (PixmapType)(SATAControllerNormal + i);
-                break;
-            case KStorageBus_SCSI:
-                mPixmaps [i] = (PixmapType)(SCSIControllerNormal + i);
-                break;
-            case KStorageBus_Floppy:
-                mPixmaps [i] = (PixmapType)(FloppyControllerNormal + i);
-                break;
-            case KStorageBus_SAS:
-                mPixmaps [i] = (PixmapType)(SASControllerNormal + i);
-                break;
-            case KStorageBus_USB:
-                mPixmaps [i] = (PixmapType)(USBControllerNormal + i);
-                break;
-            case KStorageBus_PCIe:
-                mPixmaps [i] = (PixmapType)(NVMeControllerNormal + i);
-                break;
-            case KStorageBus_VirtioSCSI:
-                mPixmaps [i] = (PixmapType)(VirtioSCSIControllerNormal + i);
-                break;
-            default:
-                break;
-        }
-        AssertMsg (mPixmaps [i] != InvalidPixmap, ("Item state pixmap was not set!\n"));
-    }
-}
-
-KStorageBus AbstractControllerType::busType() const
-{
-    return mBusType;
-}
-
-KStorageControllerType AbstractControllerType::ctrType() const
-{
-    return mCtrType;
-}
-
-ControllerTypeList AbstractControllerType::ctrTypes() const
-{
-    ControllerTypeList result;
-    for (uint i = firstType(); i < firstType() + typeAmount(); ++i)
-        result << (KStorageControllerType) i;
-    return result;
-}
-
-PixmapType AbstractControllerType::pixmap(ItemState aState) const
-{
-    return mPixmaps [aState];
-}
-
-void AbstractControllerType::setCtrType (KStorageControllerType aCtrType)
-{
-    mCtrType = aCtrType;
-}
-
-DeviceTypeList AbstractControllerType::deviceTypeList() const
-{
-    return vboxGlobal().virtualBox().GetSystemProperties().GetDeviceTypesForStorageBus (mBusType).toList();
-}
-
-KStorageControllerType AbstractControllerType::firstType() const
-{
-    switch (mBusType)
-    {
-        case KStorageBus_IDE:        return KStorageControllerType_PIIX3;
-        case KStorageBus_SATA:       return KStorageControllerType_IntelAhci;
-        case KStorageBus_SCSI:       return KStorageControllerType_LsiLogic;
-        case KStorageBus_Floppy:     return KStorageControllerType_I82078;
-        case KStorageBus_SAS:        return KStorageControllerType_LsiLogicSas;
-        case KStorageBus_USB:        return KStorageControllerType_USB;
-        case KStorageBus_PCIe:       return KStorageControllerType_NVMe;
-        case KStorageBus_VirtioSCSI: return KStorageControllerType_VirtioSCSI;
-        default:                     AssertFailedReturn(KStorageControllerType_Null);
-    }
-}
-
-uint AbstractControllerType::typeAmount() const
-{
-    switch (mBusType)
-    {
-        case KStorageBus_IDE:        return 3;
-        case KStorageBus_SATA:       return 1;
-        case KStorageBus_SCSI:       return 2;
-        case KStorageBus_Floppy:     return 1;
-        case KStorageBus_SAS:        return 1;
-        case KStorageBus_USB:        return 1;
-        case KStorageBus_PCIe:       return 1;
-        case KStorageBus_VirtioSCSI: return 1;
-        default:                     AssertFailedReturn(0);
+            case KStorageBus_IDE:        m_pixmaps[i] = static_cast<PixmapType>(IDEControllerNormal + i); break;
+            case KStorageBus_SATA:       m_pixmaps[i] = static_cast<PixmapType>(SATAControllerNormal + i); break;
+            case KStorageBus_SCSI:       m_pixmaps[i] = static_cast<PixmapType>(SCSIControllerNormal + i); break;
+            case KStorageBus_Floppy:     m_pixmaps[i] = static_cast<PixmapType>(FloppyControllerNormal + i); break;
+            case KStorageBus_SAS:        m_pixmaps[i] = static_cast<PixmapType>(SASControllerNormal + i); break;
+            case KStorageBus_USB:        m_pixmaps[i] = static_cast<PixmapType>(USBControllerNormal + i); break;
+            case KStorageBus_PCIe:       m_pixmaps[i] = static_cast<PixmapType>(NVMeControllerNormal + i); break;
+            case KStorageBus_VirtioSCSI: m_pixmaps[i] = static_cast<PixmapType>(VirtioSCSIControllerNormal + i); break;
+            default: break;
+        }
+        AssertMsg(m_pixmaps[i] != InvalidPixmap, ("Invalid item state pixmap!\n"));
     }
 }

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.h

@@ -51 +51 @@
 typedef QList <StorageSlot> SlotsList;
 typedef QList <KDeviceType> DeviceTypeList;
+typedef QList <KStorageBus> ControllerBusList;
 typedef QList <KStorageControllerType> ControllerTypeList;
 Q_DECLARE_METATYPE (SlotsList);
 Q_DECLARE_METATYPE (DeviceTypeList);
+Q_DECLARE_METATYPE (ControllerBusList);
 Q_DECLARE_METATYPE (ControllerTypeList);
 
@@ -155 +157 @@
 
     KStorageBus busType() const;
+    ControllerBusList busTypes() const;
     KStorageControllerType ctrType() const;
     ControllerTypeList ctrTypes() const;
     PixmapType pixmap(ItemState aState) const;
 
+    void setCtrBusType(KStorageBus enmCtrBusType);
     void setCtrType (KStorageControllerType aCtrType);
 
@@ -165 +169 @@
 private:
 
-    KStorageControllerType firstType() const;
-    uint typeAmount() const;
+    void updateBusInfo();
+    void updateTypeInfo();
+    void updatePixmaps();
 
     KStorageBus mBusType;
     KStorageControllerType mCtrType;
-    QList<PixmapType> mPixmaps;
+
+    ControllerBusList   m_buses;
+    ControllerTypeList  m_types;
+    QList<PixmapType>   m_pixmaps;
 };