Changeset 37779 in vbox

Timestamp:

Jul 5, 2011 12:13:15 PM (13 years ago)

Author:

vboxsync

Message:

Main/VirtualBox: add two attributes for querying the list of internal networks and generic network drivers
Frontend/VirtualBox: use new methods to decrease time needed before the settings dialog opens

Location:

trunk/src/VBox

Files:

• Frontends/VirtualBox/src/settings/machine/UIMachineSettingsNetwork.cpp (modified) (2 diffs)
• Main/idl/VirtualBox.xidl (modified) (2 diffs)
• Main/include/MachineImpl.h (modified) (2 diffs)
• Main/include/VirtualBoxImpl.h (modified) (1 diff)
• Main/src-server/VirtualBoxImpl.cpp (modified) (1 diff)

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

@@ -1066 +1066 @@
 {
     /* Load total internal network list of all VMs: */
-    QStringList otherInternalNetworks;
     CVirtualBox vbox = vboxGlobal().virtualBox();
-    ulong uCount = qMin((ULONG) 4, vbox.GetSystemProperties().GetMaxNetworkAdapters(KChipsetType_PIIX3));
-    const CMachineVector &machines = vbox.GetMachines();
-    for (int i = 0; i < machines.size(); ++i)
-    {
-        const CMachine &machine = machines[i];
-        if (machine.GetAccessible())
-        {
-            for (ulong uSlot = 0; uSlot < uCount; ++uSlot)
-            {
-                QString strName = machine.GetNetworkAdapter(uSlot).GetInternalNetwork();
-                if (!strName.isEmpty() && !otherInternalNetworks.contains(strName))
-                    otherInternalNetworks << strName;
-            }
-        }
-    }
+    QStringList otherInternalNetworks(QList<QString>::fromVector(vbox.GetInternalNetworks()));
     return otherInternalNetworks;
 }
@@ -1090 +1075 @@
 {
     /* Load total generic driver list of all VMs: */
-    QStringList otherGenericDrivers;
     CVirtualBox vbox = vboxGlobal().virtualBox();
-    ulong uCount = qMin((ULONG) 4, vbox.GetSystemProperties().GetMaxNetworkAdapters(KChipsetType_PIIX3));
-    const CMachineVector &machines = vbox.GetMachines();
-    for (int i = 0; i < machines.size(); ++i)
-    {
-        const CMachine &machine = machines[i];
-        if (machine.GetAccessible())
-        {
-            for (ulong uSlot = 0; uSlot < uCount; ++uSlot)
-            {
-                QString strName = machine.GetNetworkAdapter(uSlot).GetGenericDriver();
-                if (!strName.isEmpty() && !otherGenericDrivers.contains(strName))
-                    otherGenericDrivers << strName;
-            }
-        }
-    }
+    QStringList otherGenericDrivers(QList<QString>::fromVector(vbox.GetGenericNetworkDrivers()));
     return otherGenericDrivers;
 }

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

@@ -1392 +1392 @@
   <interface
     name="IVirtualBox" extends="$unknown"
-    uuid="d627bf11-2758-46be-9a4d-7d9ef794c247"
+    uuid="c28be65f-1a8f-43b4-81f1-eb60cb516e66"
     wsmap="managed"
     >
@@ -1550 +1550 @@
     </attribute>
 
+
+    <attribute name="internalNetworks" type="wstring" safearray="yes" readonly="yes">
+      <desc>
+        Names of all internal networks.
+      </desc>
+    </attribute>
+
+    <attribute name="genericNetworkDrivers" type="wstring" safearray="yes" readonly="yes">
+      <desc>
+        Names of all generic network drivers.
+      </desc>
+    </attribute>
 
     <method name="composeMachineFilename">

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

@@ -574 +574 @@
 
     /**
+     * Checks if this machine is accessible, without attempting to load the
+     * config file.
+     *
+     * @note This method doesn't check this object's readiness. Intended to be
+     * used by ready Machine children (whose readiness is bound to the parent's
+     * one) or after doing addCaller() manually.
+     */
+    bool isAccessible() const { return mData->mAccessible; }
+
+    /**
      * Returns this machine ID.
      *
@@ -625 +635 @@
         IsModified_BandwidthControl     = 0x1000
     };
+
+    /**
+     * Checks if this machine is accessible, without attempting to load the
+     * config file.
+     *
+     * @note This method doesn't check this object's readiness. Intended to be
+     * used by ready Machine children (whose readiness is bound to the parent's
+     * one) or after doing addCaller() manually.
+     */
+    ChipsetType_T getChipsetType() const { return mHWData->mChipsetType; }
 
     void setModified(uint32_t fl);

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

@@ -120 +120 @@
     STDMETHOD(COMGETTER(EventSource))           (IEventSource ** aEventSource);
     STDMETHOD(COMGETTER(ExtensionPackManager))  (IExtPackManager **aExtPackManager);
+    STDMETHOD(COMGETTER(InternalNetworks))      (ComSafeArrayOut(BSTR, aInternalNetworks));
+    STDMETHOD(COMGETTER(GenericNetworkDrivers)) (ComSafeArrayOut(BSTR, aGenericNetworkDrivers));
 
     /* IVirtualBox methods */

trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

@@ -1123 +1123 @@
 
     return hrc;
+}
+
+STDMETHODIMP VirtualBox::COMGETTER(InternalNetworks)(ComSafeArrayOut(BSTR, aInternalNetworks))
+{
+    if (ComSafeArrayOutIsNull(aInternalNetworks))
+        return E_POINTER;
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    std::list<Bstr> allInternalNetworks;
+
+    /* get copy of all machine references, to avoid holding the list lock */
+    MachinesOList::MyList allMachines;
+    {
+        AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+        allMachines = m->allMachines.getList();
+    }
+    for (MachinesOList::MyList::const_iterator it = allMachines.begin();
+         it != allMachines.end();
+         ++it)
+    {
+        const ComObjPtr<Machine> &pMachine = *it;
+        AutoCaller autoMachineCaller(pMachine);
+        if (FAILED(autoMachineCaller.rc()))
+            continue;
+        AutoReadLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
+
+        if (pMachine->isAccessible())
+        {
+            ULONG cNetworkAdapters = 0;
+            HRESULT rc = m->pSystemProperties->GetMaxNetworkAdapters(pMachine->getChipsetType(), &cNetworkAdapters);
+            if (FAILED(rc))
+                continue;
+            cNetworkAdapters = RT_MIN(4, cNetworkAdapters);
+            for (ULONG i = 0; i < cNetworkAdapters; i++)
+            {
+                ComPtr<INetworkAdapter> pNet;
+                rc = pMachine->GetNetworkAdapter(i, pNet.asOutParam());
+                if (FAILED(rc) || pNet.isNull())
+                    continue;
+                Bstr strInternalNetwork;
+                rc = pNet->COMGETTER(InternalNetwork)(strInternalNetwork.asOutParam());
+                if (FAILED(rc) || strInternalNetwork.isEmpty())
+                    continue;
+
+                allInternalNetworks.push_back(strInternalNetwork);
+            }
+        }
+    }
+
+    /* throw out any duplicates */
+    allInternalNetworks.sort();
+    allInternalNetworks.unique();
+    com::SafeArray<BSTR> internalNetworks(allInternalNetworks.size());
+    size_t i = 0;
+    for (std::list<Bstr>::const_iterator it = allInternalNetworks.begin();
+         it != allInternalNetworks.end();
+         ++it, i++)
+    {
+        const Bstr &tmp = *it;
+        tmp.cloneTo(&internalNetworks[i]);
+    }
+    internalNetworks.detachTo(ComSafeArrayOutArg(aInternalNetworks));
+
+    return S_OK;
+}
+
+STDMETHODIMP VirtualBox::COMGETTER(GenericNetworkDrivers)(ComSafeArrayOut(BSTR, aGenericNetworkDrivers))
+{
+    if (ComSafeArrayOutIsNull(aGenericNetworkDrivers))
+        return E_POINTER;
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    std::list<Bstr> allGenericNetworkDrivers;
+
+    /* get copy of all machine references, to avoid holding the list lock */
+    MachinesOList::MyList allMachines;
+    {
+        AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+        allMachines = m->allMachines.getList();
+    }
+    for (MachinesOList::MyList::const_iterator it = allMachines.begin();
+         it != allMachines.end();
+         ++it)
+    {
+        const ComObjPtr<Machine> &pMachine = *it;
+        AutoCaller autoMachineCaller(pMachine);
+        if (FAILED(autoMachineCaller.rc()))
+            continue;
+        AutoReadLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
+
+        if (pMachine->isAccessible())
+        {
+            ULONG cNetworkAdapters = 0;
+            HRESULT rc = m->pSystemProperties->GetMaxNetworkAdapters(pMachine->getChipsetType(), &cNetworkAdapters);
+            if (FAILED(rc))
+                continue;
+            cNetworkAdapters = RT_MIN(4, cNetworkAdapters);
+            for (ULONG i = 0; i < cNetworkAdapters; i++)
+            {
+                ComPtr<INetworkAdapter> pNet;
+                rc = pMachine->GetNetworkAdapter(i, pNet.asOutParam());
+                if (FAILED(rc) || pNet.isNull())
+                    continue;
+                Bstr strGenericNetworkDriver;
+                rc = pNet->COMGETTER(GenericDriver)(strGenericNetworkDriver.asOutParam());
+                if (FAILED(rc) || strGenericNetworkDriver.isEmpty())
+                    continue;
+
+                allGenericNetworkDrivers.push_back(strGenericNetworkDriver);
+            }
+        }
+    }
+
+    /* throw out any duplicates */
+    allGenericNetworkDrivers.sort();
+    allGenericNetworkDrivers.unique();
+    com::SafeArray<BSTR> genericNetworks(allGenericNetworkDrivers.size());
+    size_t i = 0;
+    for (std::list<Bstr>::const_iterator it = allGenericNetworkDrivers.begin();
+         it != allGenericNetworkDrivers.end();
+         ++it, i++)
+    {
+        const Bstr &tmp = *it;
+        tmp.cloneTo(&genericNetworks[i]);
+    }
+    genericNetworks.detachTo(ComSafeArrayOutArg(aGenericNetworkDrivers));
+
+    return S_OK;
 }