Changeset 94527 in vbox for trunk

Timestamp:

Apr 8, 2022 10:22:37 AM (3 years ago)

Author:

vboxsync

Message:

FE/Qt/Ds: bugref:6899: Machine settings: Network page accessibility improvements (part 1); Moving advanced stuff to separate editor; Plus minimum amount of cleanup involved, more to go.

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• Makefile.kmk (modified) (2 diffs)
• src/settings/editors/UIMachineNetworkFeaturesEditor.cpp (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIMachineDescriptionEditor.cpp ) (3 diffs)
• src/settings/editors/UIMachineNetworkFeaturesEditor.h (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIMachineDescriptionEditor.h ) (5 diffs)
• src/settings/machine/UIMachineSettingsNetwork.cpp (modified) (23 diffs)

trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

@@ -911 +911 @@
         src/settings/editors/UIMachineDisplayScreenFeaturesEditor.h \
         src/settings/editors/UIMachineDescriptionEditor.h \
+        src/settings/editors/UIMachineNetworkFeaturesEditor.h \
         src/settings/editors/UIMaximumGuestScreenSizeEditor.h \
         src/settings/editors/UIMiniToolbarSettingsEditor.h \
@@ -1477 +1478 @@
         src/settings/editors/UIMachineDisplayScreenFeaturesEditor.cpp \
         src/settings/editors/UIMachineDescriptionEditor.cpp \
+        src/settings/editors/UIMachineNetworkFeaturesEditor.cpp \
         src/settings/editors/UIMaximumGuestScreenSizeEditor.cpp \
         src/settings/editors/UIMiniToolbarSettingsEditor.cpp \

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIMachineNetworkFeaturesEditor.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * VBox Qt GUI - UIMachineDescriptionEditor class implementation.
+ * VBox Qt GUI - UIMachineNetworkFeaturesEditor class implementation.
  */
 
@@ -17 +17 @@
 
 /* Qt includes: */
+#include <QCheckBox>
+#include <QComboBox>
+#include <QGridLayout>
+#include <QLabel>
+#include <QPushButton>
 #include <QTextEdit>
 #include <QVBoxLayout>
 
 /* GUI includes: */
-#include "UIMachineDescriptionEditor.h"
-
-
-UIMachineDescriptionEditor::UIMachineDescriptionEditor(QWidget *pParent /* = 0 */)
+#include "QIArrowButtonSwitch.h"
+#include "QILineEdit.h"
+#include "QIToolButton.h"
+#include "UICommon.h"
+#include "UIConverter.h"
+#include "UIIconPool.h"
+#include "UIMachineNetworkFeaturesEditor.h"
+
+/* COM includes: */
+#include "CSystemProperties.h"
+
+
+UIMachineNetworkFeaturesEditor::UIMachineNetworkFeaturesEditor(QWidget *pParent /* = 0 */)
     : QIWithRetranslateUI<QWidget>(pParent)
-    , m_pTextEdit(0)
+    , m_fAdvancedButtonExpanded(false)
+    , m_enmAdapterType(KNetworkAdapterType_Null)
+    , m_enmPromiscuousMode(KNetworkAdapterPromiscModePolicy_Max)
+    , m_fCableConnected(false)
+    , m_pButtonAdvanced(0)
+    , m_pWidgetSettings(0)
+    , m_pLayoutSettings(0)
+    , m_pLabelAdapterType(0)
+    , m_pComboAdapterType(0)
+    , m_pLabelPromiscuousMode(0)
+    , m_pComboPromiscuousMode(0)
+    , m_pLabelMAC(0)
+    , m_pEditorMAC(0)
+    , m_pButtonMAC(0)
+    , m_pLabelGenericProperties(0)
+    , m_pEditorGenericProperties(0)
+    , m_pCheckBoxCableConnected(0)
+    , m_pButtonPortForwarding(0)
 {
     prepare();
 }
 
-void UIMachineDescriptionEditor::setValue(const QString &strValue)
-{
-    /* Update cached value and
-     * text-edit if value has changed: */
-    if (m_strValue != strValue)
-    {
-        m_strValue = strValue;
-        if (m_pTextEdit)
-            m_pTextEdit->setPlainText(strValue);
-    }
-}
-
-QString UIMachineDescriptionEditor::value() const
-{
-    return m_pTextEdit ? m_pTextEdit->toPlainText() : m_strValue;
-}
-
-void UIMachineDescriptionEditor::retranslateUi()
-{
-    if (m_pTextEdit)
-        m_pTextEdit->setToolTip(tr("Holds the description of the virtual machine. The description field is useful "
-                                   "for commenting on configuration details of the installed guest OS."));
-}
-
-void UIMachineDescriptionEditor::prepare()
+void UIMachineNetworkFeaturesEditor::setAdvancedButtonExpanded(bool fExpanded)
+{
+    if (m_fAdvancedButtonExpanded != fExpanded)
+    {
+        m_fAdvancedButtonExpanded = fExpanded;
+        if (m_pButtonAdvanced)
+        {
+            m_pButtonAdvanced->setExpanded(m_fAdvancedButtonExpanded);
+            sltHandleAdvancedButtonStateChange();
+        }
+    }
+}
+
+bool UIMachineNetworkFeaturesEditor::advancedButtonExpanded() const
+{
+    return m_pButtonAdvanced ? m_pButtonAdvanced->isExpanded() : m_fAdvancedButtonExpanded;
+}
+
+void UIMachineNetworkFeaturesEditor::setAdapterType(const KNetworkAdapterType &enmType)
+{
+    if (m_enmAdapterType != enmType)
+    {
+        m_enmAdapterType = enmType;
+        repopulateAdapterTypeCombo();
+    }
+}
+
+KNetworkAdapterType UIMachineNetworkFeaturesEditor::adapterType() const
+{
+    return m_pComboAdapterType ? m_pComboAdapterType->currentData().value<KNetworkAdapterType>() : m_enmAdapterType;
+}
+
+void UIMachineNetworkFeaturesEditor::setPromiscuousMode(const KNetworkAdapterPromiscModePolicy &enmMode)
+{
+    if (m_enmPromiscuousMode != enmMode)
+    {
+        m_enmPromiscuousMode = enmMode;
+        repopulatePromiscuousModeCombo();
+    }
+}
+
+KNetworkAdapterPromiscModePolicy UIMachineNetworkFeaturesEditor::promiscuousMode() const
+{
+    return m_pComboPromiscuousMode ? m_pComboPromiscuousMode->currentData().value<KNetworkAdapterPromiscModePolicy>() : m_enmPromiscuousMode;
+}
+
+void UIMachineNetworkFeaturesEditor::setMACAddress(const QString &strAddress)
+{
+    if (m_strMACAddress != strAddress)
+    {
+        m_strMACAddress = strAddress;
+        if (m_pEditorMAC)
+            m_pEditorMAC->setText(m_strMACAddress);
+    }
+}
+
+QString UIMachineNetworkFeaturesEditor::macAddress() const
+{
+    return m_pEditorMAC ? m_pEditorMAC->text() : m_strMACAddress;
+}
+
+void UIMachineNetworkFeaturesEditor::setGenericProperties(const QString &strProperties)
+{
+    if (m_strGenericProperties != strProperties)
+    {
+        m_strGenericProperties = strProperties;
+        if (m_pEditorGenericProperties)
+            m_pEditorGenericProperties->setPlainText(m_strGenericProperties);
+    }
+}
+
+QString UIMachineNetworkFeaturesEditor::genericProperties() const
+{
+    return m_pEditorGenericProperties ? m_pEditorGenericProperties->toPlainText() : m_strGenericProperties;
+}
+
+void UIMachineNetworkFeaturesEditor::setCableConnected(bool fConnected)
+{
+    if (m_fCableConnected != fConnected)
+    {
+        m_fCableConnected = fConnected;
+        if (m_pCheckBoxCableConnected)
+            m_pCheckBoxCableConnected->setChecked(m_fCableConnected);
+    }
+}
+
+bool UIMachineNetworkFeaturesEditor::cableConnected() const
+{
+    return m_pCheckBoxCableConnected ? m_pCheckBoxCableConnected->isChecked() : m_fCableConnected;
+}
+
+void UIMachineNetworkFeaturesEditor::setPortForwardingRules(const UIPortForwardingDataList &rules)
+{
+    if (m_portForwardingRules != rules)
+        m_portForwardingRules = rules;
+}
+
+UIPortForwardingDataList UIMachineNetworkFeaturesEditor::portForwardingRules() const
+{
+    return m_portForwardingRules;
+}
+
+void UIMachineNetworkFeaturesEditor::setAdvancedOptionsAvailable(bool fAvailable)
+{
+    m_pButtonAdvanced->setEnabled(fAvailable);
+}
+
+void UIMachineNetworkFeaturesEditor::setAdapterOptionsAvailable(bool fAvailable)
+{
+    m_pLabelAdapterType->setEnabled(fAvailable);
+    m_pComboAdapterType->setEnabled(fAvailable);
+}
+
+void UIMachineNetworkFeaturesEditor::setPromiscuousOptionsAvailable(bool fAvailable)
+{
+    m_pLabelPromiscuousMode->setEnabled(fAvailable);
+    m_pComboPromiscuousMode->setEnabled(fAvailable);
+}
+
+void UIMachineNetworkFeaturesEditor::setMACOptionsAvailable(bool fAvailable)
+{
+    m_pLabelMAC->setEnabled(fAvailable);
+    m_pEditorMAC->setEnabled(fAvailable);
+    m_pButtonMAC->setEnabled(fAvailable);
+}
+
+void UIMachineNetworkFeaturesEditor::setGenericPropertiesAvailable(bool fAvailable)
+{
+    m_pLabelGenericProperties->setVisible(fAvailable);
+    m_pEditorGenericProperties->setVisible(fAvailable);
+}
+
+void UIMachineNetworkFeaturesEditor::setCableOptionsAvailable(bool fAvailable)
+{
+    m_pCheckBoxCableConnected->setEnabled(fAvailable);
+}
+
+void UIMachineNetworkFeaturesEditor::setForwardingOptionsAvailable(bool fAvailable)
+{
+    m_pButtonPortForwarding->setEnabled(fAvailable);
+}
+
+int UIMachineNetworkFeaturesEditor::minimumLabelHorizontalHint() const
+{
+    int iMinimumLabelHorizontalHint = 0;
+    if (m_pLabelAdapterType)
+        iMinimumLabelHorizontalHint = qMax(iMinimumLabelHorizontalHint, m_pLabelAdapterType->minimumSizeHint().width());
+    if (m_pLabelPromiscuousMode)
+        iMinimumLabelHorizontalHint = qMax(iMinimumLabelHorizontalHint, m_pLabelPromiscuousMode->minimumSizeHint().width());
+    if (m_pLabelMAC)
+        iMinimumLabelHorizontalHint = qMax(iMinimumLabelHorizontalHint, m_pLabelMAC->minimumSizeHint().width());
+    if (m_pLabelGenericProperties)
+        iMinimumLabelHorizontalHint = qMax(iMinimumLabelHorizontalHint, m_pLabelGenericProperties->minimumSizeHint().width());
+    return iMinimumLabelHorizontalHint;
+}
+
+void UIMachineNetworkFeaturesEditor::setMinimumLayoutIndent(int iIndent)
+{
+    if (m_pLayoutSettings)
+        m_pLayoutSettings->setColumnMinimumWidth(0, iIndent);
+}
+
+void UIMachineNetworkFeaturesEditor::generateMac()
+{
+    setMACAddress(uiCommon().host().GenerateMACAddress());
+}
+
+void UIMachineNetworkFeaturesEditor::retranslateUi()
+{
+    if (m_pButtonAdvanced)
+    {
+        m_pButtonAdvanced->setText(tr("A&dvanced"));
+        m_pButtonAdvanced->setToolTip(tr("Shows additional network adapter options."));
+    }
+
+    if (m_pLabelAdapterType)
+        m_pLabelAdapterType->setText(tr("Adapter &Type:"));
+    if (m_pComboAdapterType)
+    {
+        for (int i = 0; i < m_pComboAdapterType->count(); ++i)
+        {
+            const KNetworkAdapterType enmType = m_pComboAdapterType->itemData(i).value<KNetworkAdapterType>();
+            m_pComboAdapterType->setItemText(i, gpConverter->toString(enmType));
+        }
+        m_pComboAdapterType->setToolTip(tr("Selects the type of the virtual network adapter. Depending on this value, VirtualBox "
+                                           "will provide different network hardware to the virtual machine."));
+    }
+
+    if (m_pLabelPromiscuousMode)
+        m_pLabelPromiscuousMode->setText(tr("&Promiscuous Mode:"));
+    if (m_pComboPromiscuousMode)
+    {
+        for (int i = 0; i < m_pComboPromiscuousMode->count(); ++i)
+        {
+            const KNetworkAdapterPromiscModePolicy enmType = m_pComboPromiscuousMode->itemData(i).value<KNetworkAdapterPromiscModePolicy>();
+            m_pComboPromiscuousMode->setItemText(i, gpConverter->toString(enmType));
+        }
+        m_pComboPromiscuousMode->setToolTip(tr("Selects the promiscuous mode policy of the network adapter when attached to an "
+                                               "internal network, host only network or a bridge."));
+    }
+
+    if (m_pLabelMAC)
+        m_pLabelMAC->setText(tr("&MAC Address:"));
+    if (m_pEditorMAC)
+        m_pEditorMAC->setToolTip(tr("Holds the MAC address of this adapter. It contains exactly 12 characters chosen from "
+                                    "{0-9,A-F}. Note that the second character must be an even digit."));
+    if (m_pButtonMAC)
+        m_pButtonMAC->setToolTip(tr("Generates a new random MAC address."));
+
+    if (m_pLabelGenericProperties)
+        m_pLabelGenericProperties->setText(tr("Generic Properties:"));
+    if (m_pEditorGenericProperties)
+        m_pEditorGenericProperties->setToolTip(tr("Holds the configuration settings for the network attachment driver. The "
+                                                  "settings should be of the form <b>name=value</b> and will depend on the "
+                                                  "driver. Use <b>shift-enter</b> to add a new entry."));
+
+    if (m_pCheckBoxCableConnected)
+    {
+        m_pCheckBoxCableConnected->setText(tr("&Cable Connected"));
+        m_pCheckBoxCableConnected->setToolTip(tr("When checked, the virtual network cable is plugged in."));
+    }
+
+    if (m_pButtonPortForwarding)
+    {
+        m_pButtonPortForwarding->setText(tr("&Port Forwarding"));
+        m_pButtonPortForwarding->setToolTip(tr("Displays a window to configure port forwarding rules."));
+    }
+}
+
+void UIMachineNetworkFeaturesEditor::sltHandleAdvancedButtonStateChange()
+{
+    /* What's the state? */
+    const bool fExpanded = m_pButtonAdvanced->isExpanded();
+    /* Update widget visibility: */
+    m_pWidgetSettings->setVisible(fExpanded);
+    /* Notify listeners about the button state change: */
+    emit sigNotifyAdvancedButtonStateChange(fExpanded);
+}
+
+void UIMachineNetworkFeaturesEditor::sltOpenPortForwardingDlg()
+{
+    UIMachineSettingsPortForwardingDlg dlg(this, m_portForwardingRules);
+    if (dlg.exec() == QDialog::Accepted)
+        m_portForwardingRules = dlg.rules();
+}
+
+void UIMachineNetworkFeaturesEditor::prepare()
 {
     /* Prepare main layout: */
@@ -63 +316 @@
         pLayout->setContentsMargins(0, 0, 0, 0);
 
-        /* Prepare text-edit: */
-        m_pTextEdit = new QTextEdit(this);
-        if (m_pTextEdit)
+        /* Prepare advanced arrow button: */
+        m_pButtonAdvanced = new QIArrowButtonSwitch(this);
+        if (m_pButtonAdvanced)
         {
-            setFocusProxy(m_pTextEdit);
-            m_pTextEdit->setAcceptRichText(false);
-#ifdef VBOX_WS_MAC
-            m_pTextEdit->setMinimumHeight(150);
-#endif
-
-            pLayout->addWidget(m_pTextEdit);
+            const QStyle *pStyle = QApplication::style();
+            const int iIconMetric = (int)(pStyle->pixelMetric(QStyle::PM_SmallIconSize) * .625);
+            m_pButtonAdvanced->setIconSize(QSize(iIconMetric, iIconMetric));
+            m_pButtonAdvanced->setIcons(UIIconPool::iconSet(":/arrow_right_10px.png"),
+                                        UIIconPool::iconSet(":/arrow_down_10px.png"));
+
+            pLayout->addWidget(m_pButtonAdvanced);
         }
-    }
+
+        /* Prepare advanced settings widget: */
+        m_pWidgetSettings = new QWidget(this);
+        if (m_pWidgetSettings)
+        {
+            /* Prepare advanced settings layout: */
+            m_pLayoutSettings = new QGridLayout(m_pWidgetSettings);
+            if (m_pLayoutSettings)
+            {
+                m_pLayoutSettings->setContentsMargins(0, 0, 0, 0);
+                m_pLayoutSettings->setColumnStretch(2, 1);
+
+                /* Prepare adapter type label: */
+                m_pLabelAdapterType = new QLabel(m_pWidgetSettings);
+                if (m_pLabelAdapterType)
+                {
+                    m_pLabelAdapterType->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
+                    m_pLayoutSettings->addWidget(m_pLabelAdapterType, 0, 0);
+                }
+                /* Prepare adapter type combo: */
+                m_pComboAdapterType = new QComboBox(m_pWidgetSettings);
+                if (m_pComboAdapterType)
+                {
+                    if (m_pLabelAdapterType)
+                        m_pLabelAdapterType->setBuddy(m_pComboAdapterType);
+                    m_pLayoutSettings->addWidget(m_pComboAdapterType, 0, 1, 1, 3);
+                }
+
+                /* Prepare promiscuous mode label: */
+                m_pLabelPromiscuousMode = new QLabel(m_pWidgetSettings);
+                if (m_pLabelPromiscuousMode)
+                {
+                    m_pLabelPromiscuousMode->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
+                    m_pLayoutSettings->addWidget(m_pLabelPromiscuousMode, 1, 0);
+                }
+                /* Prepare promiscuous mode combo: */
+                m_pComboPromiscuousMode = new QComboBox(m_pWidgetSettings);
+                if (m_pComboPromiscuousMode)
+                {
+                    if (m_pLabelPromiscuousMode)
+                        m_pLabelPromiscuousMode->setBuddy(m_pComboPromiscuousMode);
+                    m_pLayoutSettings->addWidget(m_pComboPromiscuousMode, 1, 1, 1, 3);
+                }
+
+                /* Prepare MAC label: */
+                m_pLabelMAC = new QLabel(m_pWidgetSettings);
+                if (m_pLabelMAC)
+                {
+                    m_pLabelMAC->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
+                    m_pLayoutSettings->addWidget(m_pLabelMAC, 2, 0);
+                }
+                /* Prepare MAC editor: */
+                m_pEditorMAC = new QILineEdit(m_pWidgetSettings);
+                if (m_pEditorMAC)
+                {
+                    if (m_pLabelMAC)
+                        m_pLabelMAC->setBuddy(m_pEditorMAC);
+                    m_pEditorMAC->setAllowToCopyContentsWhenDisabled(true);
+                    m_pEditorMAC->setValidator(new QRegularExpressionValidator(QRegularExpression("[0-9A-Fa-f]{12}"), this));
+                    m_pEditorMAC->setMinimumWidthByText(QString().fill('0', 12));
+
+                    m_pLayoutSettings->addWidget(m_pEditorMAC, 2, 1, 1, 2);
+                }
+                /* Prepare MAC button: */
+                m_pButtonMAC = new QIToolButton(m_pWidgetSettings);
+                if (m_pButtonMAC)
+                {
+                    m_pButtonMAC->setIcon(UIIconPool::iconSet(":/refresh_16px.png"));
+                    m_pLayoutSettings->addWidget(m_pButtonMAC, 2, 3);
+                }
+
+                /* Prepare MAC label: */
+                m_pLabelGenericProperties = new QLabel(m_pWidgetSettings);
+                if (m_pLabelGenericProperties)
+                {
+                    m_pLabelGenericProperties->setAlignment(Qt::AlignRight | Qt::AlignTop);
+                    m_pLayoutSettings->addWidget(m_pLabelGenericProperties, 3, 0);
+                }
+                /* Prepare MAC editor: */
+                m_pEditorGenericProperties = new QTextEdit(m_pWidgetSettings);
+                if (m_pEditorGenericProperties)
+                    m_pLayoutSettings->addWidget(m_pEditorGenericProperties, 3, 1, 1, 3);
+
+                /* Prepare cable connected check-box: */
+                m_pCheckBoxCableConnected = new QCheckBox(m_pWidgetSettings);
+                if (m_pCheckBoxCableConnected)
+                    m_pLayoutSettings->addWidget(m_pCheckBoxCableConnected, 4, 1, 1, 2);
+
+                /* Prepare port forwarding button: */
+                m_pButtonPortForwarding = new QPushButton(m_pWidgetSettings);
+                if (m_pButtonPortForwarding)
+                    m_pLayoutSettings->addWidget(m_pButtonPortForwarding, 5, 1);
+            }
+
+            pLayout->addWidget(m_pWidgetSettings);
+        }
+    }
+
+    /* Configure connections: */
+    if (m_pButtonAdvanced)
+        connect(m_pButtonAdvanced, &QIArrowButtonSwitch::sigClicked,
+                this, &UIMachineNetworkFeaturesEditor::sltHandleAdvancedButtonStateChange);
+    if (m_pEditorMAC)
+        connect(m_pEditorMAC, &QILineEdit::textChanged,
+                this, &UIMachineNetworkFeaturesEditor::sigMACAddressChanged);
+    if (m_pButtonMAC)
+        connect(m_pButtonMAC, &QIToolButton::clicked,
+                this, &UIMachineNetworkFeaturesEditor::generateMac);
+    if (m_pButtonPortForwarding)
+        connect(m_pButtonPortForwarding, &QPushButton::clicked,
+                this, &UIMachineNetworkFeaturesEditor::sltOpenPortForwardingDlg);
+
+    /* Update widget availability: */
+    m_pWidgetSettings->setVisible(m_pButtonAdvanced->isExpanded());
 
     /* Apply language settings: */
     retranslateUi();
 }
+
+void UIMachineNetworkFeaturesEditor::repopulateAdapterTypeCombo()
+{
+    if (m_pComboAdapterType)
+    {
+        /* Clear combo first of all: */
+        m_pComboAdapterType->clear();
+
+        /* Load currently supported types: */
+        CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+        QVector<KNetworkAdapterType> supportedTypes = comProperties.GetSupportedNetworkAdapterTypes();
+
+        /* Make sure requested value if sane is present as well: */
+        if (   m_enmAdapterType != KNetworkAdapterType_Null
+            && !supportedTypes.contains(m_enmAdapterType))
+            supportedTypes.prepend(m_enmAdapterType);
+
+        /* Update combo with all the supported values: */
+        foreach (const KNetworkAdapterType &enmType, supportedTypes)
+            m_pComboAdapterType->addItem(QString(), QVariant::fromValue(enmType));
+
+        /* Look for proper index to choose: */
+        const int iIndex = m_pComboAdapterType->findData(QVariant::fromValue(m_enmAdapterType));
+        if (iIndex != -1)
+            m_pComboAdapterType->setCurrentIndex(iIndex);
+
+        /* Retranslate finally: */
+        retranslateUi();
+    }
+}
+
+void UIMachineNetworkFeaturesEditor::repopulatePromiscuousModeCombo()
+{
+    if (m_pComboPromiscuousMode)
+    {
+        /* Clear combo first of all: */
+        m_pComboPromiscuousMode->clear();
+
+        /* Populate currently supported types: */
+        QVector<KNetworkAdapterPromiscModePolicy> supportedTypes =
+            QVector<KNetworkAdapterPromiscModePolicy>() << KNetworkAdapterPromiscModePolicy_Deny
+                                                        << KNetworkAdapterPromiscModePolicy_AllowNetwork
+                                                        << KNetworkAdapterPromiscModePolicy_AllowAll;
+
+        /* Make sure requested value if sane is present as well: */
+        if (   m_enmPromiscuousMode != KNetworkAdapterPromiscModePolicy_Max
+            && !supportedTypes.contains(m_enmPromiscuousMode))
+            supportedTypes.prepend(m_enmPromiscuousMode);
+
+        /* Update combo with all the supported values: */
+        foreach (const KNetworkAdapterPromiscModePolicy &enmType, supportedTypes)
+            m_pComboPromiscuousMode->addItem(QString(), QVariant::fromValue(enmType));
+
+        /* Look for proper index to choose: */
+        const int iIndex = m_pComboPromiscuousMode->findData(QVariant::fromValue(m_enmPromiscuousMode));
+        if (iIndex != -1)
+            m_pComboPromiscuousMode->setCurrentIndex(iIndex);
+
+        /* Retranslate finally: */
+        retranslateUi();
+    }
+}

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIMachineNetworkFeaturesEditor.h

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * VBox Qt GUI - UIMachineDescriptionEditor class declaration.
+ * VBox Qt GUI - UIMachineNetworkFeaturesEditor class declaration.
  */
 
@@ -16 +16 @@
  */
 
-#ifndef FEQT_INCLUDED_SRC_settings_editors_UIMachineDescriptionEditor_h
-#define FEQT_INCLUDED_SRC_settings_editors_UIMachineDescriptionEditor_h
+#ifndef FEQT_INCLUDED_SRC_settings_editors_UIMachineNetworkFeaturesEditor_h
+#define FEQT_INCLUDED_SRC_settings_editors_UIMachineNetworkFeaturesEditor_h
 #ifndef RT_WITHOUT_PRAGMA_ONCE
 # pragma once
@@ -24 +24 @@
 /* GUI includes: */
 #include "QIWithRetranslateUI.h"
+#include "UIMachineSettingsPortForwardingDlg.h"
+
+/* COM includes: */
+#include "COMEnums.h"
 
 /* Forward declarations: */
+class QCheckBox;
+class QComboBox;
+class QGridLayout;
+class QLabel;
 class QTextEdit;
+class QIArrowButtonSwitch;
+class QILineEdit;
+class QIToolButton;
 
 /** QWidget subclass used as machine description editor. */
-class SHARED_LIBRARY_STUFF UIMachineDescriptionEditor : public QIWithRetranslateUI<QWidget>
+class SHARED_LIBRARY_STUFF UIMachineNetworkFeaturesEditor : public QIWithRetranslateUI<QWidget>
 {
     Q_OBJECT;
+
+signals:
+
+    /** Notifies about the advanced button state change to @a fExpanded. */
+    void sigNotifyAdvancedButtonStateChange(bool fExpanded);
+    /** Notifies about MAC address changed. */
+    void sigMACAddressChanged();
 
 public:
 
     /** Constructs editor passing @a pParent to the base-class. */
-    UIMachineDescriptionEditor(QWidget *pParent = 0);
+    UIMachineNetworkFeaturesEditor(QWidget *pParent = 0);
 
-    /** Defines editor @a strValue. */
-    void setValue(const QString &strValue);
-    /** Returns editor value. */
-    QString value() const;
+    /** Defines whether advanced button @a fExpanded. */
+    void setAdvancedButtonExpanded(bool fExpanded);
+    /** Returns whether advanced button expanded. */
+    bool advancedButtonExpanded() const;
+
+    /** Defines adapter @a enmType. */
+    void setAdapterType(const KNetworkAdapterType &enmType);
+    /** Returns adapter type. */
+    KNetworkAdapterType adapterType() const;
+
+    /** Defines promiscuous @a enmMode. */
+    void setPromiscuousMode(const KNetworkAdapterPromiscModePolicy &enmMode);
+    /** Returns promiscuous mode. */
+    KNetworkAdapterPromiscModePolicy promiscuousMode() const;
+
+    /** Defines MAC @a strAddress. */
+    void setMACAddress(const QString &strAddress);
+    /** Returns MAC address. */
+    QString macAddress() const;
+
+    /** Defines generic @a strProperties. */
+    void setGenericProperties(const QString &strProperties);
+    /** Returns generic properties. */
+    QString genericProperties() const;
+
+    /** Defines whether cable is @a fConnected. */
+    void setCableConnected(bool fConnected);
+    /** Returns whether cable is connected. */
+    bool cableConnected() const;
+
+    /** Defines list of port forwarding @a rules. */
+    void setPortForwardingRules(const UIPortForwardingDataList &rules);
+    /** Returns list of port forwarding rules. */
+    UIPortForwardingDataList portForwardingRules() const;
+
+    /** Defines whether advanced options @a fAvailable. */
+    void setAdvancedOptionsAvailable(bool fAvailable);
+    /** Defines whether adapter options @a fAvailable. */
+    void setAdapterOptionsAvailable(bool fAvailable);
+    /** Defines whether promiscuous options @a fAvailable. */
+    void setPromiscuousOptionsAvailable(bool fAvailable);
+    /** Defines whether MAC options @a fAvailable. */
+    void setMACOptionsAvailable(bool fAvailable);
+    /** Defines whether generic properties @a fAvailable. */
+    void setGenericPropertiesAvailable(bool fAvailable);
+    /** Defines whether cable options @a fAvailable. */
+    void setCableOptionsAvailable(bool fAvailable);
+    /** Defines whether forwarding options @a fAvailable. */
+    void setForwardingOptionsAvailable(bool fAvailable);
+
+    /** Returns minimum layout hint. */
+    int minimumLabelHorizontalHint() const;
+    /** Defines minimum layout @a iIndent. */
+    void setMinimumLayoutIndent(int iIndent);
+
+public slots:
+
+    /** Generates MAC address. */
+    void generateMac();
 
 protected:
@@ -48 +121 @@
     virtual void retranslateUi() RT_OVERRIDE;
 
+private slots:
+
+    /** Handles advanced button state change to expanded. */
+    void sltHandleAdvancedButtonStateChange();
+    /** Handles request to open port forwarding dialog. */
+    void sltOpenPortForwardingDlg();
+
 private:
 
@@ -53 +133 @@
     void prepare();
 
-    /** Holds the value to be set. */
-    QString  m_strValue;
+    /** Repopulates adapter type combo. */
+    void repopulateAdapterTypeCombo();
+    /** Repopulates promiscuous mode combo. */
+    void repopulatePromiscuousModeCombo();
 
-    /** Holds the check-box instance. */
-    QTextEdit *m_pTextEdit;
+    /** @name Widgets
+     * @{ */
+        /** Holds whether advanced button expanded. */
+        bool                              m_fAdvancedButtonExpanded;
+        /** Holds the adapter type to be set. */
+        KNetworkAdapterType               m_enmAdapterType;
+        /** Holds the promisc mode to be set. */
+        KNetworkAdapterPromiscModePolicy  m_enmPromiscuousMode;
+        /** Holds the MAC address to be set. */
+        QString                           m_strMACAddress;
+        /** Holds the generic properties to be set. */
+        QString                           m_strGenericProperties;
+        /** Holds whether cable is connected. */
+        bool                              m_fCableConnected;
+        /** Holds the list of port forwarding rules. */
+        UIPortForwardingDataList          m_portForwardingRules;
+    /** @} */
+
+    /** @name Widgets
+     * @{ */
+        /** Holds the advanced button instance. */
+        QIArrowButtonSwitch *m_pButtonAdvanced;
+        /** Holds the settings widget instance. */
+        QWidget             *m_pWidgetSettings;
+        /** Holds the settings layout instance. */
+        QGridLayout         *m_pLayoutSettings;
+        /** Holds the adapter type label instance. */
+        QLabel              *m_pLabelAdapterType;
+        /** Holds the adapter type editor instance. */
+        QComboBox           *m_pComboAdapterType;
+        /** Holds the promiscuous mode label instance. */
+        QLabel              *m_pLabelPromiscuousMode;
+        /** Holds the promiscuous mode combo instance. */
+        QComboBox           *m_pComboPromiscuousMode;
+        /** Holds the MAC label instance. */
+        QLabel              *m_pLabelMAC;
+        /** Holds the MAC editor instance. */
+        QILineEdit          *m_pEditorMAC;
+        /** Holds the MAC button instance. */
+        QIToolButton        *m_pButtonMAC;
+        /** Holds the generic properties label instance. */
+        QLabel              *m_pLabelGenericProperties;
+        /** Holds the generic properties editor instance. */
+        QTextEdit           *m_pEditorGenericProperties;
+        /** Holds the cable connected check-box instance. */
+        QCheckBox           *m_pCheckBoxCableConnected;
+        /** Holds the port forwarding button instance. */
+        QPushButton         *m_pButtonPortForwarding;
+    /** @} */
 };
 
-#endif /* !FEQT_INCLUDED_SRC_settings_editors_UIMachineDescriptionEditor_h */
+#endif /* !FEQT_INCLUDED_SRC_settings_editors_UIMachineNetworkFeaturesEditor_h */

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

@@ -18 +18 @@
 /* Qt includes: */
 #include <QCheckBox>
-#include <QComboBox>
 #include <QGridLayout>
 #include <QLabel>
-#include <QRegExp>
-#include <QRegularExpressionValidator>
-#include <QPushButton>
-#include <QTextEdit>
+#include <QVBoxLayout>
 
 /* GUI includes: */
-#include "QIArrowButtonSwitch.h"
-#include "QILineEdit.h"
 #include "QITabWidget.h"
-#include "QIToolButton.h"
-#include "QIWidgetValidator.h"
 #include "UICommon.h"
-#include "UIConverter.h"
 #include "UIErrorString.h"
-#include "UIExtraDataManager.h"
-#include "UIIconPool.h"
+#include "UIMachineNetworkFeaturesEditor.h"
 #include "UIMachineSettingsNetwork.h"
 #include "UINetworkAttachmentEditor.h"
@@ -44 +34 @@
 #include "CNATEngine.h"
 #include "CNetworkAdapter.h"
-
-/* Other VBox includes: */
-#ifdef VBOX_WITH_VDE
-# include <iprt/ldr.h>
-# include <VBox/VDEPlug.h>
-#endif
 
 
@@ -200 +184 @@
     void sigTabUpdated();
 
-    /** Notifies about the advanced button has @a fExpanded. */
+    /** Notifies about the advanced button state change to @a fExpanded. */
     void sigNotifyAdvancedButtonStateChange(bool fExpanded);
 
@@ -214 +198 @@
     void sltHandleAttachmentTypeChange();
     void sltHandleAlternativeNameChange();
-    void sltHandleAdvancedButtonStateChange();
-    void sltGenerateMac();
-    void sltOpenPortForwardingDlg();
 
 private:
@@ -226 +207 @@
     /** Prepares connections. */
     void prepareConnections();
-    /** Prepares advanced settings widgets. */
-    void prepareAdvancedSettingsWidgets(QGridLayout *pLayout);
-
-    /* Helping stuff: */
-    void populateComboboxes();
-
-    /** Handles advanced button state change. */
-    void handleAdvancedButtonStateChange();
-
-    /* Various static stuff: */
-    static int position(QComboBox *pComboBox, int iData);
-    static int position(QComboBox *pComboBox, const QString &strText);
 
     /* Parent page: */
@@ -244 +213 @@
     /* Other variables: */
     int m_iSlot;
-    KNetworkAdapterType m_enmAdapterType;
-    UIPortForwardingDataList m_portForwardingRules;
 
     /** @name Widgets
      * @{ */
         /** Holds the adapter check-box instance. */
-        QCheckBox                 *m_pCheckBoxAdapter;
+        QCheckBox                      *m_pCheckBoxAdapter;
         /** Holds the adapter settings widget instance. */
-        QWidget                   *m_pWidgetAdapterSettings;
-        /** Holds the adapter settings layout instance. */
-        QGridLayout               *m_pLayoutAdapterSettings;
-        /** Holds the advanced settings container widget instance. */
-        QWidget                   *m_pWidgetAdvancedSettings;
-        /** Holds the attachment type label instance. */
-        QLabel                    *m_pLabelAttachmentType;
-        /** Holds the network name label instance. */
-        QLabel                    *m_pLabelNetworkName;
+        QWidget                        *m_pWidgetAdapterSettings;
         /** Holds the attachment type editor instance. */
-        UINetworkAttachmentEditor *m_pEditorAttachmentType;
-        /** Holds the advanced button instance. */
-        QIArrowButtonSwitch       *m_pButtonAdvanced;
-        /** Holds the adapter type label instance. */
-        QLabel                    *m_pLabelAdapterType;
-        /** Holds the adapter type editor instance. */
-        QComboBox                 *m_pComboAdapterType;
-        /** Holds the promiscuous mode label instance. */
-        QLabel                    *m_pLabelPromiscuousMode;
-        /** Holds the promiscuous mode combo instance. */
-        QComboBox                 *m_pComboPromiscuousMode;
-        /** Holds the MAC label instance. */
-        QLabel                    *m_pLabelMAC;
-        /** Holds the MAC editor instance. */
-        QILineEdit                *m_pEditorMAC;
-        /** Holds the MAC button instance. */
-        QIToolButton              *m_pButtonMAC;
-        /** Holds the generic properties label instance. */
-        QLabel                    *m_pLabelGenericProperties;
-        /** Holds the generic properties editor instance. */
-        QTextEdit                 *m_pEditorGenericProperties;
-        /** Holds the cable connected check-box instance. */
-        QCheckBox                 *m_pCheckBoxCableConnected;
-        /** Holds the port forwarding button instance. */
-        QPushButton               *m_pButtonPortForwarding;
+        UINetworkAttachmentEditor      *m_pEditorAttachmentType;
+        /** Holds the network features editor instance. */
+        UIMachineNetworkFeaturesEditor *m_pEditorNetworkFeatures;
     /** @} */
 };
@@ -299 +236 @@
     , m_pParent(pParent)
     , m_iSlot(-1)
-    , m_enmAdapterType(KNetworkAdapterType_Null)
     , m_pCheckBoxAdapter(0)
     , m_pWidgetAdapterSettings(0)
-    , m_pLayoutAdapterSettings(0)
-    , m_pWidgetAdvancedSettings(0)
-    , m_pLabelAttachmentType(0)
-    , m_pLabelNetworkName(0)
     , m_pEditorAttachmentType(0)
-    , m_pButtonAdvanced(0)
-    , m_pLabelAdapterType(0)
-    , m_pComboAdapterType(0)
-    , m_pLabelPromiscuousMode(0)
-    , m_pComboPromiscuousMode(0)
-    , m_pLabelMAC(0)
-    , m_pEditorMAC(0)
-    , m_pButtonMAC(0)
-    , m_pLabelGenericProperties(0)
-    , m_pEditorGenericProperties(0)
-    , m_pCheckBoxCableConnected(0)
-    , m_pButtonPortForwarding(0)
+    , m_pEditorNetworkFeatures(0)
 {
     prepare();
@@ -353 +274 @@
     sltHandleAttachmentTypeChange();
 
-    /* Load adapter type: */
-    m_enmAdapterType = oldAdapterData.m_adapterType;
-
-    /* Load promiscuous mode type: */
-    m_pComboPromiscuousMode->setCurrentIndex(position(m_pComboPromiscuousMode, oldAdapterData.m_promiscuousMode));
-
-    /* Other options: */
-    m_pEditorMAC->setText(oldAdapterData.m_strMACAddress);
-    m_pEditorGenericProperties->setText(oldAdapterData.m_strGenericProperties);
-    m_pCheckBoxCableConnected->setChecked(oldAdapterData.m_fCableConnected);
+    /* Load settings: */
+    m_pEditorNetworkFeatures->setAdapterType(oldAdapterData.m_adapterType);
+    m_pEditorNetworkFeatures->setPromiscuousMode(oldAdapterData.m_promiscuousMode);
+    m_pEditorNetworkFeatures->setMACAddress(oldAdapterData.m_strMACAddress);
+    m_pEditorNetworkFeatures->setGenericProperties(oldAdapterData.m_strGenericProperties);
+    m_pEditorNetworkFeatures->setCableConnected(oldAdapterData.m_fCableConnected);
 
     /* Load port forwarding rules: */
-    m_portForwardingRules.clear();
+    UIPortForwardingDataList portForwardingRules;
     for (int i = 0; i < adapterCache.childCount(); ++i)
-        m_portForwardingRules << adapterCache.child(i).base();
-
-    /* Repopulate combo-boxes content: */
-    populateComboboxes();
+        portForwardingRules << adapterCache.child(i).base();
+    m_pEditorNetworkFeatures->setPortForwardingRules(portForwardingRules);
+
+    /* Reload alternatives: */
+    reloadAlternatives();
     /* Reapply attachment info: */
     sltHandleAttachmentTypeChange();
@@ -402 +320 @@
         case KNetworkAttachmentType_Generic:
             newAdapterData.m_strGenericDriverName = m_pEditorAttachmentType->valueName(KNetworkAttachmentType_Generic);
-            newAdapterData.m_strGenericProperties = m_pEditorGenericProperties->toPlainText();
             break;
         case KNetworkAttachmentType_NATNetwork:
@@ -421 +338 @@
     }
 
-    /* Save adapter type: */
-    newAdapterData.m_adapterType = m_pComboAdapterType->currentData().value<KNetworkAdapterType>();
-
-    /* Save promiscuous mode type: */
-    newAdapterData.m_promiscuousMode = (KNetworkAdapterPromiscModePolicy)m_pComboPromiscuousMode->itemData(m_pComboPromiscuousMode->currentIndex()).toInt();
-
-    /* Other options: */
-    newAdapterData.m_strMACAddress = m_pEditorMAC->text().isEmpty() ? QString() : m_pEditorMAC->text();
-    newAdapterData.m_fCableConnected = m_pCheckBoxCableConnected->isChecked();
+    /* Save settings: */
+    newAdapterData.m_adapterType = m_pEditorNetworkFeatures->adapterType();
+    newAdapterData.m_promiscuousMode = m_pEditorNetworkFeatures->promiscuousMode();
+    newAdapterData.m_strMACAddress = m_pEditorNetworkFeatures->macAddress();
+    if (newAdapterData.m_attachmentType == KNetworkAttachmentType_Generic)
+        newAdapterData.m_strGenericProperties = m_pEditorNetworkFeatures->genericProperties();
+    newAdapterData.m_fCableConnected = m_pEditorNetworkFeatures->cableConnected();
 
     /* Save port forwarding rules: */
-    foreach (const UIDataPortForwardingRule &rule, m_portForwardingRules)
+    foreach (const UIDataPortForwardingRule &rule, m_pEditorNetworkFeatures->portForwardingRules())
         adapterCache.child(rule.name).cacheCurrentData(rule);
 
@@ -536 +451 @@
 
     /* Validate MAC-address length: */
-    if (m_pEditorMAC->text().size() < 12)
+    if (m_pEditorNetworkFeatures->macAddress().size() < 12)
     {
         message.second << tr("The MAC address must be 12 hexadecimal digits long.");
@@ -543 +458 @@
 
     /* Make sure MAC-address is unicast: */
-    if (m_pEditorMAC->text().size() >= 2)
+    if (m_pEditorNetworkFeatures->macAddress().size() >= 2)
     {
         QRegExp validator("^[0-9A-Fa-f][02468ACEace]");
-        if (validator.indexIn(m_pEditorMAC->text()) != 0)
+        if (validator.indexIn(m_pEditorNetworkFeatures->macAddress()) != 0)
         {
             message.second << tr("The second digit in the MAC address may not be odd as only unicast addresses are allowed.");
@@ -565 +480 @@
     setTabOrder(pAfter, m_pCheckBoxAdapter);
     setTabOrder(m_pCheckBoxAdapter, m_pEditorAttachmentType);
-    setTabOrder(m_pEditorAttachmentType, m_pButtonAdvanced);
-    setTabOrder(m_pButtonAdvanced, m_pComboAdapterType);
-    setTabOrder(m_pComboAdapterType, m_pComboPromiscuousMode);
-    setTabOrder(m_pComboPromiscuousMode, m_pEditorMAC);
-    setTabOrder(m_pEditorMAC, m_pButtonMAC);
-    setTabOrder(m_pButtonMAC, m_pEditorGenericProperties);
-    setTabOrder(m_pEditorGenericProperties, m_pCheckBoxCableConnected);
-    setTabOrder(m_pCheckBoxCableConnected, m_pButtonPortForwarding);
-    return m_pButtonPortForwarding;
+    setTabOrder(m_pEditorAttachmentType, m_pEditorNetworkFeatures);
+    return m_pEditorNetworkFeatures;
 }
 
@@ -597 +505 @@
     /* Basic attributes: */
     m_pCheckBoxAdapter->setEnabled(m_pParent->isMachineOffline());
-    m_pLabelAttachmentType->setEnabled(m_pParent->isMachineInValidMode());
     m_pEditorAttachmentType->setEnabled(m_pParent->isMachineInValidMode());
-    m_pLabelNetworkName->setEnabled(m_pParent->isMachineInValidMode() &&
-                                    attachmentType() != KNetworkAttachmentType_Null &&
-                                    attachmentType() != KNetworkAttachmentType_NAT);
-    m_pButtonAdvanced->setEnabled(m_pParent->isMachineInValidMode());
 
     /* Advanced attributes: */
-    m_pLabelAdapterType->setEnabled(m_pParent->isMachineOffline());
-    m_pComboAdapterType->setEnabled(m_pParent->isMachineOffline());
-    m_pLabelPromiscuousMode->setEnabled(m_pParent->isMachineInValidMode() &&
-                                        attachmentType() != KNetworkAttachmentType_Null &&
-                                        attachmentType() != KNetworkAttachmentType_Generic &&
-                                        attachmentType() != KNetworkAttachmentType_NAT);
-    m_pComboPromiscuousMode->setEnabled(m_pParent->isMachineInValidMode() &&
-                                        attachmentType() != KNetworkAttachmentType_Null &&
-                                        attachmentType() != KNetworkAttachmentType_Generic &&
-                                        attachmentType() != KNetworkAttachmentType_NAT);
-    m_pLabelMAC->setEnabled(m_pParent->isMachineOffline());
-    m_pEditorMAC->setEnabled(m_pParent->isMachineOffline());
-    m_pButtonMAC->setEnabled(m_pParent->isMachineOffline());
-    m_pLabelGenericProperties->setEnabled(m_pParent->isMachineInValidMode());
-    m_pEditorGenericProperties->setEnabled(m_pParent->isMachineInValidMode());
-    m_pCheckBoxCableConnected->setEnabled(m_pParent->isMachineInValidMode());
-    m_pButtonPortForwarding->setEnabled(m_pParent->isMachineInValidMode() &&
-                                        attachmentType() == KNetworkAttachmentType_NAT);
-
-    /* Postprocessing: */
-    handleAdvancedButtonStateChange();
+    m_pEditorNetworkFeatures->setAdvancedOptionsAvailable(m_pParent->isMachineInValidMode());
+    m_pEditorNetworkFeatures->setAdapterOptionsAvailable(m_pParent->isMachineOffline());
+    m_pEditorNetworkFeatures->setPromiscuousOptionsAvailable(   attachmentType() != KNetworkAttachmentType_Null
+                                                             && attachmentType() != KNetworkAttachmentType_Generic
+                                                             && attachmentType() != KNetworkAttachmentType_NAT);
+    m_pEditorNetworkFeatures->setMACOptionsAvailable(m_pParent->isMachineOffline());
+    m_pEditorNetworkFeatures->setGenericPropertiesAvailable(attachmentType() == KNetworkAttachmentType_Generic);
+    m_pEditorNetworkFeatures->setCableOptionsAvailable(m_pParent->isMachineInValidMode());
+    m_pEditorNetworkFeatures->setForwardingOptionsAvailable(attachmentType() == KNetworkAttachmentType_NAT);
 }
 
@@ -645 +536 @@
 void UIMachineSettingsNetwork::setAdvancedButtonState(bool fExpanded)
 {
-    /* Check whether the button state really changed: */
-    if (m_pButtonAdvanced->isExpanded() == fExpanded)
-        return;
-
-    /* Push the state to button and handle the state change: */
-    m_pButtonAdvanced->setExpanded(fExpanded);
-    handleAdvancedButtonStateChange();
+    m_pEditorNetworkFeatures->setAdvancedButtonExpanded(fExpanded);
 }
 
 void UIMachineSettingsNetwork::retranslateUi()
 {
-    int iFirstColumnWidth = 0;
-    m_pCheckBoxAdapter->setToolTip(tr("When checked, plugs this virtual network adapter into the virtual machine."));
-    m_pCheckBoxAdapter->setText(tr("&Enable Network Adapter"));
-    m_pLabelAttachmentType->setText(tr("&Attached to:"));
-    iFirstColumnWidth = qMax(iFirstColumnWidth, m_pLabelAttachmentType->minimumSizeHint().width());
-    m_pLabelNetworkName->setText(tr("&Name:"));
-    iFirstColumnWidth = qMax(iFirstColumnWidth, m_pLabelNetworkName->minimumSizeHint().width());
-    m_pButtonAdvanced->setText(tr("A&dvanced"));
-    m_pButtonAdvanced->setToolTip(tr("Shows additional network adapter options."));
-    m_pLabelAdapterType->setText(tr("Adapter &Type:"));
-    iFirstColumnWidth = qMax(iFirstColumnWidth, m_pLabelAdapterType->minimumSizeHint().width());
-    m_pComboAdapterType->setToolTip(tr("Selects the type of the virtual network adapter. Depending on this value, VirtualBox "
-                                       "will provide different network hardware to the virtual machine."));
-    m_pLabelPromiscuousMode->setText(tr("&Promiscuous Mode:"));
-    iFirstColumnWidth = qMax(iFirstColumnWidth, m_pLabelPromiscuousMode->minimumSizeHint().width());
-    m_pComboPromiscuousMode->setToolTip(tr("Selects the promiscuous mode policy of the network adapter when attached to an "
-                                           "internal network, host only network or a bridge."));
-    m_pLabelMAC->setText(tr("&MAC Address:"));
-    iFirstColumnWidth = qMax(iFirstColumnWidth, m_pLabelMAC->minimumSizeHint().width());
-    m_pEditorMAC->setToolTip(tr("Holds the MAC address of this adapter. It contains exactly 12 characters chosen from {0-9,A-F}. "
-                                "Note that the second character must be an even digit."));
-    m_pButtonMAC->setToolTip(tr("Generates a new random MAC address."));
-    m_pLabelGenericProperties->setText(tr("Generic Properties:"));
-    m_pEditorGenericProperties->setToolTip(tr("Holds the configuration settings for the network attachment driver. The settings "
-                                              "should be of the form <b>name=value</b> and will depend on the driver. "
-                                              "Use <b>shift-enter</b> to add a new entry."));
-    m_pCheckBoxCableConnected->setToolTip(tr("When checked, the virtual network cable is plugged in."));
-    m_pCheckBoxCableConnected->setText(tr("&Cable Connected"));
-    m_pButtonPortForwarding->setToolTip(tr("Displays a window to configure port forwarding rules."));
-    m_pButtonPortForwarding->setText(tr("&Port Forwarding"));
-
-    /* Translate combo-boxes content: */
-    populateComboboxes();
-
-    /* Translate attachment info: */
+    if (m_pCheckBoxAdapter)
+    {
+        m_pCheckBoxAdapter->setText(tr("&Enable Network Adapter"));
+        m_pCheckBoxAdapter->setToolTip(tr("When checked, plugs this virtual network adapter into the virtual machine."));
+    }
+
+    /* Reload alternatives: */
+    reloadAlternatives();
+    /* Reapply attachment info: */
     sltHandleAttachmentTypeChange();
-    /* Set the minimum width of the 1st column to size longest label to align all labels: */
-    m_pLayoutAdapterSettings->setColumnMinimumWidth(0, iFirstColumnWidth);
 }
 
@@ -703 +560 @@
     /* Generate a new MAC address in case this adapter was never enabled before: */
     if (   m_pCheckBoxAdapter->isChecked()
-        && m_pEditorMAC->text().isEmpty())
-        sltGenerateMac();
+        && m_pEditorNetworkFeatures->macAddress().isEmpty())
+        m_pEditorNetworkFeatures->generateMac();
 
     /* Revalidate: */
@@ -712 +569 @@
 void UIMachineSettingsNetwork::sltHandleAttachmentTypeChange()
 {
-    /* Update alternative-name combo-box availability: */
-    m_pLabelNetworkName->setEnabled(attachmentType() != KNetworkAttachmentType_Null &&
-                                    attachmentType() != KNetworkAttachmentType_NAT);
-    /* Update promiscuous-mode combo-box availability: */
-    m_pLabelPromiscuousMode->setEnabled(attachmentType() != KNetworkAttachmentType_Null &&
-                                        attachmentType() != KNetworkAttachmentType_Generic &&
-                                        attachmentType() != KNetworkAttachmentType_NAT);
-    m_pComboPromiscuousMode->setEnabled(attachmentType() != KNetworkAttachmentType_Null &&
-                                        attachmentType() != KNetworkAttachmentType_Generic &&
-                                        attachmentType() != KNetworkAttachmentType_NAT);
-    /* Update generic-properties editor visibility: */
-    m_pLabelGenericProperties->setVisible(attachmentType() == KNetworkAttachmentType_Generic &&
-                                          m_pButtonAdvanced->isExpanded());
-    m_pEditorGenericProperties->setVisible(attachmentType() == KNetworkAttachmentType_Generic &&
-                                             m_pButtonAdvanced->isExpanded());
-    /* Update forwarding rules button availability: */
-    m_pButtonPortForwarding->setEnabled(attachmentType() == KNetworkAttachmentType_NAT);
+    /* Advanced attributes: */
+    m_pEditorNetworkFeatures->setPromiscuousOptionsAvailable(   attachmentType() != KNetworkAttachmentType_Null
+                                                             && attachmentType() != KNetworkAttachmentType_Generic
+                                                             && attachmentType() != KNetworkAttachmentType_NAT);
+    m_pEditorNetworkFeatures->setGenericPropertiesAvailable(attachmentType() == KNetworkAttachmentType_Generic);
+    m_pEditorNetworkFeatures->setForwardingOptionsAvailable(attachmentType() == KNetworkAttachmentType_NAT);
 
     /* Revalidate: */
@@ -760 +606 @@
 }
 
-void UIMachineSettingsNetwork::sltHandleAdvancedButtonStateChange()
-{
-    /* Handle the button state change: */
-    handleAdvancedButtonStateChange();
-
-    /* Notify listeners about the button state change: */
-    emit sigNotifyAdvancedButtonStateChange(m_pButtonAdvanced->isExpanded());
-}
-
-void UIMachineSettingsNetwork::sltGenerateMac()
-{
-    m_pEditorMAC->setText(uiCommon().host().GenerateMACAddress());
-}
-
-void UIMachineSettingsNetwork::sltOpenPortForwardingDlg()
-{
-    UIMachineSettingsPortForwardingDlg dlg(this, m_portForwardingRules);
-    if (dlg.exec() == QDialog::Accepted)
-        m_portForwardingRules = dlg.rules();
-}
-
 void UIMachineSettingsNetwork::prepare()
 {
@@ -794 +619 @@
 {
     /* Prepare main layout: */
-    QGridLayout *pLayoutMain = new QGridLayout(this);
-    if (pLayoutMain)
-    {
-        pLayoutMain->setRowStretch(2, 1);
-
+    QGridLayout *pLayout = new QGridLayout(this);
+    if (pLayout)
+    {
         /* Prepare adapter check-box: */
         m_pCheckBoxAdapter = new QCheckBox(this);
         if (m_pCheckBoxAdapter)
-            pLayoutMain->addWidget(m_pCheckBoxAdapter, 0, 0, 1, 2);
+            pLayout->addWidget(m_pCheckBoxAdapter, 0, 0, 1, 2);
 
         /* Prepare 20-px shifting spacer: */
         QSpacerItem *pSpacerItem = new QSpacerItem(20, 0, QSizePolicy::Fixed, QSizePolicy::Minimum);
         if (pSpacerItem)
-            pLayoutMain->addItem(pSpacerItem, 1, 0);
+            pLayout->addItem(pSpacerItem, 1, 0);
 
         /* Prepare adapter settings widget: */
@@ -814 +637 @@
         {
             /* Prepare adapter settings widget layout: */
-            m_pLayoutAdapterSettings = new QGridLayout(m_pWidgetAdapterSettings);
-            if (m_pLayoutAdapterSettings)
-            {
-                m_pLayoutAdapterSettings->setContentsMargins(0, 0, 0, 0);
-                m_pLayoutAdapterSettings->setColumnStretch(2, 1);
-
-                /* Prepare attachment type label: */
-                m_pLabelAttachmentType = new QLabel(m_pWidgetAdapterSettings);
-                if (m_pLabelAttachmentType)
-                {
-                    m_pLabelAttachmentType->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-                    m_pLayoutAdapterSettings->addWidget(m_pLabelAttachmentType, 0, 0);
-                }
-                /* Prepare adapter name label: */
-                m_pLabelNetworkName = new QLabel(m_pWidgetAdapterSettings);
-                if (m_pLabelNetworkName)
-                {
-                    m_pLabelNetworkName->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-                    m_pLayoutAdapterSettings->addWidget(m_pLabelNetworkName, 1, 0);
-                }
+            QVBoxLayout *pLayoutAdapterSettings = new QVBoxLayout(m_pWidgetAdapterSettings);
+            if (pLayoutAdapterSettings)
+            {
+                pLayoutAdapterSettings->setContentsMargins(0, 0, 0, 0);
+
                 /* Prepare attachment type editor: */
-                m_pEditorAttachmentType = new UINetworkAttachmentEditor(m_pWidgetAdapterSettings);
+                m_pEditorAttachmentType = new UINetworkAttachmentEditor(m_pWidgetAdapterSettings, true);
                 if (m_pEditorAttachmentType)
-                {
-                    if (m_pLabelAttachmentType)
-                        m_pLabelAttachmentType->setBuddy(m_pEditorAttachmentType);
-                    if (m_pLabelNetworkName)
-                        m_pLabelNetworkName->setBuddy(m_pEditorAttachmentType);
-
-                    m_pLayoutAdapterSettings->addWidget(m_pEditorAttachmentType, 0, 1, 2, 3);
-                }
-
-                /* Prepare advanced arrow button: */
-                m_pButtonAdvanced = new QIArrowButtonSwitch(m_pWidgetAdapterSettings);
-                if (m_pButtonAdvanced)
-                {
-                    const QStyle *pStyle = QApplication::style();
-                    const int iIconMetric = (int)(pStyle->pixelMetric(QStyle::PM_SmallIconSize) * .625);
-                    m_pButtonAdvanced->setIconSize(QSize(iIconMetric, iIconMetric));
-                    m_pButtonAdvanced->setIcons(UIIconPool::iconSet(":/arrow_right_10px.png"),
-                                               UIIconPool::iconSet(":/arrow_down_10px.png"));
-
-                    m_pLayoutAdapterSettings->addWidget(m_pButtonAdvanced, 2, 0);
-                }
-
-                /* Create the container widget for advanced settings related widgets: */
-                m_pWidgetAdvancedSettings = new QWidget;
-                m_pLayoutAdapterSettings->addWidget(m_pWidgetAdvancedSettings, 3, 0, 4, 3, Qt::AlignLeft);
-                QGridLayout *pLayoutAdvancedSettings = new QGridLayout(m_pWidgetAdvancedSettings);
-                pLayoutAdvancedSettings->setContentsMargins(0, 0, 0, 0);
-                prepareAdvancedSettingsWidgets(pLayoutAdvancedSettings);
-           }
-
-            pLayoutMain->addWidget(m_pWidgetAdapterSettings, 1, 1);
+                    pLayoutAdapterSettings->addWidget(m_pEditorAttachmentType);
+
+                /* Prepare advanced settingseditor: */
+                m_pEditorNetworkFeatures = new UIMachineNetworkFeaturesEditor(m_pWidgetAdapterSettings);
+                if (m_pEditorNetworkFeatures)
+                    pLayoutAdapterSettings->addWidget(m_pEditorNetworkFeatures);
+
+                pLayoutAdapterSettings->addStretch();
+            }
+
+            pLayout->addWidget(m_pWidgetAdapterSettings, 1, 1);
         }
     }
@@ -874 +662 @@
 void UIMachineSettingsNetwork::prepareConnections()
 {
-    connect(m_pCheckBoxAdapter, &QCheckBox::toggled, this, &UIMachineSettingsNetwork::sltHandleAdapterActivityChange);
+    connect(m_pCheckBoxAdapter, &QCheckBox::toggled,
+            this, &UIMachineSettingsNetwork::sltHandleAdapterActivityChange);
     connect(m_pEditorAttachmentType, &UINetworkAttachmentEditor::sigValueTypeChanged,
             this, &UIMachineSettingsNetwork::sltHandleAttachmentTypeChange);
     connect(m_pEditorAttachmentType, &UINetworkAttachmentEditor::sigValueNameChanged,
             this, &UIMachineSettingsNetwork::sltHandleAlternativeNameChange);
-    connect(m_pButtonAdvanced, &QIArrowButtonSwitch::sigClicked, this, &UIMachineSettingsNetwork::sltHandleAdvancedButtonStateChange);
-    connect(m_pEditorMAC, &QILineEdit::textChanged, m_pParent, &UIMachineSettingsNetworkPage::revalidate);
-    connect(m_pButtonMAC, &QIToolButton::clicked, this, &UIMachineSettingsNetwork::sltGenerateMac);
-    connect(m_pButtonPortForwarding, &QPushButton::clicked, this, &UIMachineSettingsNetwork::sltOpenPortForwardingDlg);
-    connect(this, &UIMachineSettingsNetwork::sigTabUpdated, m_pParent, &UIMachineSettingsNetworkPage::sltHandleTabUpdate);
-}
-
-void UIMachineSettingsNetwork::prepareAdvancedSettingsWidgets(QGridLayout *pLayout)
-{
-    AssertPtrReturnVoid(pLayout);
-
-    /* Prepare adapter type label: */
-    m_pLabelAdapterType = new QLabel(m_pWidgetAdapterSettings);
-    if (m_pLabelAdapterType)
-    {
-        m_pLabelAdapterType->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-        pLayout->addWidget(m_pLabelAdapterType, 0, 0);
-    }
-    /* Prepare adapter type combo: */
-    m_pComboAdapterType = new QComboBox(m_pWidgetAdapterSettings);
-    if (m_pComboAdapterType)
-    {
-        if (m_pLabelAdapterType)
-            m_pLabelAdapterType->setBuddy(m_pComboAdapterType);
-        pLayout->addWidget(m_pComboAdapterType, 0, 1, 1, 3);
-    }
-
-    /* Prepare promiscuous mode label: */
-    m_pLabelPromiscuousMode = new QLabel(m_pWidgetAdapterSettings);
-    if (m_pLabelPromiscuousMode)
-    {
-        m_pLabelPromiscuousMode->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-        pLayout->addWidget(m_pLabelPromiscuousMode, 1, 0);
-    }
-    /* Prepare promiscuous mode combo: */
-    m_pComboPromiscuousMode = new QComboBox(m_pWidgetAdapterSettings);
-    if (m_pComboPromiscuousMode)
-    {
-        if (m_pLabelPromiscuousMode)
-            m_pLabelPromiscuousMode->setBuddy(m_pComboPromiscuousMode);
-        pLayout->addWidget(m_pComboPromiscuousMode, 1, 1, 1, 3);
-    }
-
-    /* Prepare MAC label: */
-    m_pLabelMAC = new QLabel(m_pWidgetAdapterSettings);
-    if (m_pLabelMAC)
-    {
-        m_pLabelMAC->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-        pLayout->addWidget(m_pLabelMAC, 2, 0);
-    }
-    /* Prepare MAC editor: */
-    m_pEditorMAC = new QILineEdit(m_pWidgetAdapterSettings);
-    if (m_pEditorMAC)
-    {
-        if (m_pLabelMAC)
-            m_pLabelMAC->setBuddy(m_pEditorMAC);
-        m_pEditorMAC->setAllowToCopyContentsWhenDisabled(true);
-        m_pEditorMAC->setValidator(new QRegularExpressionValidator(QRegularExpression("[0-9A-Fa-f]{12}"), this));
-        m_pEditorMAC->setMinimumWidthByText(QString().fill('0', 12));
-
-        pLayout->addWidget(m_pEditorMAC, 2, 1, 1, 2);
-    }
-    /* Prepare MAC button: */
-    m_pButtonMAC = new QIToolButton(m_pWidgetAdapterSettings);
-    if (m_pButtonMAC)
-    {
-        m_pButtonMAC->setIcon(UIIconPool::iconSet(":/refresh_16px.png"));
-        pLayout->addWidget(m_pButtonMAC, 2, 3);
-    }
-
-    /* Prepare MAC label: */
-    m_pLabelGenericProperties = new QLabel(m_pWidgetAdapterSettings);
-    if (m_pLabelGenericProperties)
-    {
-        m_pLabelGenericProperties->setAlignment(Qt::AlignRight | Qt::AlignTop);
-        pLayout->addWidget(m_pLabelGenericProperties, 3, 0);
-    }
-    /* Prepare MAC editor: */
-    m_pEditorGenericProperties = new QTextEdit(m_pWidgetAdapterSettings);
-    if (m_pEditorGenericProperties)
-        pLayout->addWidget(m_pEditorGenericProperties, 3, 1, 1, 3);
-
-    /* Prepare cable connected check-box: */
-    m_pCheckBoxCableConnected = new QCheckBox(m_pWidgetAdapterSettings);
-    if (m_pCheckBoxCableConnected)
-        pLayout->addWidget(m_pCheckBoxCableConnected, 4, 1, 1, 2);
-
-    /* Prepare port forwarding button: */
-    m_pButtonPortForwarding = new QPushButton(m_pWidgetAdapterSettings);
-    if (m_pButtonPortForwarding)
-        pLayout->addWidget(m_pButtonPortForwarding, 5, 1);
-}
-
-void UIMachineSettingsNetwork::populateComboboxes()
-{
-    /* Adapter names: */
-    {
-        reloadAlternatives();
-    }
-
-    /* Adapter type: */
-    {
-        /* Clear the adapter type combo-box: */
-        m_pComboAdapterType->clear();
-
-        /* Load currently supported network adapter types: */
-        CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
-        QVector<KNetworkAdapterType> supportedTypes = comProperties.GetSupportedNetworkAdapterTypes();
-        /* Take currently requested type into account if it's sane: */
-        if (!supportedTypes.contains(m_enmAdapterType) && m_enmAdapterType != KNetworkAdapterType_Null)
-            supportedTypes.prepend(m_enmAdapterType);
-
-        /* Populate adapter types: */
-        int iAdapterTypeIndex = 0;
-        foreach (const KNetworkAdapterType &enmType, supportedTypes)
-        {
-            m_pComboAdapterType->insertItem(iAdapterTypeIndex, gpConverter->toString(enmType));
-            m_pComboAdapterType->setItemData(iAdapterTypeIndex, QVariant::fromValue(enmType));
-            m_pComboAdapterType->setItemData(iAdapterTypeIndex, m_pComboAdapterType->itemText(iAdapterTypeIndex), Qt::ToolTipRole);
-            ++iAdapterTypeIndex;
-        }
-
-        /* Choose requested adapter type: */
-        const int iIndex = m_pComboAdapterType->findData(m_enmAdapterType);
-        m_pComboAdapterType->setCurrentIndex(iIndex != -1 ? iIndex : 0);
-    }
-
-    /* Promiscuous Mode type: */
-    {
-        /* Remember the currently selected promiscuous mode type: */
-        int iCurrentPromiscuousMode = m_pComboPromiscuousMode->currentIndex();
-
-        /* Clear the promiscuous mode combo-box: */
-        m_pComboPromiscuousMode->clear();
-
-        /* Populate promiscuous modes: */
-        int iPromiscuousModeIndex = 0;
-        m_pComboPromiscuousMode->insertItem(iPromiscuousModeIndex, gpConverter->toString(KNetworkAdapterPromiscModePolicy_Deny));
-        m_pComboPromiscuousMode->setItemData(iPromiscuousModeIndex, KNetworkAdapterPromiscModePolicy_Deny);
-        m_pComboPromiscuousMode->setItemData(iPromiscuousModeIndex, m_pComboPromiscuousMode->itemText(iPromiscuousModeIndex), Qt::ToolTipRole);
-        ++iPromiscuousModeIndex;
-        m_pComboPromiscuousMode->insertItem(iPromiscuousModeIndex, gpConverter->toString(KNetworkAdapterPromiscModePolicy_AllowNetwork));
-        m_pComboPromiscuousMode->setItemData(iPromiscuousModeIndex, KNetworkAdapterPromiscModePolicy_AllowNetwork);
-        m_pComboPromiscuousMode->setItemData(iPromiscuousModeIndex, m_pComboPromiscuousMode->itemText(iPromiscuousModeIndex), Qt::ToolTipRole);
-        ++iPromiscuousModeIndex;
-        m_pComboPromiscuousMode->insertItem(iPromiscuousModeIndex, gpConverter->toString(KNetworkAdapterPromiscModePolicy_AllowAll));
-        m_pComboPromiscuousMode->setItemData(iPromiscuousModeIndex, KNetworkAdapterPromiscModePolicy_AllowAll);
-        m_pComboPromiscuousMode->setItemData(iPromiscuousModeIndex, m_pComboPromiscuousMode->itemText(iPromiscuousModeIndex), Qt::ToolTipRole);
-        ++iPromiscuousModeIndex;
-
-        /* Restore the previously selected promiscuous mode type: */
-        m_pComboPromiscuousMode->setCurrentIndex(iCurrentPromiscuousMode == -1 ? 0 : iCurrentPromiscuousMode);
-    }
-}
-
-void UIMachineSettingsNetwork::handleAdvancedButtonStateChange()
-{
-    /* Update visibility of advanced options: */
-    m_pWidgetAdvancedSettings->setVisible(m_pButtonAdvanced->isExpanded());
-}
-
-/* static */
-int UIMachineSettingsNetwork::position(QComboBox *pComboBox, int iData)
-{
-    const int iPosition = pComboBox->findData(iData);
-    return iPosition == -1 ? 0 : iPosition;
-}
-
-/* static */
-int UIMachineSettingsNetwork::position(QComboBox *pComboBox, const QString &strText)
-{
-    const int iPosition = pComboBox->findText(strText);
-    return iPosition == -1 ? 0 : iPosition;
+    connect(m_pEditorNetworkFeatures, &UIMachineNetworkFeaturesEditor::sigNotifyAdvancedButtonStateChange,
+            this, &UIMachineSettingsNetwork::sigNotifyAdvancedButtonStateChange);
+    connect(m_pEditorNetworkFeatures, &UIMachineNetworkFeaturesEditor::sigMACAddressChanged,
+            m_pParent, &UIMachineSettingsNetworkPage::revalidate);
+    connect(this, &UIMachineSettingsNetwork::sigTabUpdated, m_pParent,
+            &UIMachineSettingsNetworkPage::sltHandleTabUpdate);
 }
 
@@ -1063 +685 @@
     , m_pCache(0)
 {
-    /* Prepare: */
     prepare();
 }
@@ -1069 +690 @@
 UIMachineSettingsNetworkPage::~UIMachineSettingsNetworkPage()
 {
-    /* Cleanup: */
     cleanup();
 }