Changeset 48458 in vbox

Timestamp:

Sep 12, 2013 4:26:07 PM (11 years ago)

Author:

vboxsync

Message:

FE/Qt: Global settings: Network page: 1. Full rework; 2. Added NAT network page with corresponding options.

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• Makefile.kmk (modified) (2 diffs)
• VBoxUI.pro (modified) (1 diff)
• src/globals/UIMessageCenter.cpp (modified) (2 diffs)
• src/globals/UIMessageCenter.h (modified) (1 diff)
• src/settings/global/UIGlobalSettingsNetwork.cpp (modified) (10 diffs)
• src/settings/global/UIGlobalSettingsNetwork.h (modified) (7 diffs)
• src/settings/global/UIGlobalSettingsNetwork.ui (modified) (2 diffs)
• src/settings/global/UIGlobalSettingsNetworkDetailsHost.cpp (moved) (moved from trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetails.cpp ) (7 diffs)
• src/settings/global/UIGlobalSettingsNetworkDetailsHost.h (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetails.h ) (3 diffs)
• src/settings/global/UIGlobalSettingsNetworkDetailsHost.ui (moved) (moved from trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetails.ui ) (3 diffs)
• src/settings/global/UIGlobalSettingsNetworkDetailsNAT.cpp (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetails.cpp ) (3 diffs)
• src/settings/global/UIGlobalSettingsNetworkDetailsNAT.h (moved) (moved from trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetails.h ) (3 diffs)
• src/settings/global/UIGlobalSettingsNetworkDetailsNAT.ui (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetails.ui ) (4 diffs)

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

@@ -351 +351 @@
         src/settings/global/UIGlobalSettingsDisplay.h \
         src/settings/global/UIGlobalSettingsNetwork.h \
-        src/settings/global/UIGlobalSettingsNetworkDetails.h \
+        src/settings/global/UIGlobalSettingsNetworkDetailsNAT.h \
+        src/settings/global/UIGlobalSettingsNetworkDetailsHost.h \
         src/settings/global/UIGlobalSettingsProxy.h \
         src/settings/global/UIGlobalSettingsUpdate.h \
@@ -604 +605 @@
         src/settings/global/UIGlobalSettingsDisplay.cpp \
         src/settings/global/UIGlobalSettingsNetwork.cpp \
-        src/settings/global/UIGlobalSettingsNetworkDetails.cpp \
+        src/settings/global/UIGlobalSettingsNetworkDetailsNAT.cpp \
+        src/settings/global/UIGlobalSettingsNetworkDetailsHost.cpp \
         src/settings/global/UIGlobalSettingsProxy.cpp \
         src/settings/global/UIGlobalSettingsUpdate.cpp \

trunk/src/VBox/Frontends/VirtualBox/VBoxUI.pro

@@ -34 +34 @@
     src/settings/global/UIGlobalSettingsDisplay.ui \
     src/settings/global/UIGlobalSettingsNetwork.ui \
-    src/settings/global/UIGlobalSettingsNetworkDetails.ui \
+    src/settings/global/UIGlobalSettingsNetworkDetailsNAT.ui \
+    src/settings/global/UIGlobalSettingsNetworkDetailsHost.ui \
     src/settings/global/UIGlobalSettingsExtension.ui \
     src/settings/global/UIGlobalSettingsProxy.ui \

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

@@ -884 +884 @@
 }
 
-bool UIMessageCenter::confirmHostInterfaceRemoval(const QString &strName, QWidget *pParent /*= 0*/) const
+bool UIMessageCenter::confirmNATNetworkRemoval(const QString &strName, QWidget *pParent /*= 0*/) const
+{
+    return questionBinary(pParent, MessageType_Question,
+                          tr("<p>Do you want to remove the NAT network <nobr><b>%1</b>?</nobr></p>"
+                             "<p><b>Note:</b> this network may be in use by one or more "
+                             "virtual network adapters belonging to one of your VMs. "
+                             "After it is removed, these adapters will no longer be usable until "
+                             "you correct their settings by either choosing a different network "
+                             "name or a different adapter attachment type.</p>")
+                             .arg(strName),
+                          0 /* auto-confirm id */,
+                          tr("Remove"));
+}
+
+bool UIMessageCenter::confirmHostOnlyInterfaceRemoval(const QString &strName, QWidget *pParent /*= 0*/) const
 {
     return questionBinary(pParent, MessageType_Question,
@@ -898 +912 @@
                           0 /* auto-confirm id */,
                           tr("Remove"));
+}
+
+void UIMessageCenter::cannotCreateNATNetwork(const CVirtualBox &vbox, QWidget *pParent /*= 0*/)
+{
+    error(pParent, MessageType_Error,
+          tr("Failed to create NAT network."),
+          formatErrorInfo(vbox));
+}
+
+void UIMessageCenter::cannotRemoveNATNetwork(const CVirtualBox &vbox, const QString &strNetworkName, QWidget *pParent /*= 0*/)
+{
+    error(pParent, MessageType_Error,
+          tr("Failed to remove NAT network <b>%1</b>.")
+             .arg(strNetworkName),
+          formatErrorInfo(vbox));
+}
+
+void UIMessageCenter::cannotCreateDHCPServer(const CVirtualBox &vbox, QWidget *pParent /*= 0*/)
+{
+    error(pParent, MessageType_Error,
+          tr("Failed to create DHCP server."),
+          formatErrorInfo(vbox));
+}
+
+void UIMessageCenter::cannotRemoveDHCPServer(const CVirtualBox &vbox, const QString &strInterfaceName, QWidget *pParent /*= 0*/)
+{
+    error(pParent, MessageType_Error,
+          tr("Failed to remove DHCP server for network interface <b>%1</b>.")
+             .arg(strInterfaceName),
+          formatErrorInfo(vbox));
 }
 

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

@@ -211 +211 @@
 
     /* API: Global settings warnings: */
-    bool confirmHostInterfaceRemoval(const QString &strName, QWidget *pParent = 0) const;
+    bool confirmNATNetworkRemoval(const QString &strName, QWidget *pParent = 0) const;
+    bool confirmHostOnlyInterfaceRemoval(const QString &strName, QWidget *pParent = 0) const;
+    void cannotCreateNATNetwork(const CVirtualBox &vbox, QWidget *pParent = 0);
+    void cannotRemoveNATNetwork(const CVirtualBox &vbox, const QString &strNetworkName, QWidget *pParent = 0);
+    void cannotCreateDHCPServer(const CVirtualBox &vbox, QWidget *pParent = 0);
+    void cannotRemoveDHCPServer(const CVirtualBox &vbox, const QString &strInterfaceName, QWidget *pParent = 0);
     void cannotCreateHostInterface(const CHost &host, QWidget *pParent = 0);
     void cannotCreateHostInterface(const CProgress &progress, QWidget *pParent = 0);

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetwork.cpp

@@ -7 +7 @@
 
 /*
- * Copyright (C) 2009-2012 Oracle Corporation
+ * Copyright (C) 2009-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -23 +23 @@
 
 /* GUI includes: */
-#include "QIWidgetValidator.h"
+#include "VBoxGlobal.h"
 #include "UIIconPool.h"
+#include "UIMessageCenter.h"
 #include "UIGlobalSettingsNetwork.h"
-#include "UIGlobalSettingsNetworkDetails.h"
-#include "VBoxGlobal.h"
-#include "UIMessageCenter.h"
+#include "UIGlobalSettingsNetworkDetailsNAT.h"
+#include "UIGlobalSettingsNetworkDetailsHost.h"
 
 /* COM includes: */
+#include "CNATNetwork.h"
 #include "CHostNetworkInterface.h"
 #include "CDHCPServer.h"
 
-/* Host-network item constructor: */
-UIHostInterfaceItem::UIHostInterfaceItem()
+/* Other VBox includes: */
+#include "iprt/cidr.h"
+
+
+/* Global settings / Network page / NAT network item: */
+class UIItemNetworkNAT : public QTreeWidgetItem
+{
+public:
+
+    /* Constructor: */
+    UIItemNetworkNAT();
+
+    /* API: Get/return data to/form items: */
+    void fetchNetworkData(const UIDataNetworkNAT &data);
+    void uploadNetworkData(UIDataNetworkNAT &data);
+
+    /* API: Validation stuff: */
+    bool validate(UIValidationMessage &message);
+
+    /* API: Update stuff: */
+    void updateInfo();
+
+    /* API: Network item getters: */
+    QString name() const { return m_data.m_strName; }
+    QString newName() const { return m_data.m_strNewName; }
+
+private:
+
+    /* Variable: Network data: */
+    UIDataNetworkNAT m_data;
+};
+
+
+/* Global settings / Network page / Host network item: */
+class UIItemNetworkHost : public QTreeWidgetItem
+{
+public:
+
+    /* Constructor: */
+    UIItemNetworkHost();
+
+    /* API: Get/return data to/form items: */
+    void fetchNetworkData(const UIDataNetworkHost &data);
+    void uploadNetworkData(UIDataNetworkHost &data);
+
+    /* API: Validation stuff: */
+    bool validate(UIValidationMessage &message);
+
+    /* API: Update stuff: */
+    void updateInfo();
+
+    /* API: Network item getters: */
+    QString name() const { return m_data.m_interface.m_strName; }
+
+private:
+
+    /* Variable: Network data: */
+    UIDataNetworkHost m_data;
+};
+
+
+UIItemNetworkNAT::UIItemNetworkNAT()
     : QTreeWidgetItem()
 {
 }
 
-/* Get data to item: */
-void UIHostInterfaceItem::fetchNetworkData(const UIHostNetworkData &data)
-{
-    /* Fetch from cache: */
+void UIItemNetworkNAT::fetchNetworkData(const UIDataNetworkNAT &data)
+{
+    /* Get from cache: */
     m_data = data;
 
-    /* Update tool-tip: */
+    /* Fetch info: */
     updateInfo();
 }
 
-/* Return data from item: */
-void UIHostInterfaceItem::uploadNetworkData(UIHostNetworkData &data)
-{
-    /* Upload to cache: */
+void UIItemNetworkNAT::uploadNetworkData(UIDataNetworkNAT &data)
+{
+    /* Put to cache: */
     data = m_data;
 }
 
-/* Validation stuff: */
-bool UIHostInterfaceItem::validate(QList<UIValidationMessage> &messages)
+bool UIItemNetworkNAT::validate(UIValidationMessage &message)
 {
     /* Pass by default: */
     bool fPass = true;
 
-    /* Prepare message: */
-    UIValidationMessage message;
-
-    /* Host-only interface validation: */
+    /* NAT network name validation: */
+    bool fNameValid = true;
+    if (m_data.m_strNewName.isEmpty())
+    {
+        /* Emptiness validation: */
+        message.second << UIGlobalSettingsNetwork::tr("The new name for NAT network previously called <b>%1</b> is empty.").arg(m_data.m_strName);
+        fNameValid = false;
+        fPass = false;
+    }
+
+    /* NAT network CIDR validation: */
+    if (m_data.m_strCIDR.isEmpty())
+    {
+        /* Emptiness validation: */
+        if (fNameValid)
+            message.second << UIGlobalSettingsNetwork::tr("The CIDR for NAT network <b>%1</b> is empty.").arg(m_data.m_strNewName);
+        else
+            message.second << UIGlobalSettingsNetwork::tr("The CIDR for NAT network previously called <b>%1</b> is empty.").arg(m_data.m_strName);
+        fPass = false;
+    }
+    else
+    {
+        /* Correctness validation: */
+        RTNETADDRIPV4 network, mask;
+        int rc = RTCidrStrToIPv4(m_data.m_strCIDR.toAscii().constData(), &network, &mask);
+        if (RT_FAILURE(rc))
+        {
+            if (fNameValid)
+                message.second << UIGlobalSettingsNetwork::tr("The CIDR <i>%1</i> for NAT network <b>%2</b> is invalid.")
+                                                              .arg(m_data.m_strCIDR, m_data.m_strNewName);
+            else
+                message.second << UIGlobalSettingsNetwork::tr("The CIDR <i>%1</i> for NAT network previously called <b>%2</b> is invalid.")
+                                                              .arg(m_data.m_strCIDR, m_data.m_strName);
+            fPass = false;
+        }
+    }
+
+    /* Return result: */
+    return fPass;
+}
+
+void UIItemNetworkNAT::updateInfo()
+{
+    /* Compose item name/tool-tip: */
+    QString strHeader("<tr><td><nobr>%1:&nbsp;</nobr></td><td><nobr>%2</nobr></td></tr>");
+    QString strSubHeader("<tr><td><nobr>&nbsp;&nbsp;%1:&nbsp;</nobr></td><td><nobr>%2</nobr></td></tr>");
+    QString strToolTip;
+
+    /* Item name was not changed: */
+    if (m_data.m_strNewName == m_data.m_strName)
+    {
+        /* Just use the old one: */
+        setText(0, m_data.m_strName);
+        strToolTip += strHeader.arg(UIGlobalSettingsNetwork::tr("Network Name"), m_data.m_strName);
+    }
+    /* If name was changed: */
+    else
+    {
+        /* We should explain that: */
+        const QString oldName = m_data.m_strName;
+        const QString newName = m_data.m_strNewName.isEmpty() ? UIGlobalSettingsNetwork::tr("[empty]") : m_data.m_strNewName;
+        setText(0, UIGlobalSettingsNetwork::tr("%1 (renamed from %2)").arg(newName, oldName));
+        strToolTip += strHeader.arg(UIGlobalSettingsNetwork::tr("Old Network Name"), m_data.m_strName);
+        strToolTip += strHeader.arg(UIGlobalSettingsNetwork::tr("New Network Name"), m_data.m_strNewName);
+    }
+
+    /* Other tool-tip information: */
+    strToolTip += strHeader.arg(UIGlobalSettingsNetwork::tr("Network CIDR"), m_data.m_strCIDR);
+    strToolTip += strHeader.arg(UIGlobalSettingsNetwork::tr("Supports DHCP"),
+                                m_data.m_fSupportsDHCP ? UIGlobalSettingsNetwork::tr("yes") : UIGlobalSettingsNetwork::tr("no"));
+    strToolTip += strHeader.arg(UIGlobalSettingsNetwork::tr("Supports IPv6"),
+                                m_data.m_fSupportsIPv6 ? UIGlobalSettingsNetwork::tr("yes") : UIGlobalSettingsNetwork::tr("no"));
+    if (m_data.m_fSupportsIPv6 && m_data.m_fAdvertiseDefaultIPv6Route)
+        strToolTip += strSubHeader.arg(UIGlobalSettingsNetwork::tr("Default IPv6 route"), UIGlobalSettingsNetwork::tr("yes"));
+
+    /* Assign tool-tip finally: */
+    setToolTip(0, strToolTip);
+}
+
+
+UIItemNetworkHost::UIItemNetworkHost()
+    : QTreeWidgetItem()
+{
+}
+
+void UIItemNetworkHost::fetchNetworkData(const UIDataNetworkHost &data)
+{
+    /* Get from cache: */
+    m_data = data;
+
+    /* Fetch info: */
+    updateInfo();
+}
+
+void UIItemNetworkHost::uploadNetworkData(UIDataNetworkHost &data)
+{
+    /* Put to cache: */
+    data = m_data;
+}
+
+bool UIItemNetworkHost::validate(UIValidationMessage &message)
+{
+    /* Pass by default: */
+    bool fPass = true;
+
+    /* Host interface validation: */
     if (!m_data.m_interface.m_fDhcpClientEnabled)
     {
@@ -124 +284 @@
     }
 
-    /* Serialize message: */
-    if (!message.second.isEmpty())
-        messages << message;
-
     /* Return result: */
     return fPass;
 }
 
-QString UIHostInterfaceItem::updateInfo()
-{
-    /* Update text: */
+void UIItemNetworkHost::updateInfo()
+{
+    /* Compose item name/tool-tip: */
     setText(0, m_data.m_interface.m_strName);
-
-    /* Update information label: */
     QString strHeader("<tr><td><nobr>%1:&nbsp;</nobr></td><td><nobr>%2</nobr></td></tr>");
     QString strSubHeader("<tr><td><nobr>&nbsp;&nbsp;%1:&nbsp;</nobr></td><td><nobr>%2</nobr></td></tr>");
-    QString strData, strToolTip, strBuffer;
-
-    /* Host-only interface information: */
-    strBuffer = strHeader.arg(UIGlobalSettingsNetwork::tr("Adapter"))
-                .arg(m_data.m_interface.m_fDhcpClientEnabled ? UIGlobalSettingsNetwork::tr("Automatically configured", "interface")
-                                                             : UIGlobalSettingsNetwork::tr("Manually configured", "interface"));
-    strData += strBuffer;
-    strToolTip += strBuffer;
+    QString strToolTip;
+
+    /* Host interface information: */
+    strToolTip += strHeader.arg(UIGlobalSettingsNetwork::tr("Adapter"))
+                           .arg(m_data.m_interface.m_fDhcpClientEnabled ?
+                                UIGlobalSettingsNetwork::tr("Automatically configured", "interface") :
+                                UIGlobalSettingsNetwork::tr("Manually configured", "interface"));
     if (!m_data.m_interface.m_fDhcpClientEnabled)
     {
-        strBuffer = strSubHeader.arg(UIGlobalSettingsNetwork::tr("IPv4 Address"))
-                                .arg(m_data.m_interface.m_strInterfaceAddress.isEmpty() ?
-                                     UIGlobalSettingsNetwork::tr ("Not set", "address") :
-                                     m_data.m_interface.m_strInterfaceAddress) +
-                    strSubHeader.arg(UIGlobalSettingsNetwork::tr("IPv4 Network Mask"))
-                                .arg(m_data.m_interface.m_strInterfaceMask.isEmpty() ?
-                                     UIGlobalSettingsNetwork::tr ("Not set", "mask") :
-                                     m_data.m_interface.m_strInterfaceMask);
-        strToolTip += strBuffer;
+        strToolTip += strSubHeader.arg(UIGlobalSettingsNetwork::tr("IPv4 Address"))
+                                  .arg(m_data.m_interface.m_strInterfaceAddress.isEmpty() ?
+                                       UIGlobalSettingsNetwork::tr ("Not set", "address") :
+                                       m_data.m_interface.m_strInterfaceAddress) +
+                      strSubHeader.arg(UIGlobalSettingsNetwork::tr("IPv4 Network Mask"))
+                                  .arg(m_data.m_interface.m_strInterfaceMask.isEmpty() ?
+                                       UIGlobalSettingsNetwork::tr ("Not set", "mask") :
+                                       m_data.m_interface.m_strInterfaceMask);
         if (m_data.m_interface.m_fIpv6Supported)
         {
-            strBuffer = strSubHeader.arg(UIGlobalSettingsNetwork::tr("IPv6 Address"))
-                                    .arg(m_data.m_interface.m_strInterfaceAddress6.isEmpty() ?
-                                         UIGlobalSettingsNetwork::tr("Not set", "address") :
-                                         m_data.m_interface.m_strInterfaceAddress6) +
-                        strSubHeader.arg(UIGlobalSettingsNetwork::tr("IPv6 Network Mask Length"))
-                                    .arg(m_data.m_interface.m_strInterfaceMaskLength6.isEmpty() ?
-                                         UIGlobalSettingsNetwork::tr("Not set", "length") :
-                                         m_data.m_interface.m_strInterfaceMaskLength6);
-            strToolTip += strBuffer;
+            strToolTip += strSubHeader.arg(UIGlobalSettingsNetwork::tr("IPv6 Address"))
+                                      .arg(m_data.m_interface.m_strInterfaceAddress6.isEmpty() ?
+                                           UIGlobalSettingsNetwork::tr("Not set", "address") :
+                                           m_data.m_interface.m_strInterfaceAddress6) +
+                          strSubHeader.arg(UIGlobalSettingsNetwork::tr("IPv6 Network Mask Length"))
+                                      .arg(m_data.m_interface.m_strInterfaceMaskLength6.isEmpty() ?
+                                           UIGlobalSettingsNetwork::tr("Not set", "length") :
+                                           m_data.m_interface.m_strInterfaceMaskLength6);
         }
     }
 
     /* DHCP server information: */
-    strBuffer = strHeader.arg(UIGlobalSettingsNetwork::tr("DHCP Server"))
-                         .arg(m_data.m_dhcpserver.m_fDhcpServerEnabled ?
-                              UIGlobalSettingsNetwork::tr("Enabled", "server") :
-                              UIGlobalSettingsNetwork::tr("Disabled", "server"));
-    strData += strBuffer;
-    strToolTip += strBuffer;
+    strToolTip += strHeader.arg(UIGlobalSettingsNetwork::tr("DHCP Server"))
+                           .arg(m_data.m_dhcpserver.m_fDhcpServerEnabled ?
+                                UIGlobalSettingsNetwork::tr("Enabled", "server") :
+                                UIGlobalSettingsNetwork::tr("Disabled", "server"));
     if (m_data.m_dhcpserver.m_fDhcpServerEnabled)
     {
-        strBuffer = strSubHeader.arg(UIGlobalSettingsNetwork::tr("Address"))
-                                .arg(m_data.m_dhcpserver.m_strDhcpServerAddress.isEmpty() ?
-                                     UIGlobalSettingsNetwork::tr("Not set", "address") :
-                                     m_data.m_dhcpserver.m_strDhcpServerAddress) +
-                    strSubHeader.arg(UIGlobalSettingsNetwork::tr("Network Mask"))
-                                .arg(m_data.m_dhcpserver.m_strDhcpServerMask.isEmpty() ?
-                                     UIGlobalSettingsNetwork::tr("Not set", "mask") :
-                                     m_data.m_dhcpserver.m_strDhcpServerMask) +
-                    strSubHeader.arg(UIGlobalSettingsNetwork::tr("Lower Bound"))
-                                .arg(m_data.m_dhcpserver.m_strDhcpLowerAddress.isEmpty() ?
-                                     UIGlobalSettingsNetwork::tr("Not set", "bound") :
-                                     m_data.m_dhcpserver.m_strDhcpLowerAddress) +
-                    strSubHeader.arg(UIGlobalSettingsNetwork::tr("Upper Bound"))
-                                .arg(m_data.m_dhcpserver.m_strDhcpUpperAddress.isEmpty() ?
-                                     UIGlobalSettingsNetwork::tr("Not set", "bound") :
-                                     m_data.m_dhcpserver.m_strDhcpUpperAddress);
-        strToolTip += strBuffer;
-    }
-
+        strToolTip += strSubHeader.arg(UIGlobalSettingsNetwork::tr("Address"))
+                                  .arg(m_data.m_dhcpserver.m_strDhcpServerAddress.isEmpty() ?
+                                       UIGlobalSettingsNetwork::tr("Not set", "address") :
+                                       m_data.m_dhcpserver.m_strDhcpServerAddress) +
+                      strSubHeader.arg(UIGlobalSettingsNetwork::tr("Network Mask"))
+                                  .arg(m_data.m_dhcpserver.m_strDhcpServerMask.isEmpty() ?
+                                       UIGlobalSettingsNetwork::tr("Not set", "mask") :
+                                       m_data.m_dhcpserver.m_strDhcpServerMask) +
+                      strSubHeader.arg(UIGlobalSettingsNetwork::tr("Lower Bound"))
+                                  .arg(m_data.m_dhcpserver.m_strDhcpLowerAddress.isEmpty() ?
+                                       UIGlobalSettingsNetwork::tr("Not set", "bound") :
+                                       m_data.m_dhcpserver.m_strDhcpLowerAddress) +
+                      strSubHeader.arg(UIGlobalSettingsNetwork::tr("Upper Bound"))
+                                  .arg(m_data.m_dhcpserver.m_strDhcpUpperAddress.isEmpty() ?
+                                       UIGlobalSettingsNetwork::tr("Not set", "bound") :
+                                       m_data.m_dhcpserver.m_strDhcpUpperAddress);
+    }
+
+    /* Assign tool-tip finally: */
     setToolTip(0, strToolTip);
-
-    return QString("<table>") + strData + QString("</table>");
-}
-
-/* Network page constructor: */
+}
+
+
 UIGlobalSettingsNetwork::UIGlobalSettingsNetwork()
-    : m_pAddAction(0), m_pDelAction(0), m_pEditAction(0)
+    : m_pActionAddNetworkNAT(0), m_pActionDelNetworkNAT(0), m_pActionEditNetworkNAT(0)
+    , m_pActionAddNetworkHost(0), m_pActionDelNetworkHost(0), m_pActionEditNetworkHost(0)
     , m_fChanged(false)
 {
     /* Apply UI decorations: */
-    Ui::UIGlobalSettingsNetwork::setupUi (this);
-
-    /* Setup tree-widget: */
-    m_pInterfacesTree->header()->hide();
-    m_pInterfacesTree->setContextMenuPolicy(Qt::CustomContextMenu);
-
-    /* Prepare toolbar: */
-    m_pAddAction = new QAction(m_pInterfacesTree);
-    m_pDelAction = new QAction(m_pInterfacesTree);
-    m_pEditAction = new QAction(m_pInterfacesTree);
-
-    m_pAddAction->setShortcuts(QList<QKeySequence>() << QKeySequence("Ins") << QKeySequence("Ctrl+N"));
-    m_pDelAction->setShortcuts(QList<QKeySequence>() << QKeySequence("Del") << QKeySequence("Ctrl+R"));
-    m_pEditAction->setShortcuts(QList<QKeySequence>() << QKeySequence("Space") << QKeySequence("F2"));
-
-    m_pAddAction->setIcon(UIIconPool::iconSet(":/add_host_iface_16px.png",
-                                              ":/add_host_iface_disabled_16px.png"));
-    m_pDelAction->setIcon(UIIconPool::iconSet(":/remove_host_iface_16px.png",
-                                              ":/remove_host_iface_disabled_16px.png"));
-    m_pEditAction->setIcon(UIIconPool::iconSet(":/guesttools_16px.png",
-                                               ":/guesttools_disabled_16px.png"));
-
-    m_pActionsToolbar->setUsesTextLabel(false);
-    m_pActionsToolbar->setIconSize(QSize(16, 16));
-    m_pActionsToolbar->setOrientation(Qt::Vertical);
-    m_pActionsToolbar->addAction(m_pAddAction);
-    m_pActionsToolbar->addAction(m_pDelAction);
-    m_pActionsToolbar->addAction(m_pEditAction);
-
-    /* Setup connections: */
-    connect(m_pAddAction, SIGNAL(triggered(bool)), this, SLOT(sltAddInterface()));
-    connect(m_pDelAction, SIGNAL(triggered(bool)), this, SLOT(sltDelInterface()));
-    connect(m_pEditAction, SIGNAL(triggered(bool)), this, SLOT(sltEditInterface()));
-    connect(m_pInterfacesTree, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)),
-            this, SLOT(sltUpdateCurrentItem()));
-    connect(m_pInterfacesTree, SIGNAL(customContextMenuRequested(const QPoint&)),
-            this, SLOT(sltChowContextMenu(const QPoint&)));
-    connect(m_pInterfacesTree, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)),
-            this, SLOT(sltEditInterface()));
+    Ui::UIGlobalSettingsNetwork::setupUi(this);
+
+    /* Prepare NAT network tree-widget: */
+    {
+        m_pTreeNetworkNAT->header()->hide();
+        m_pTreeNetworkNAT->setContextMenuPolicy(Qt::CustomContextMenu);
+        connect(m_pTreeNetworkNAT, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)),
+                this, SLOT(sltHandleCurrentItemChangeNetworkNAT()));
+        connect(m_pTreeNetworkNAT, SIGNAL(customContextMenuRequested(const QPoint&)),
+                this, SLOT(sltShowContextMenuNetworkNAT(const QPoint&)));
+        connect(m_pTreeNetworkNAT, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)),
+                this, SLOT(sltEditNetworkNAT()));
+    }
+    /* Prepare Host network tree-widget: */
+    {
+        m_pTreeNetworkHost->header()->hide();
+        m_pTreeNetworkHost->setContextMenuPolicy(Qt::CustomContextMenu);
+        connect(m_pTreeNetworkHost, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)),
+                this, SLOT(sltHandleCurrentItemChangeNetworkHost()));
+        connect(m_pTreeNetworkHost, SIGNAL(customContextMenuRequested(const QPoint&)),
+                this, SLOT(sltShowContextMenuNetworkHost(const QPoint&)));
+        connect(m_pTreeNetworkHost, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)),
+                this, SLOT(sltEditNetworkHost()));
+    }
+
+    /* Prepare actions: */
+    m_pActionAddNetworkNAT = new QAction(m_pTreeNetworkNAT);
+    {
+        m_pActionAddNetworkNAT->setShortcutContext(Qt::WidgetWithChildrenShortcut);
+        m_pActionAddNetworkNAT->setShortcuts(QList<QKeySequence>() << QKeySequence("Ins") << QKeySequence("Ctrl+N"));
+        m_pActionAddNetworkNAT->setIcon(UIIconPool::iconSet(":/add_host_iface_16px.png",
+                                                            ":/add_host_iface_disabled_16px.png"));
+        connect(m_pActionAddNetworkNAT, SIGNAL(triggered(bool)), this, SLOT(sltAddNetworkNAT()));
+    }
+    m_pActionDelNetworkNAT = new QAction(m_pTreeNetworkNAT);
+    {
+        m_pActionDelNetworkNAT->setShortcutContext(Qt::WidgetWithChildrenShortcut);
+        m_pActionDelNetworkNAT->setShortcuts(QList<QKeySequence>() << QKeySequence("Del") << QKeySequence("Ctrl+R"));
+        m_pActionDelNetworkNAT->setIcon(UIIconPool::iconSet(":/remove_host_iface_16px.png",
+                                                            ":/remove_host_iface_disabled_16px.png"));
+        connect(m_pActionDelNetworkNAT, SIGNAL(triggered(bool)), this, SLOT(sltDelNetworkNAT()));
+    }
+    m_pActionEditNetworkNAT = new QAction(m_pTreeNetworkNAT);
+    {
+        m_pActionEditNetworkNAT->setShortcutContext(Qt::WidgetWithChildrenShortcut);
+        m_pActionEditNetworkNAT->setShortcuts(QList<QKeySequence>() << QKeySequence("Space") << QKeySequence("F2"));
+        m_pActionEditNetworkNAT->setIcon(UIIconPool::iconSet(":/guesttools_16px.png",
+                                                             ":/guesttools_disabled_16px.png"));
+        connect(m_pActionEditNetworkNAT, SIGNAL(triggered(bool)), this, SLOT(sltEditNetworkNAT()));
+    }
+    m_pActionAddNetworkHost = new QAction(m_pTreeNetworkHost);
+    {
+        m_pActionAddNetworkHost->setShortcutContext(Qt::WidgetWithChildrenShortcut);
+        m_pActionAddNetworkHost->setShortcuts(QList<QKeySequence>() << QKeySequence("Ins") << QKeySequence("Ctrl+N"));
+        m_pActionAddNetworkHost->setIcon(UIIconPool::iconSet(":/add_host_iface_16px.png",
+                                                             ":/add_host_iface_disabled_16px.png"));
+        connect(m_pActionAddNetworkHost, SIGNAL(triggered(bool)), this, SLOT(sltAddNetworkHost()));
+    }
+    m_pActionDelNetworkHost = new QAction(m_pTreeNetworkHost);
+    {
+        m_pActionDelNetworkHost->setShortcutContext(Qt::WidgetWithChildrenShortcut);
+        m_pActionDelNetworkHost->setShortcuts(QList<QKeySequence>() << QKeySequence("Del") << QKeySequence("Ctrl+R"));
+        m_pActionDelNetworkHost->setIcon(UIIconPool::iconSet(":/remove_host_iface_16px.png",
+                                                             ":/remove_host_iface_disabled_16px.png"));
+        connect(m_pActionDelNetworkHost, SIGNAL(triggered(bool)), this, SLOT(sltDelNetworkHost()));
+    }
+    m_pActionEditNetworkHost = new QAction(m_pTreeNetworkHost);
+    {
+        m_pActionEditNetworkHost->setShortcutContext(Qt::WidgetWithChildrenShortcut);
+        m_pActionEditNetworkHost->setShortcuts(QList<QKeySequence>() << QKeySequence("Space") << QKeySequence("F2"));
+        m_pActionEditNetworkHost->setIcon(UIIconPool::iconSet(":/guesttools_16px.png",
+                                                              ":/guesttools_disabled_16px.png"));
+        connect(m_pActionEditNetworkHost, SIGNAL(triggered(bool)), this, SLOT(sltEditNetworkHost()));
+    }
+
+    /* Prepare NAT network toolbar: */
+    {
+        m_pToolbarNetworkNAT->setUsesTextLabel(false);
+        m_pToolbarNetworkNAT->setIconSize(QSize(16, 16));
+        m_pToolbarNetworkNAT->setOrientation(Qt::Vertical);
+        m_pToolbarNetworkNAT->addAction(m_pActionAddNetworkNAT);
+        m_pToolbarNetworkNAT->addAction(m_pActionDelNetworkNAT);
+        m_pToolbarNetworkNAT->addAction(m_pActionEditNetworkNAT);
+    }
+    /* Prepare Host network toolbar: */
+    {
+        m_pToolbarNetworkHost->setUsesTextLabel(false);
+        m_pToolbarNetworkHost->setIconSize(QSize(16, 16));
+        m_pToolbarNetworkHost->setOrientation(Qt::Vertical);
+        m_pToolbarNetworkHost->addAction(m_pActionAddNetworkHost);
+        m_pToolbarNetworkHost->addAction(m_pActionDelNetworkHost);
+        m_pToolbarNetworkHost->addAction(m_pActionEditNetworkHost);
+    }
 
     /* Apply language settings: */
@@ -256 +458 @@
 }
 
-/* Load data to cache from corresponding external object(s),
- * this task COULD be performed in other than GUI thread: */
 void UIGlobalSettingsNetwork::loadToCacheFrom(QVariant &data)
 {
@@ -263 +463 @@
     UISettingsPageGlobal::fetchData(data);
 
-    /* Load to cache: */
+    /* Load NAT networks to cache: */
+    m_cache.m_networksNAT.clear();
+    const CNATNetworkVector &networks = vboxGlobal().virtualBox().GetNATNetworks();
+    foreach (const CNATNetwork &network, networks)
+        m_cache.m_networksNAT << generateDataNetworkNAT(network);
+
+    /* Load Host networks to cache: */
+    m_cache.m_networksHost.clear();
     const CHostNetworkInterfaceVector &interfaces = vboxGlobal().host().GetNetworkInterfaces();
-    for (int iNetworkIndex = 0; iNetworkIndex < interfaces.size(); ++iNetworkIndex)
-    {
-        const CHostNetworkInterface &iface = interfaces[iNetworkIndex];
+    foreach (const CHostNetworkInterface &iface, interfaces)
         if (iface.GetInterfaceType() == KHostNetworkInterfaceType_HostOnly)
-            appendCacheItem(iface);
-    }
+            m_cache.m_networksHost << generateDataNetworkHost(iface);
 
     /* Upload properties & settings to data: */
@@ -276 +480 @@
 }
 
-/* Load data to corresponding widgets from cache,
- * this task SHOULD be performed in GUI thread only: */
 void UIGlobalSettingsNetwork::getFromCache()
 {
-    /* Fetch from cache: */
-    for (int iNetworkIndex = 0; iNetworkIndex < m_cache.m_items.size(); ++iNetworkIndex)
-        appendListItem(m_cache.m_items[iNetworkIndex]);
-    /* Set first list item as current: */
-    m_pInterfacesTree->setCurrentItem(m_pInterfacesTree->topLevelItem(0));
-    sltUpdateCurrentItem();
+    /* Fetch NAT networks from cache: */
+    foreach (const UIDataNetworkNAT &network, m_cache.m_networksNAT)
+        createTreeItemNetworkNAT(network);
+    m_pTreeNetworkNAT->setCurrentItem(m_pTreeNetworkNAT->topLevelItem(0));
+    sltHandleCurrentItemChangeNetworkNAT();
+
+    /* Fetch Host networks from cache: */
+    foreach (const UIDataNetworkHost &network, m_cache.m_networksHost)
+        createTreeItemNetworkHost(network);
+    m_pTreeNetworkHost->setCurrentItem(m_pTreeNetworkHost->topLevelItem(0));
+    sltHandleCurrentItemChangeNetworkHost();
 
     /* Revalidate: */
@@ -291 +498 @@
 }
 
-/* Save data from corresponding widgets to cache,
- * this task SHOULD be performed in GUI thread only: */
 void UIGlobalSettingsNetwork::putToCache()
 {
-    /* Eraze cache: */
-    m_cache.m_items.clear();
-    /* Upload to cache: */
-    for (int iNetworkIndex = 0; iNetworkIndex < m_pInterfacesTree->topLevelItemCount(); ++iNetworkIndex)
-    {
-        UIHostNetworkData data;
-        UIHostInterfaceItem *pItem = static_cast<UIHostInterfaceItem*>(m_pInterfacesTree->topLevelItem(iNetworkIndex));
+    /* Upload NAT networks to cache: */
+    m_cache.m_networksNAT.clear();
+    for (int iNetworkIndex = 0; iNetworkIndex < m_pTreeNetworkNAT->topLevelItemCount(); ++iNetworkIndex)
+    {
+        UIDataNetworkNAT data;
+        UIItemNetworkNAT *pItem = static_cast<UIItemNetworkNAT*>(m_pTreeNetworkNAT->topLevelItem(iNetworkIndex));
         pItem->uploadNetworkData(data);
-        m_cache.m_items << data;
-    }
-}
-
-/* Save data from cache to corresponding external object(s),
- * this task COULD be performed in other than GUI thread: */
+        m_cache.m_networksNAT << data;
+    }
+
+    /* Upload Host networks to cache: */
+    m_cache.m_networksHost.clear();
+    for (int iNetworkIndex = 0; iNetworkIndex < m_pTreeNetworkHost->topLevelItemCount(); ++iNetworkIndex)
+    {
+        UIDataNetworkHost data;
+        UIItemNetworkHost *pItem = static_cast<UIItemNetworkHost*>(m_pTreeNetworkHost->topLevelItem(iNetworkIndex));
+        pItem->uploadNetworkData(data);
+        m_cache.m_networksHost << data;
+    }
+}
+
 void UIGlobalSettingsNetwork::saveFromCacheTo(QVariant &data)
 {
@@ -318 +530 @@
     UISettingsPageGlobal::fetchData(data);
 
+    /* Save NAT networks from cache: */
+    foreach (const UIDataNetworkNAT &data, m_cache.m_networksNAT)
+        saveCacheItemNetworkNAT(data);
+
+    /* Save Host networks from cache: */
+    foreach (const UIDataNetworkHost &data, m_cache.m_networksHost)
+        saveCacheItemNetworkHost(data);
+
+    /* Upload properties & settings to data: */
+    UISettingsPageGlobal::uploadData(data);
+}
+
+bool UIGlobalSettingsNetwork::validate(QList<UIValidationMessage> &messages)
+{
+    /* Pass by default: */
+    bool fPass = true;
+
+    /* Validate NAT network items: */
+    {
+        /* Prepare message: */
+        UIValidationMessage message;
+        message.first = VBoxGlobal::removeAccelMark(m_pTabWidget->tabText(0));
+
+        /* Validate items first: */
+        for (int iNetworkIndex = 0; iNetworkIndex < m_pTreeNetworkNAT->topLevelItemCount(); ++iNetworkIndex)
+        {
+            UIItemNetworkNAT *pItem = static_cast<UIItemNetworkNAT*>(m_pTreeNetworkNAT->topLevelItem(iNetworkIndex));
+            if (!pItem->validate(message))
+                fPass = false;
+        }
+
+        /* And make sure item names are unique: */
+        QList<QString> names;
+        for (int iItemIndex = 0; iItemIndex < m_pTreeNetworkNAT->topLevelItemCount(); ++iItemIndex)
+        {
+            UIItemNetworkNAT *pItem = static_cast<UIItemNetworkNAT*>(m_pTreeNetworkNAT->topLevelItem(iItemIndex));
+            const QString strItemName(pItem->newName());
+            if (strItemName.isEmpty())
+                continue;
+            if (!names.contains(strItemName))
+                names << strItemName;
+            else
+            {
+                message.second << UIGlobalSettingsNetwork::tr("The name <b>%1</b> for NAT network on position <b>%2</b> is already in use.")
+                                                              .arg(strItemName).arg(iItemIndex + 1);
+                fPass = false;
+            }
+        }
+
+        /* Serialize message: */
+        if (!message.second.isEmpty())
+            messages << message;
+    }
+
+    /* Validate Host network items: */
+    {
+        /* Prepare message: */
+        UIValidationMessage message;
+        message.first = VBoxGlobal::removeAccelMark(m_pTabWidget->tabText(1));
+
+        /* Validate items only: */
+        for (int iNetworkIndex = 0; iNetworkIndex < m_pTreeNetworkHost->topLevelItemCount(); ++iNetworkIndex)
+        {
+            UIItemNetworkHost *pItem = static_cast<UIItemNetworkHost*>(m_pTreeNetworkHost->topLevelItem(iNetworkIndex));
+            if (!pItem->validate(message))
+                fPass = false;
+        }
+
+        /* Serialize message: */
+        if (!message.second.isEmpty())
+            messages << message;
+    }
+
+    /* Return result: */
+    return fPass;
+}
+
+void UIGlobalSettingsNetwork::setOrderAfter(QWidget *pWidget)
+{
+    setTabOrder(pWidget, m_pTabWidget->focusProxy());
+    setTabOrder(m_pTabWidget->focusProxy(), m_pTreeNetworkNAT);
+    setTabOrder(m_pTreeNetworkNAT, m_pTreeNetworkHost);
+}
+
+void UIGlobalSettingsNetwork::retranslateUi()
+{
+    /* Translate uic generated strings: */
+    Ui::UIGlobalSettingsNetwork::retranslateUi(this);
+
+    /* NAT network actions: */
+    {
+        /* Translate text: */
+        m_pActionAddNetworkNAT->setText(tr("&Add NAT network"));
+        m_pActionDelNetworkNAT->setText(tr("&Remove NAT network"));
+        m_pActionEditNetworkNAT->setText(tr("&Edit NAT network"));
+
+        /* Recompose tool-tips: */
+        m_pActionAddNetworkNAT->setToolTip(m_pActionAddNetworkNAT->text().remove('&') +
+            QString(" (%1)").arg(m_pActionAddNetworkNAT->shortcut().toString()));
+        m_pActionDelNetworkNAT->setToolTip(m_pActionDelNetworkNAT->text().remove('&') +
+            QString(" (%1)").arg(m_pActionDelNetworkNAT->shortcut().toString()));
+        m_pActionEditNetworkNAT->setToolTip(m_pActionEditNetworkNAT->text().remove('&') +
+            QString(" (%1)").arg(m_pActionEditNetworkNAT->shortcut().toString()));
+    }
+
+    /* Host network actions: */
+    {
+        /* Translate text: */
+        m_pActionAddNetworkHost->setText(tr("&Add host-only network"));
+        m_pActionDelNetworkHost->setText(tr("&Remove host-only network"));
+        m_pActionEditNetworkHost->setText(tr("&Edit host-only network"));
+
+        /* Recompose tool-tips: */
+        m_pActionAddNetworkHost->setToolTip(m_pActionAddNetworkHost->text().remove('&') +
+            QString(" (%1)").arg(m_pActionAddNetworkHost->shortcut().toString()));
+        m_pActionDelNetworkHost->setToolTip(m_pActionDelNetworkHost->text().remove('&') +
+            QString(" (%1)").arg(m_pActionDelNetworkHost->shortcut().toString()));
+        m_pActionEditNetworkHost->setToolTip(m_pActionEditNetworkHost->text().remove('&') +
+            QString(" (%1)").arg(m_pActionEditNetworkHost->shortcut().toString()));
+    }
+}
+
+void UIGlobalSettingsNetwork::sltAddNetworkNAT()
+{
+    /* Prepare useful variables: */
+    CVirtualBox vbox = vboxGlobal().virtualBox();
+
+    /* Compose a pool of busy names: */
+    QList<QString> names;
+    for (int iItemIndex = 0; iItemIndex < m_pTreeNetworkNAT->topLevelItemCount(); ++iItemIndex)
+    {
+        UIItemNetworkNAT *pItem = static_cast<UIItemNetworkNAT*>(m_pTreeNetworkNAT->topLevelItem(iItemIndex));
+        if (!names.contains(pItem->name()))
+            names << pItem->name();
+    }
+    /* Search for the name with maximum index: */
+    int iMaximumIndex = -1;
+    const QString strNameTemplate("NatNetwork%1");
+    foreach (const QString &strName, names)
+    {
+        QRegExp regExp(strNameTemplate.arg("([\\d]*)"));
+        if (regExp.indexIn(strName) != -1)
+            iMaximumIndex = qMax(iMaximumIndex, regExp.cap(1).toInt());
+    }
+
+    /* Create NAT network: */
+    QString strIndex(iMaximumIndex == -1 ? QString() : QString::number(iMaximumIndex + 1));
+    CNATNetwork network = vbox.CreateNATNetwork(strNameTemplate.arg(strIndex));
+    if (!vbox.isOk())
+        return msgCenter().cannotCreateNATNetwork(vbox, this);
+    AssertReturnVoid(!network.isNull());
+
+    /* Update tree: */
+    createTreeItemNetworkNAT(generateDataNetworkNAT(network), true);
+}
+
+void UIGlobalSettingsNetwork::sltDelNetworkNAT()
+{
+    /* Get network item: */
+    UIItemNetworkNAT *pItem = static_cast<UIItemNetworkNAT*>(m_pTreeNetworkNAT->currentItem());
+    AssertMsg(pItem, ("Current item should present!\n"));
+    /* Get network name: */
+    const QString strNetworkName(pItem->name());
+
+    /* Confirm NAT network removal: */
+    if (!msgCenter().confirmNATNetworkRemoval(strNetworkName, this))
+        return;
+
+    /* Prepare useful variables: */
+    CVirtualBox vbox = vboxGlobal().virtualBox();
+
+    /* Find corresponding interface: */
+    const CNATNetwork &network = vbox.FindNATNetworkByName(strNetworkName);
+    AssertReturnVoid(vbox.isOk() && !network.isNull());
+
+    /* Remove NAT network: */
+    vbox.RemoveNATNetwork(network);
+    if (!vbox.isOk())
+        return msgCenter().cannotRemoveNATNetwork(vbox, strNetworkName, this);
+
+    /* Update tree: */
+    removeTreeItemNetworkNAT(pItem);
+}
+
+void UIGlobalSettingsNetwork::sltEditNetworkNAT()
+{
+    /* Get network item: */
+    UIItemNetworkNAT *pItem = static_cast<UIItemNetworkNAT*>(m_pTreeNetworkNAT->currentItem());
+    AssertMsg(pItem, ("Current item should present!\n"));
+
+    /* Edit current item data: */
+    UIDataNetworkNAT data;
+    pItem->uploadNetworkData(data);
+    UIGlobalSettingsNetworkDetailsNAT details(this, data);
+    if (details.exec() == QDialog::Accepted)
+    {
+        /* Put data back: */
+        pItem->fetchNetworkData(data);
+        sltHandleCurrentItemChangeNetworkNAT();
+        m_fChanged = true;
+        /* Revalidate: */
+        revalidate();
+    }
+}
+
+void UIGlobalSettingsNetwork::sltAddNetworkHost()
+{
     /* Prepare useful variables: */
     CVirtualBox vbox = vboxGlobal().virtualBox();
     CHost host = vboxGlobal().host();
 
-    /* Update all the host-only interfaces: */
-    for (int iNetworkIndex = 0; iNetworkIndex < m_cache.m_items.size(); ++iNetworkIndex)
-    {
-        /* Get iterated data: */
-        const UIHostNetworkData &data = m_cache.m_items[iNetworkIndex];
-        /* Find corresponding interface: */
-        CHostNetworkInterface iface = host.FindHostNetworkInterfaceByName(data.m_interface.m_strName);
-        if (!iface.isNull())
-        {
-            /* Host-only interface configuring: */
-            if (data.m_interface.m_fDhcpClientEnabled)
-            {
-                iface.EnableDynamicIPConfig();
-            }
-            else
-            {
-                AssertMsg(data.m_interface.m_strInterfaceAddress.isEmpty() ||
-                          QHostAddress(data.m_interface.m_strInterfaceAddress).protocol() == QAbstractSocket::IPv4Protocol,
-                          ("Interface IPv4 address must be empty or IPv4-valid!\n"));
-                AssertMsg(data.m_interface.m_strInterfaceMask.isEmpty() ||
-                          QHostAddress(data.m_interface.m_strInterfaceMask).protocol() == QAbstractSocket::IPv4Protocol,
-                          ("Interface IPv4 network mask must be empty or IPv4-valid!\n"));
-                iface.EnableStaticIPConfig(data.m_interface.m_strInterfaceAddress, data.m_interface.m_strInterfaceMask);
-                if (iface.GetIPV6Supported())
-                {
-                    AssertMsg(data.m_interface.m_strInterfaceAddress6.isEmpty() ||
-                              QHostAddress(data.m_interface.m_strInterfaceAddress6).protocol() == QAbstractSocket::IPv6Protocol,
-                              ("Interface IPv6 address must be empty or IPv6-valid!\n"));
-                    iface.EnableStaticIPConfigV6(data.m_interface.m_strInterfaceAddress6, data.m_interface.m_strInterfaceMaskLength6.toULong());
-                }
-            }
-
-            /* Find corresponding DHCP server: */
-            CDHCPServer dhcp = vbox.FindDHCPServerByNetworkName(iface.GetNetworkName());
-            if (!dhcp.isNull())
-            {
-                /* DHCP server configuring: */
-                dhcp.SetEnabled(data.m_dhcpserver.m_fDhcpServerEnabled);
-                AssertMsg(QHostAddress(data.m_dhcpserver.m_strDhcpServerAddress).protocol() == QAbstractSocket::IPv4Protocol,
-                          ("DHCP server IPv4 address must be IPv4-valid!\n"));
-                AssertMsg(QHostAddress(data.m_dhcpserver.m_strDhcpServerMask).protocol() == QAbstractSocket::IPv4Protocol,
-                          ("DHCP server IPv4 network mask must be IPv4-valid!\n"));
-                AssertMsg(QHostAddress(data.m_dhcpserver.m_strDhcpLowerAddress).protocol() == QAbstractSocket::IPv4Protocol,
-                          ("DHCP server IPv4 lower bound must be IPv4-valid!\n"));
-                AssertMsg(QHostAddress(data.m_dhcpserver.m_strDhcpUpperAddress).protocol() == QAbstractSocket::IPv4Protocol,
-                          ("DHCP server IPv4 upper bound must be IPv4-valid!\n"));
-                if (QHostAddress(data.m_dhcpserver.m_strDhcpServerAddress).protocol() == QAbstractSocket::IPv4Protocol &&
-                    QHostAddress(data.m_dhcpserver.m_strDhcpServerMask).protocol() == QAbstractSocket::IPv4Protocol &&
-                    QHostAddress(data.m_dhcpserver.m_strDhcpLowerAddress).protocol() == QAbstractSocket::IPv4Protocol &&
-                    QHostAddress(data.m_dhcpserver.m_strDhcpUpperAddress).protocol() == QAbstractSocket::IPv4Protocol)
-                    dhcp.SetConfiguration(data.m_dhcpserver.m_strDhcpServerAddress, data.m_dhcpserver.m_strDhcpServerMask,
-                                          data.m_dhcpserver.m_strDhcpLowerAddress, data.m_dhcpserver.m_strDhcpUpperAddress);
-            }
-        }
-    }
-
-    /* Upload properties & settings to data: */
-    UISettingsPageGlobal::uploadData(data);
-}
-
-/* Validation processing: */
-bool UIGlobalSettingsNetwork::validate(QList<UIValidationMessage> &messages)
-{
-    /* Redirect validation to items: */
-    UIHostInterfaceItem *pItem = static_cast<UIHostInterfaceItem*>(m_pInterfacesTree->currentItem());
-    return pItem ? pItem->validate(messages) : true;
-}
-
-/* Navigation stuff: */
-void UIGlobalSettingsNetwork::setOrderAfter(QWidget *pWidget)
-{
-    setTabOrder(pWidget, m_pInterfacesTree);
-}
-
-/* Translation stuff: */
-void UIGlobalSettingsNetwork::retranslateUi()
-{
-    /* Translate uic generated strings: */
-    Ui::UIGlobalSettingsNetwork::retranslateUi(this);
-
-    /* Translate action tool-tips: */
-    m_pAddAction->setText(tr("&Add host-only network"));
-    m_pDelAction->setText(tr("&Remove host-only network"));
-    m_pEditAction->setText(tr("&Edit host-only network"));
-
-    /* Assign tool-tips: */
-    m_pAddAction->setToolTip(m_pAddAction->text().remove('&') +
-        QString(" (%1)").arg(m_pAddAction->shortcut().toString()));
-    m_pDelAction->setToolTip(m_pDelAction->text().remove('&') +
-        QString(" (%1)").arg(m_pDelAction->shortcut().toString()));
-    m_pEditAction->setToolTip(m_pEditAction->text().remove('&') +
-        QString(" (%1)").arg(m_pEditAction->shortcut().toString()));
-}
-
-/* Adds new network interface: */
-void UIGlobalSettingsNetwork::sltAddInterface()
-{
+    /* Create Host interface: */
+    CHostNetworkInterface iface;
+    CProgress progress = host.CreateHostOnlyNetworkInterface(iface);
+    if (!host.isOk())
+        return msgCenter().cannotCreateHostInterface(host, this);
+    msgCenter().showModalProgressDialog(progress, tr("Networking"), ":/nw_32px.png", this, 0); // TODO: Change icon!
+    if (!progress.isOk() || progress.GetResultCode() != 0)
+        return msgCenter().cannotCreateHostInterface(progress, this);
+
+    /* Make sure DHCP server is created too: */
+    CDHCPServer dhcp = vbox.FindDHCPServerByNetworkName(iface.GetNetworkName());
+    if (dhcp.isNull())
+    {
+        vbox.CreateDHCPServer(iface.GetNetworkName());
+        if (!vbox.isOk())
+            return msgCenter().cannotCreateDHCPServer(vbox, this);
+        dhcp = vbox.FindDHCPServerByNetworkName(iface.GetNetworkName());
+    }
+    AssertReturnVoid(!dhcp.isNull());
+
+    /* Update tree: */
+    createTreeItemNetworkHost(generateDataNetworkHost(iface), true);
+}
+
+void UIGlobalSettingsNetwork::sltDelNetworkHost()
+{
+    /* Get network item: */
+    UIItemNetworkHost *pItem = static_cast<UIItemNetworkHost*>(m_pTreeNetworkHost->currentItem());
+    AssertMsg(pItem, ("Current item should present!\n"));
+    /* Get interface name: */
+    const QString strInterfaceName(pItem->name());
+
+    /* Confirm Host network removal: */
+    if (!msgCenter().confirmHostOnlyInterfaceRemoval(strInterfaceName, this))
+        return;
+
     /* Prepare useful variables: */
     CVirtualBox vbox = vboxGlobal().virtualBox();
     CHost host = vboxGlobal().host();
 
-    /* Create new host-only interface: */
-    CHostNetworkInterface iface;
-    CProgress progress = host.CreateHostOnlyNetworkInterface(iface);
-    if (host.isOk())
-    {
-        msgCenter().showModalProgressDialog(progress, tr("Networking"), ":/nw_32px.png", this, 0);
-        if (progress.isOk() && progress.GetResultCode() == 0)
-        {
-            /* Create DHCP server: */
-            CDHCPServer dhcp = vbox.FindDHCPServerByNetworkName(iface.GetNetworkName());
-            if (dhcp.isNull())
-            {
-                vbox.CreateDHCPServer(iface.GetNetworkName());
-                dhcp = vbox.FindDHCPServerByNetworkName(iface.GetNetworkName());
-            }
-            AssertMsg(!dhcp.isNull(), ("DHCP server creation failed!\n"));
-            /* Append cache with new item: */
-            appendCacheItem(iface);
-            /* Append list with new item: */
-            appendListItem(m_cache.m_items.last(), true);
-        }
-        else
-            msgCenter().cannotCreateHostInterface(progress, this);
-    }
-    else
-        msgCenter().cannotCreateHostInterface(host, this);
-}
-
-/* Removes selected network interface: */
-void UIGlobalSettingsNetwork::sltDelInterface()
-{
-    /* Get interface item: */
-    UIHostInterfaceItem *pItem = static_cast<UIHostInterfaceItem*>(m_pInterfacesTree->currentItem());
-    AssertMsg(pItem, ("Current item should present!\n"));
-    /* Get interface name: */
-    QString strInterfaceName(pItem->name());
-    /* Asking user about deleting selected network interface: */
-    if (!msgCenter().confirmHostInterfaceRemoval(strInterfaceName, this))
-        return;
-
-    /* Prepare useful variables: */
-    CVirtualBox vbox = vboxGlobal().virtualBox();
-    CHost host = vboxGlobal().host();
-
     /* Find corresponding interface: */
     const CHostNetworkInterface &iface = host.FindHostNetworkInterfaceByName(strInterfaceName);
-
-    /* Remove DHCP server first: */
-    CDHCPServer dhcp = vboxGlobal().virtualBox().FindDHCPServerByNetworkName(iface.GetNetworkName());
-    if (!dhcp.isNull())
+    AssertReturnVoid(host.isOk() && !iface.isNull());
+
+    /* Remove DHCP server if any: */
+    CDHCPServer dhcp = vbox.FindDHCPServerByNetworkName(iface.GetNetworkName());
+    if (vbox.isOk() && !dhcp.isNull())
+    {
         vbox.RemoveDHCPServer(dhcp);
+        if (!vbox.isOk())
+            return msgCenter().cannotRemoveDHCPServer(vbox, strInterfaceName, this);
+    }
 
     /* Remove interface finally: */
     CProgress progress = host.RemoveHostOnlyNetworkInterface(iface.GetId());
-    if (host.isOk())
-    {
-        msgCenter().showModalProgressDialog(progress, tr("Networking"), ":/nw_32px.png", this, 0);
-        if (progress.isOk() && progress.GetResultCode() == 0)
-        {
-            /* Remove list item: */
-            removeListItem(pItem);
-            /* Remove cache item: */
-            removeCacheItem(strInterfaceName);
-        }
-        else
-            msgCenter().cannotRemoveHostInterface(progress, strInterfaceName, this);
-    }
-    else
-        msgCenter().cannotRemoveHostInterface(host, strInterfaceName, this);
-}
-
-/* Edits selected network interface: */
-void UIGlobalSettingsNetwork::sltEditInterface()
-{
-    /* Check interface presence */
-    UIHostInterfaceItem *pItem = static_cast<UIHostInterfaceItem*>(m_pInterfacesTree->currentItem());
-    AssertMsg(pItem, ("Current item should be selected!\n"));
-    /* Edit current item data */
-    UIGlobalSettingsNetworkDetails details(this);
-    details.getFromItem(pItem);
+    if (!host.isOk())
+        return msgCenter().cannotRemoveHostInterface(host, strInterfaceName, this);
+    msgCenter().showModalProgressDialog(progress, tr("Networking"), ":/nw_32px.png", this, 0); // TODO: Change icon!
+    if (!progress.isOk() || progress.GetResultCode() != 0)
+        return msgCenter().cannotRemoveHostInterface(progress, strInterfaceName, this);
+
+    /* Update tree: */
+    removeTreeItemNetworkHost(pItem);
+}
+
+void UIGlobalSettingsNetwork::sltEditNetworkHost()
+{
+    /* Get network item: */
+    UIItemNetworkHost *pItem = static_cast<UIItemNetworkHost*>(m_pTreeNetworkHost->currentItem());
+    AssertMsg(pItem, ("Current item should present!\n"));
+
+    /* Edit current item data: */
+    UIDataNetworkHost data;
+    pItem->uploadNetworkData(data);
+    UIGlobalSettingsNetworkDetailsHost details(this, data);
     if (details.exec() == QDialog::Accepted)
     {
-        details.putBackToItem();
-        pItem->updateInfo();
-        sltUpdateCurrentItem();
+        /* Put data back: */
+        pItem->fetchNetworkData(data);
+        sltHandleCurrentItemChangeNetworkHost();
         m_fChanged = true;
-
         /* Revalidate: */
         revalidate();
@@ -515 +827 @@
 }
 
-/* Update current network interface data relations: */
-void UIGlobalSettingsNetwork::sltUpdateCurrentItem()
+void UIGlobalSettingsNetwork::sltHandleCurrentItemChangeNetworkNAT()
 {
     /* Get current item: */
-    UIHostInterfaceItem *pItem = static_cast<UIHostInterfaceItem*>(m_pInterfacesTree->currentItem());
+    UIItemNetworkNAT *pItem = static_cast<UIItemNetworkNAT*>(m_pTreeNetworkNAT->currentItem());
     /* Update availability: */
-    m_pDelAction->setEnabled(pItem);
-    m_pEditAction->setEnabled(pItem);
-}
-
-/* Show network interface context-menu: */
-void UIGlobalSettingsNetwork::sltChowContextMenu(const QPoint &pos)
-{
+    m_pActionDelNetworkNAT->setEnabled(pItem);
+    m_pActionEditNetworkNAT->setEnabled(pItem);
+}
+
+void UIGlobalSettingsNetwork::sltHandleCurrentItemChangeNetworkHost()
+{
+    /* Get current item: */
+    UIItemNetworkHost *pItem = static_cast<UIItemNetworkHost*>(m_pTreeNetworkHost->currentItem());
+    /* Update availability: */
+    m_pActionDelNetworkHost->setEnabled(pItem);
+    m_pActionEditNetworkHost->setEnabled(pItem);
+}
+
+void UIGlobalSettingsNetwork::sltShowContextMenuNetworkNAT(const QPoint &pos)
+{
+    /* Compose temporary context-menu: */
     QMenu menu;
-    if (m_pInterfacesTree->itemAt(pos))
-    {
-        menu.addAction(m_pEditAction);
-        menu.addAction(m_pDelAction);
+    if (m_pTreeNetworkNAT->itemAt(pos))
+    {
+        menu.addAction(m_pActionEditNetworkNAT);
+        menu.addAction(m_pActionDelNetworkNAT);
     }
     else
     {
-        menu.addAction(m_pAddAction);
-    }
-    menu.exec(m_pInterfacesTree->mapToGlobal(pos));
-}
-
-void UIGlobalSettingsNetwork::appendCacheItem(const CHostNetworkInterface &iface)
-{
+        menu.addAction(m_pActionAddNetworkNAT);
+    }
+    /* And show it: */
+    menu.exec(m_pTreeNetworkNAT->mapToGlobal(pos));
+}
+
+void UIGlobalSettingsNetwork::sltShowContextMenuNetworkHost(const QPoint &pos)
+{
+    /* Compose temporary context-menu: */
+    QMenu menu;
+    if (m_pTreeNetworkHost->itemAt(pos))
+    {
+        menu.addAction(m_pActionEditNetworkHost);
+        menu.addAction(m_pActionDelNetworkHost);
+    }
+    else
+    {
+        menu.addAction(m_pActionAddNetworkHost);
+    }
+    /* And show it: */
+    menu.exec(m_pTreeNetworkHost->mapToGlobal(pos));
+}
+
+UIDataNetworkNAT UIGlobalSettingsNetwork::generateDataNetworkNAT(const CNATNetwork &network)
+{
+    /* Prepare data: */
+    UIDataNetworkNAT data;
+
+    /* Load NAT network settings: */
+    data.m_fEnabled = network.GetEnabled();
+    data.m_strName = network.GetNetworkName();
+    data.m_strNewName = data.m_strName;
+    data.m_strCIDR = network.GetNetwork();
+    data.m_fSupportsDHCP = network.GetNeedDhcpServer();
+    data.m_fSupportsIPv6 = network.GetIPv6Enabled();
+    data.m_fAdvertiseDefaultIPv6Route = network.GetAdvertiseDefaultIPv6RouteEnabled();
+
+    /* Return data: */
+    return data;
+}
+
+void UIGlobalSettingsNetwork::saveCacheItemNetworkNAT(const UIDataNetworkNAT &data)
+{
+    /* Make sure corresponding NAT network exists: */
+    CVirtualBox vbox = vboxGlobal().virtualBox();
+    CNATNetwork network = vbox.FindNATNetworkByName(data.m_strName);
+    AssertReturnVoid(vbox.isOk() && !network.isNull());
+
+    /* Save NAT network options: */
+    network.SetEnabled(data.m_fEnabled);
+    network.SetNetworkName(data.m_strNewName);
+    network.SetNetwork(data.m_strCIDR);
+    network.SetNeedDhcpServer(data.m_fSupportsDHCP);
+    network.SetIPv6Enabled(data.m_fSupportsIPv6);
+    network.SetAdvertiseDefaultIPv6RouteEnabled(data.m_fAdvertiseDefaultIPv6Route);
+}
+
+void UIGlobalSettingsNetwork::createTreeItemNetworkNAT(const UIDataNetworkNAT &data, bool fChooseItem)
+{
+    /* Add new item to the tree: */
+    UIItemNetworkNAT *pItem = new UIItemNetworkNAT;
+    pItem->fetchNetworkData(data);
+    m_pTreeNetworkNAT->addTopLevelItem(pItem);
+    /* And choose it as current if necessary: */
+    if (fChooseItem)
+        m_pTreeNetworkNAT->setCurrentItem(pItem);
+}
+
+void UIGlobalSettingsNetwork::removeTreeItemNetworkNAT(UIItemNetworkNAT *pItem)
+{
+    /* Delete passed item: */
+    delete pItem;
+}
+
+UIDataNetworkHost UIGlobalSettingsNetwork::generateDataNetworkHost(const CHostNetworkInterface &iface)
+{
+    /* Prepare data: */
+    UIDataNetworkHost data;
+
     /* Get DHCP server (create if necessary): */
     CDHCPServer dhcp = vboxGlobal().virtualBox().FindDHCPServerByNetworkName(iface.GetNetworkName());
     if (dhcp.isNull())
     {
-        vboxGlobal().virtualBox().CreateDHCPServer(iface.GetNetworkName());
+        CVirtualBox vbox = vboxGlobal().virtualBox();
+        vbox.CreateDHCPServer(iface.GetNetworkName());
+        if (!vbox.isOk())
+        {
+            msgCenter().cannotCreateDHCPServer(vbox, this);
+            return data;
+        }
         dhcp = vboxGlobal().virtualBox().FindDHCPServerByNetworkName(iface.GetNetworkName());
     }
-    AssertMsg(!dhcp.isNull(), ("DHCP server creation failed!\n"));
-
-    /* Prepare cache item: */
-    UIHostNetworkData data;
-
-    /* Host-only interface settings */
+    Assert(!dhcp.isNull());
+    if (dhcp.isNull())
+        return data;
+
+    /* Host interface settings: */
     data.m_interface.m_strName = iface.GetName();
     data.m_interface.m_fDhcpClientEnabled = iface.GetDHCPEnabled();
@@ -571 +968 @@
     data.m_dhcpserver.m_strDhcpUpperAddress = dhcp.GetUpperIP();
 
-    /* Append cache item: */
-    m_cache.m_items << data;
-}
-
-void UIGlobalSettingsNetwork::removeCacheItem(const QString &strInterfaceName)
-{
-    /* Search for invalidated cache item: */
-    for (int iNetworkIndex = 0; iNetworkIndex < m_cache.m_items.size(); ++iNetworkIndex)
-    {
-        /* Get iterated data: */
-        const UIHostNetworkData &data = m_cache.m_items[iNetworkIndex];
-        if (data.m_interface.m_strName == strInterfaceName)
-        {
-            m_cache.m_items.removeAll(data);
-            break;
-        }
-    }
-}
-
-void UIGlobalSettingsNetwork::appendListItem(const UIHostNetworkData &data, bool fChooseItem)
-{
-    /* Add new item to the list: */
-    UIHostInterfaceItem *pItem = new UIHostInterfaceItem;
+    /* Return data: */
+    return data;
+}
+
+void UIGlobalSettingsNetwork::saveCacheItemNetworkHost(const UIDataNetworkHost &data)
+{
+    /* Make sure corresponding Host interface exists: */
+    CHost host = vboxGlobal().host();
+    CHostNetworkInterface iface = host.FindHostNetworkInterfaceByName(data.m_interface.m_strName);
+    AssertReturnVoid(host.isOk() && !iface.isNull());
+
+    /* Automatic host interface configuration: */
+    if (data.m_interface.m_fDhcpClientEnabled)
+    {
+        iface.EnableDynamicIPConfig();
+    }
+    /* Manual host interface configuration: */
+    else
+    {
+        AssertMsg(data.m_interface.m_strInterfaceAddress.isEmpty() ||
+                  QHostAddress(data.m_interface.m_strInterfaceAddress).protocol() == QAbstractSocket::IPv4Protocol,
+                  ("Interface IPv4 address must be empty or IPv4-valid!\n"));
+        AssertMsg(data.m_interface.m_strInterfaceMask.isEmpty() ||
+                  QHostAddress(data.m_interface.m_strInterfaceMask).protocol() == QAbstractSocket::IPv4Protocol,
+                  ("Interface IPv4 network mask must be empty or IPv4-valid!\n"));
+        iface.EnableStaticIPConfig(data.m_interface.m_strInterfaceAddress, data.m_interface.m_strInterfaceMask);
+        if (iface.GetIPV6Supported())
+        {
+            AssertMsg(data.m_interface.m_strInterfaceAddress6.isEmpty() ||
+                      QHostAddress(data.m_interface.m_strInterfaceAddress6).protocol() == QAbstractSocket::IPv6Protocol,
+                      ("Interface IPv6 address must be empty or IPv6-valid!\n"));
+            iface.EnableStaticIPConfigV6(data.m_interface.m_strInterfaceAddress6, data.m_interface.m_strInterfaceMaskLength6.toULong());
+        }
+    }
+
+    /* Make sure corresponding DHCP server exists: */
+    CVirtualBox vbox = vboxGlobal().virtualBox();
+    CDHCPServer dhcp = vbox.FindDHCPServerByNetworkName(iface.GetNetworkName());
+    AssertReturnVoid(vbox.isOk() && !dhcp.isNull());
+
+    /* Save DHCP server configuration: */
+    dhcp.SetEnabled(data.m_dhcpserver.m_fDhcpServerEnabled);
+    AssertMsg(QHostAddress(data.m_dhcpserver.m_strDhcpServerAddress).protocol() == QAbstractSocket::IPv4Protocol,
+              ("DHCP server IPv4 address must be IPv4-valid!\n"));
+    AssertMsg(QHostAddress(data.m_dhcpserver.m_strDhcpServerMask).protocol() == QAbstractSocket::IPv4Protocol,
+              ("DHCP server IPv4 network mask must be IPv4-valid!\n"));
+    AssertMsg(QHostAddress(data.m_dhcpserver.m_strDhcpLowerAddress).protocol() == QAbstractSocket::IPv4Protocol,
+              ("DHCP server IPv4 lower bound must be IPv4-valid!\n"));
+    AssertMsg(QHostAddress(data.m_dhcpserver.m_strDhcpUpperAddress).protocol() == QAbstractSocket::IPv4Protocol,
+              ("DHCP server IPv4 upper bound must be IPv4-valid!\n"));
+    if (QHostAddress(data.m_dhcpserver.m_strDhcpServerAddress).protocol() == QAbstractSocket::IPv4Protocol &&
+        QHostAddress(data.m_dhcpserver.m_strDhcpServerMask).protocol() == QAbstractSocket::IPv4Protocol &&
+        QHostAddress(data.m_dhcpserver.m_strDhcpLowerAddress).protocol() == QAbstractSocket::IPv4Protocol &&
+        QHostAddress(data.m_dhcpserver.m_strDhcpUpperAddress).protocol() == QAbstractSocket::IPv4Protocol)
+        dhcp.SetConfiguration(data.m_dhcpserver.m_strDhcpServerAddress, data.m_dhcpserver.m_strDhcpServerMask,
+                              data.m_dhcpserver.m_strDhcpLowerAddress, data.m_dhcpserver.m_strDhcpUpperAddress);
+}
+
+void UIGlobalSettingsNetwork::createTreeItemNetworkHost(const UIDataNetworkHost &data, bool fChooseItem)
+{
+    /* Add new item to the tree: */
+    UIItemNetworkHost *pItem = new UIItemNetworkHost;
     pItem->fetchNetworkData(data);
-    m_pInterfacesTree->addTopLevelItem(pItem);
+    m_pTreeNetworkHost->addTopLevelItem(pItem);
     /* And choose it as current if necessary: */
     if (fChooseItem)
-        m_pInterfacesTree->setCurrentItem(pItem);
-}
-
-void UIGlobalSettingsNetwork::removeListItem(UIHostInterfaceItem *pItem)
+        m_pTreeNetworkHost->setCurrentItem(pItem);
+}
+
+void UIGlobalSettingsNetwork::removeTreeItemNetworkHost(UIItemNetworkHost *pItem)
 {
     /* Delete passed item: */

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetwork.h

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2009-2012 Oracle Corporation
+ * Copyright (C) 2009-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -20 +20 @@
 #define __UIGlobalSettingsNetwork_h__
 
-/* Local includes */
+/* GUI includes: */
 #include "UISettingsPage.h"
 #include "UIGlobalSettingsNetwork.gen.h"
 
+/* Forward declarations: */
+class UIItemNetworkNAT;
+class UIItemNetworkHost;
+
+
+/* Global settings / Network page / NAT network data: */
+struct UIDataNetworkNAT
+{
+    /* NAT Network: */
+    bool m_fEnabled;
+    QString m_strName;
+    QString m_strNewName;
+    QString m_strCIDR;
+    bool m_fSupportsDHCP;
+    bool m_fSupportsIPv6;
+    bool m_fAdvertiseDefaultIPv6Route;
+    bool operator==(const UIDataNetworkNAT &other) const
+    {
+        return m_fEnabled == other.m_fEnabled &&
+               m_strName == other.m_strName &&
+               m_strNewName == other.m_strNewName &&
+               m_strCIDR == other.m_strCIDR &&
+               m_fSupportsDHCP == other.m_fSupportsDHCP &&
+               m_fSupportsIPv6 == other.m_fSupportsIPv6 &&
+               m_fAdvertiseDefaultIPv6Route == other.m_fAdvertiseDefaultIPv6Route;
+    }
+};
+
+
 /* Global settings / Network page / Host interface data: */
-struct UIHostInterfaceData
-{
-    /* Host-only Interface: */
+struct UIDataNetworkHostInterface
+{
+    /* Host Interface: */
     QString m_strName;
     bool m_fDhcpClientEnabled;
@@ -35 +64 @@
     QString m_strInterfaceAddress6;
     QString m_strInterfaceMaskLength6;
-    bool operator==(const UIHostInterfaceData &other) const
+    bool operator==(const UIDataNetworkHostInterface &other) const
     {
         return m_strName == other.m_strName &&
@@ -47 +76 @@
 };
 
-/* Global settings / Network page / DHCP server data: */
-struct UIDHCPServerData
-{
-    /* DHCP Server */
+/* Global settings / Network page / Host DHCP server data: */
+struct UIDataNetworkDHCPServer
+{
+    /* DHCP Server: */
     bool m_fDhcpServerEnabled;
     QString m_strDhcpServerAddress;
@@ -56 +85 @@
     QString m_strDhcpLowerAddress;
     QString m_strDhcpUpperAddress;
-    bool operator==(const UIDHCPServerData &other) const
+    bool operator==(const UIDataNetworkDHCPServer &other) const
     {
         return m_fDhcpServerEnabled == other.m_fDhcpServerEnabled &&
@@ -66 +95 @@
 };
 
-/* Global settings / Network page / Full network data: */
-struct UIHostNetworkData
-{
-    UIHostInterfaceData m_interface;
-    UIDHCPServerData m_dhcpserver;
-    bool operator==(const UIHostNetworkData &other) const
+/* Global settings / Network page / Host network data: */
+struct UIDataNetworkHost
+{
+    UIDataNetworkHostInterface m_interface;
+    UIDataNetworkDHCPServer m_dhcpserver;
+    bool operator==(const UIDataNetworkHost &other) const
     {
         return m_interface == other.m_interface &&
@@ -78 +107 @@
 };
 
-/* Global settings / Network page / Cache: */
+
+/* Global settings / Network page / Global network cache: */
 struct UISettingsCacheGlobalNetwork
 {
-    QList<UIHostNetworkData> m_items;
-};
-
-/* Global settings / Network page / Host interface item: */
-class UIHostInterfaceItem : public QTreeWidgetItem
-{
+    QList<UIDataNetworkNAT> m_networksNAT;
+    QList<UIDataNetworkHost> m_networksHost;
+};
+
+
+/* Global settings / Network page: */
+class UIGlobalSettingsNetwork : public UISettingsPageGlobal, public Ui::UIGlobalSettingsNetwork
+{
+    Q_OBJECT;
+
 public:
 
     /* Constructor: */
-    UIHostInterfaceItem();
-
-    /* API: Get/return data to/form items: */
-    void fetchNetworkData(const UIHostNetworkData &data);
-    void uploadNetworkData(UIHostNetworkData &data);
+    UIGlobalSettingsNetwork();
+
+protected:
+
+    /* API:
+     * Load data to cache from corresponding external object(s),
+     * this task COULD be performed in other than GUI thread: */
+    void loadToCacheFrom(QVariant &data);
+    /* API:
+     * Load data to corresponding widgets from cache,
+     * this task SHOULD be performed in GUI thread only: */
+    void getFromCache();
+
+    /* API:
+     * Save data from corresponding widgets to cache,
+     * this task SHOULD be performed in GUI thread only: */
+    void putToCache();
+    /* API:
+     * Save data from cache to corresponding external object(s),
+     * this task COULD be performed in other than GUI thread: */
+    void saveFromCacheTo(QVariant &data);
 
     /* API: Validation stuff: */
     bool validate(QList<UIValidationMessage> &messages);
 
-    /* API: Update stuff: */
-    QString updateInfo();
-
-    /* API: Network item getters: */
-    QString name() const { return m_data.m_interface.m_strName; }
-    bool isDhcpClientEnabled() const { return m_data.m_interface.m_fDhcpClientEnabled; }
-    QString interfaceAddress() const { return m_data.m_interface.m_strInterfaceAddress; }
-    QString interfaceMask() const { return m_data.m_interface.m_strInterfaceMask; }
-    bool isIpv6Supported() const { return m_data.m_interface.m_fIpv6Supported; }
-    QString interfaceAddress6() const { return m_data.m_interface.m_strInterfaceAddress6; }
-    QString interfaceMaskLength6() const { return m_data.m_interface.m_strInterfaceMaskLength6; }
-
-    bool isDhcpServerEnabled() const { return m_data.m_dhcpserver.m_fDhcpServerEnabled; }
-    QString dhcpServerAddress() const { return m_data.m_dhcpserver.m_strDhcpServerAddress; }
-    QString dhcpServerMask() const { return m_data.m_dhcpserver.m_strDhcpServerMask; }
-    QString dhcpLowerAddress() const { return m_data.m_dhcpserver.m_strDhcpLowerAddress; }
-    QString dhcpUpperAddress() const { return m_data.m_dhcpserver.m_strDhcpUpperAddress; }
-
-    /* API: Network item setters */
-    void setDhcpClientEnabled(bool fEnabled) { m_data.m_interface.m_fDhcpClientEnabled = fEnabled; }
-    void setInterfaceAddress (const QString &strValue) { m_data.m_interface.m_strInterfaceAddress = strValue; }
-    void setInterfaceMask (const QString &strValue) { m_data.m_interface.m_strInterfaceMask = strValue; }
-    void setIp6Supported (bool fSupported) { m_data.m_interface.m_fIpv6Supported = fSupported; }
-    void setInterfaceAddress6 (const QString &strValue) { m_data.m_interface.m_strInterfaceAddress6 = strValue; }
-    void setInterfaceMaskLength6 (const QString &strValue) { m_data.m_interface.m_strInterfaceMaskLength6 = strValue; }
-
-    void setDhcpServerEnabled (bool fEnabled) { m_data.m_dhcpserver.m_fDhcpServerEnabled = fEnabled; }
-    void setDhcpServerAddress (const QString &sttValue) { m_data.m_dhcpserver.m_strDhcpServerAddress = sttValue; }
-    void setDhcpServerMask (const QString &strValue) { m_data.m_dhcpserver.m_strDhcpServerMask = strValue; }
-    void setDhcpLowerAddress (const QString &strValue) { m_data.m_dhcpserver.m_strDhcpLowerAddress = strValue; }
-    void setDhcpUpperAddress (const QString &strValue) { m_data.m_dhcpserver.m_strDhcpUpperAddress = strValue; }
+    /* API: Navigation stuff: */
+    void setOrderAfter(QWidget *pWidget);
+
+    /* API: Translation stuff: */
+    void retranslateUi();
+
+private slots:
+
+    /* Handlers: NAT network stuff: */
+    void sltAddNetworkNAT();
+    void sltDelNetworkNAT();
+    void sltEditNetworkNAT();
+    void sltHandleCurrentItemChangeNetworkNAT();
+    void sltShowContextMenuNetworkNAT(const QPoint &pos);
+
+    /* Handlers: Host network stuff: */
+    void sltAddNetworkHost();
+    void sltDelNetworkHost();
+    void sltEditNetworkHost();
+    void sltHandleCurrentItemChangeNetworkHost();
+    void sltShowContextMenuNetworkHost(const QPoint &pos);
 
 private:
 
-    /* Network data: */
-    UIHostNetworkData m_data;
-};
-
-/* Global settings / Network page: */
-class UIGlobalSettingsNetwork : public UISettingsPageGlobal, public Ui::UIGlobalSettingsNetwork
-{
-    Q_OBJECT;
-
-public:
-
-    /* Constructor: */
-    UIGlobalSettingsNetwork();
-
-protected:
-
-    /* Load data to cache from corresponding external object(s),
-     * this task COULD be performed in other than GUI thread: */
-    void loadToCacheFrom(QVariant &data);
-    /* Load data to corresponding widgets from cache,
-     * this task SHOULD be performed in GUI thread only: */
-    void getFromCache();
-
-    /* Save data from corresponding widgets to cache,
-     * this task SHOULD be performed in GUI thread only: */
-    void putToCache();
-    /* Save data from cache to corresponding external object(s),
-     * this task COULD be performed in other than GUI thread: */
-    void saveFromCacheTo(QVariant &data);
-
-    /* API: Validation stuff: */
-    bool validate(QList<UIValidationMessage> &messages);
-
-    /* Navigation stuff: */
-    void setOrderAfter (QWidget *aWidget);
-
-    /* Translation stuff: */
-    void retranslateUi();
-
-private slots:
-
-    /* Helper slots: */
-    void sltAddInterface();
-    void sltDelInterface();
-    void sltEditInterface();
-    void sltUpdateCurrentItem();
-    void sltChowContextMenu(const QPoint &pos);
-
-private:
-
-    /* Helper members: */
-    void appendCacheItem(const CHostNetworkInterface &iface);
-    void removeCacheItem(const QString &strInterfaceName);
-    void appendListItem(const UIHostNetworkData &data, bool fChooseItem = false);
-    void removeListItem(UIHostInterfaceItem *pItem);
-
-    /* Helper actions: */
-    QAction *m_pAddAction;
-    QAction *m_pDelAction;
-    QAction *m_pEditAction;
-
-    /* Editness flag: */
+    /* Helpers: NAT network cache stuff: */
+    UIDataNetworkNAT generateDataNetworkNAT(const CNATNetwork &network);
+    void saveCacheItemNetworkNAT(const UIDataNetworkNAT &data);
+
+    /* Helpers: NAT network tree stuff: */
+    void createTreeItemNetworkNAT(const UIDataNetworkNAT &data, bool fChooseItem = false);
+    void removeTreeItemNetworkNAT(UIItemNetworkNAT *pItem);
+
+    /* Helpers: Host network cache stuff: */
+    UIDataNetworkHost generateDataNetworkHost(const CHostNetworkInterface &iface);
+    void saveCacheItemNetworkHost(const UIDataNetworkHost &data);
+
+    /* Helpers: Host network tree stuff: */
+    void createTreeItemNetworkHost(const UIDataNetworkHost &data, bool fChooseItem = false);
+    void removeTreeItemNetworkHost(UIItemNetworkHost *pItem);
+
+    /* Variables: NAT network actions: */
+    QAction *m_pActionAddNetworkNAT;
+    QAction *m_pActionDelNetworkNAT;
+    QAction *m_pActionEditNetworkNAT;
+
+    /* Variables: Host network actions: */
+    QAction *m_pActionAddNetworkHost;
+    QAction *m_pActionDelNetworkHost;
+    QAction *m_pActionEditNetworkHost;
+
+    /* Variable: Editness flag: */
     bool m_fChanged;
 
-    /* Cache: */
+    /* Variable: Cache: */
     UISettingsCacheGlobalNetwork m_cache;
 };
 
 #endif // __UIGlobalSettingsNetwork_h__
-

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetwork.ui

@@ -15 +15 @@
  <class>UIGlobalSettingsNetwork</class>
  <widget class="QWidget" name="UIGlobalSettingsNetwork">
-  <layout class="QGridLayout">
-   <property name="margin">
-    <number>0</number>
-   </property>
-   <item row="0" column="0">
-    <widget class="QILabelSeparator" native="1" name="m_pNetworkLabel">
-     <property name="text">
-     <string>&amp;Host-only Networks</string>
-     </property>
-     <property name="buddy">
-      <cstring>m_pInterfacesTree</cstring>
-     </property>
-    </widget>
-   </item>
-   <item row="1" column="0">
-    <widget class="QWidget" native="1" name="m_pNetworkSettingsContainer" >
-     <layout class="QHBoxLayout" name="m_pLayout1">
-      <property name="spacing">
-       <number>3</number>
-      </property>
-      <property name="margin">
-       <number>0</number>
-      </property>
-      <item>
-       <widget class="QTreeWidget" name="m_pInterfacesTree">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="minimumSize">
-         <size>
-          <width>0</width>
-          <height>150</height>
-         </size>
-        </property>
-        <property name="whatsThis">
-         <string>Lists all available host-only networks.</string>
-        </property>
-        <property name="rootIsDecorated">
-         <bool>false</bool>
-        </property>
-        <column>
-         <property name="text">
-          <string>Name</string>
+  <layout class="QVBoxLayout">
+   <item>
+    <widget class="QITabWidget" name="m_pTabWidget">
+     <widget class="QWidget" name="m_pTabNAT">
+      <attribute name="title">
+       <string>&amp;NAT Networks</string>
+      </attribute>
+      <layout class="QHBoxLayout">
+       <property name="margin">
+        <number>0</number>
+       </property>
+       <property name="spacing">
+        <number>3</number>
+       </property>
+       <item>
+        <widget class="QTreeWidget" name="m_pTreeNetworkNAT">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
          </property>
-        </column>
-       </widget>
-      </item>
-      <item>
-       <widget class="UIToolBar" name="m_pActionsToolbar"/>
-      </item>
-     </layout>
+         <property name="minimumSize">
+          <size>
+           <width>0</width>
+           <height>150</height>
+          </size>
+         </property>
+         <property name="whatsThis">
+          <string>Lists all available NAT networks.</string>
+         </property>
+         <property name="rootIsDecorated">
+          <bool>false</bool>
+         </property>
+         <column>
+          <property name="text">
+           <string>Name</string>
+          </property>
+         </column>
+        </widget>
+       </item>
+       <item>
+        <widget class="UIToolBar" name="m_pToolbarNetworkNAT"/>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="m_pTabHostOnly">
+      <attribute name="title">
+       <string>&amp;Host-only Networks</string>
+      </attribute>
+      <layout class="QHBoxLayout">
+       <property name="margin">
+        <number>0</number>
+       </property>
+       <property name="spacing">
+        <number>3</number>
+       </property>
+       <item>
+        <widget class="QTreeWidget" name="m_pTreeNetworkHost">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
+         <property name="minimumSize">
+          <size>
+           <width>0</width>
+           <height>150</height>
+          </size>
+         </property>
+         <property name="whatsThis">
+          <string>Lists all available host-only networks.</string>
+         </property>
+         <property name="rootIsDecorated">
+          <bool>false</bool>
+         </property>
+         <column>
+          <property name="text">
+           <string>Name</string>
+          </property>
+         </column>
+        </widget>
+       </item>
+       <item>
+        <widget class="UIToolBar" name="m_pToolbarNetworkHost"/>
+       </item>
+      </layout>
+     </widget>
     </widget>
    </item>
@@ -75 +110 @@
  <customwidgets>
   <customwidget>
-   <class>QILabelSeparator</class>
-   <extends>QLabel</extends>
-   <header>QILabelSeparator.h</header>
-  </customwidget>
-  <customwidget>
    <class>UIToolBar</class>
    <extends>QToolBar</extends>
    <header>UIToolBar.h</header>
+  </customwidget>
+  <customwidget>
+   <class>QITabWidget</class>
+   <extends>QTabWidget</extends>
+   <header>QITabWidget.h</header>
   </customwidget>
  </customwidgets>

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetailsHost.cpp

@@ -3 +3 @@
  *
  * VBox frontends: Qt4 GUI ("VirtualBox"):
- * UIGlobalSettingsNetworkDetails class implementation
+ * UIGlobalSettingsNetworkDetailsHost class implementation
  */
 
 /*
- * Copyright (C) 2009-2010 Oracle Corporation
+ * Copyright (C) 2009-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -18 +18 @@
  */
 
-/* Global includes */
-#include <QHostAddress>
+/* Qt includes: */
 #include <QRegExpValidator>
 
-/* Local includes */
+/* GUI includes: */
 #include "UIGlobalSettingsNetwork.h"
-#include "UIGlobalSettingsNetworkDetails.h"
-
-/* Network page details constructor: */
-UIGlobalSettingsNetworkDetails::UIGlobalSettingsNetworkDetails(QWidget *pParent)
-    : QIWithRetranslateUI2<QIDialog>(pParent
-#ifdef Q_WS_MAC
-    ,Qt::Sheet
-#endif /* Q_WS_MAC */
-    )
-    , m_pItem(0)
+#include "UIGlobalSettingsNetworkDetailsHost.h"
+
+UIGlobalSettingsNetworkDetailsHost::UIGlobalSettingsNetworkDetailsHost(QWidget *pParent, UIDataNetworkHost &data)
+    : QIWithRetranslateUI2<QIDialog>(pParent)
+    , m_data(data)
 {
     /* Apply UI decorations: */
-    Ui::UIGlobalSettingsNetworkDetails::setupUi(this);
+    Ui::UIGlobalSettingsNetworkDetailsHost::setupUi(this);
 
     /* Setup dialog: */
@@ -46 +40 @@
                             "([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\."
                             "([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])");
-    QString strTemplateIPv6("[0-9a-fA-Z]{1,4}:{1,2}[0-9a-fA-Z]{1,4}:{1,2}"
-                            "[0-9a-fA-Z]{1,4}:{1,2}[0-9a-fA-Z]{1,4}:{1,2}"
-                            "[0-9a-fA-Z]{1,4}:{1,2}[0-9a-fA-Z]{1,4}:{1,2}"
-                            "[0-9a-fA-Z]{1,4}:{1,2}[0-9a-fA-Z]{1,4}");
+    QString strTemplateIPv6("[0-9a-fA-F]{1,4}:{1,2}[0-9a-fA-F]{1,4}:{1,2}"
+                            "[0-9a-fA-F]{1,4}:{1,2}[0-9a-fA-F]{1,4}:{1,2}"
+                            "[0-9a-fA-F]{1,4}:{1,2}[0-9a-fA-F]{1,4}:{1,2}"
+                            "[0-9a-fA-F]{1,4}:{1,2}[0-9a-fA-F]{1,4}");
 
     m_pIPv4Editor->setValidator(new QRegExpValidator(QRegExp(strTemplateIPv4), this));
@@ -92 +86 @@
     retranslateUi();
 
+    /* Load: */
+    load();
+
     /* Fix minimum possible size: */
     resize(minimumSizeHint());
-    qApp->processEvents();
     setFixedSize(minimumSizeHint());
 }
 
-/* Get data to details sub-dialog: */
-void UIGlobalSettingsNetworkDetails::getFromItem(UIHostInterfaceItem *pItem)
-{
-    m_pItem = pItem;
-
-    /* Host-only Interface: */
-    m_pEnableManualCheckbox->setChecked(!m_pItem->isDhcpClientEnabled());
+void UIGlobalSettingsNetworkDetailsHost::retranslateUi()
+{
+    /* Translate uic generated strings: */
+    Ui::UIGlobalSettingsNetworkDetailsHost::retranslateUi(this);
+}
+
+void UIGlobalSettingsNetworkDetailsHost::accept()
+{
+    /* Save before accept: */
+    save();
+    /* Call to base-class: */
+    QIDialog::accept();
+}
+
+void UIGlobalSettingsNetworkDetailsHost::load()
+{
+    /* Host Interface: */
+    m_pEnableManualCheckbox->setChecked(!m_data.m_interface.m_fDhcpClientEnabled);
 #if !0 /* !defined (Q_WS_WIN) */
     /* Disable automatic for all hosts for now: */
@@ -110 +117 @@
     m_pEnableManualCheckbox->setEnabled(false);
 #endif
-    sltDhcpClientStatusChanged();
+    loadClientStuff();
 
     /* DHCP Server: */
-    m_pEnabledDhcpServerCheckbox->setChecked(m_pItem->isDhcpServerEnabled());
-    sltDhcpServerStatusChanged();
-}
-
-/* Return data from details sub-dialog: */
-void UIGlobalSettingsNetworkDetails::putBackToItem()
-{
-    /* Host-only Interface: */
-    m_pItem->setDhcpClientEnabled(!m_pEnableManualCheckbox->isChecked());
-    if (m_pEnableManualCheckbox->isChecked())
-    {
-        m_pItem->setInterfaceAddress(m_pIPv4Editor->text());
-        m_pItem->setInterfaceMask(m_pNMv4Editor->text());
-        if (m_pItem->isIpv6Supported())
-        {
-            m_pItem->setInterfaceAddress6(m_pIPv6Editor->text());
-            m_pItem->setInterfaceMaskLength6(m_pNMv6Editor->text());
-        }
-    }
-
-    /* DHCP Server: */
-    m_pItem->setDhcpServerEnabled(m_pEnabledDhcpServerCheckbox->isChecked());
-    if (m_pEnabledDhcpServerCheckbox->isChecked())
-    {
-        m_pItem->setDhcpServerAddress(m_pDhcpAddressEditor->text());
-        m_pItem->setDhcpServerMask(m_pDhcpMaskEditor->text());
-        m_pItem->setDhcpLowerAddress(m_pDhcpLowerAddressEditor->text());
-        m_pItem->setDhcpUpperAddress(m_pDhcpUpperAddressEditor->text());
-    }
-}
-
-/* Validation stuff: */
-void UIGlobalSettingsNetworkDetails::retranslateUi()
-{
-    /* Translate uic generated strings: */
-    Ui::UIGlobalSettingsNetworkDetails::retranslateUi(this);
-}
-
-/* Handler for DHCP client settings change: */
-void UIGlobalSettingsNetworkDetails::sltDhcpClientStatusChanged()
-{
+    m_pEnabledDhcpServerCheckbox->setChecked(m_data.m_dhcpserver.m_fDhcpServerEnabled);
+    loadServerStuff();
+}
+
+void UIGlobalSettingsNetworkDetailsHost::loadClientStuff()
+{
+    /* Adjust network interface fields: */
     bool fIsManual = m_pEnableManualCheckbox->isChecked();
-    bool fIsIpv6Supported = fIsManual && m_pItem->isIpv6Supported();
+    bool fIsIpv6Supported = fIsManual && m_data.m_interface.m_fIpv6Supported;
 
     m_pIPv4Editor->clear();
@@ -173 +146 @@
     if (fIsManual)
     {
-        m_pIPv4Editor->setText(m_pItem->interfaceAddress());
-        m_pNMv4Editor->setText(m_pItem->interfaceMask());
+        m_pIPv4Editor->setText(m_data.m_interface.m_strInterfaceAddress);
+        m_pNMv4Editor->setText(m_data.m_interface.m_strInterfaceMask);
         if (fIsIpv6Supported)
         {
-            m_pIPv6Editor->setText(m_pItem->interfaceAddress6());
-            m_pNMv6Editor->setText(m_pItem->interfaceMaskLength6());
+            m_pIPv6Editor->setText(m_data.m_interface.m_strInterfaceAddress6);
+            m_pNMv6Editor->setText(m_data.m_interface.m_strInterfaceMaskLength6);
         }
     }
 }
 
-/* Handler for DHCP server settings change: */
-void UIGlobalSettingsNetworkDetails::sltDhcpServerStatusChanged()
-{
+void UIGlobalSettingsNetworkDetailsHost::loadServerStuff()
+{
+    /* Adjust dhcp server fields: */
     bool fIsManual = m_pEnabledDhcpServerCheckbox->isChecked();
 
@@ -204 +177 @@
     if (fIsManual)
     {
-        m_pDhcpAddressEditor->setText(m_pItem->dhcpServerAddress());
-        m_pDhcpMaskEditor->setText(m_pItem->dhcpServerMask());
-        m_pDhcpLowerAddressEditor->setText(m_pItem->dhcpLowerAddress());
-        m_pDhcpUpperAddressEditor->setText(m_pItem->dhcpUpperAddress());
-    }
-}
-
+        m_pDhcpAddressEditor->setText(m_data.m_dhcpserver.m_strDhcpServerAddress);
+        m_pDhcpMaskEditor->setText(m_data.m_dhcpserver.m_strDhcpServerMask);
+        m_pDhcpLowerAddressEditor->setText(m_data.m_dhcpserver.m_strDhcpLowerAddress);
+        m_pDhcpUpperAddressEditor->setText(m_data.m_dhcpserver.m_strDhcpUpperAddress);
+    }
+}
+
+void UIGlobalSettingsNetworkDetailsHost::save()
+{
+    /* Host Interface: */
+    m_data.m_interface.m_fDhcpClientEnabled = !m_pEnableManualCheckbox->isChecked();
+    if (m_pEnableManualCheckbox->isChecked())
+    {
+        m_data.m_interface.m_strInterfaceAddress = m_pIPv4Editor->text();
+        m_data.m_interface.m_strInterfaceMask = m_pNMv4Editor->text();
+        if (m_data.m_interface.m_fIpv6Supported)
+        {
+            m_data.m_interface.m_strInterfaceAddress6 = m_pIPv6Editor->text();
+            m_data.m_interface.m_strInterfaceMaskLength6 = m_pNMv6Editor->text();
+        }
+    }
+
+    /* DHCP Server: */
+    m_data.m_dhcpserver.m_fDhcpServerEnabled = m_pEnabledDhcpServerCheckbox->isChecked();
+    if (m_pEnabledDhcpServerCheckbox->isChecked())
+    {
+        m_data.m_dhcpserver.m_strDhcpServerAddress = m_pDhcpAddressEditor->text();
+        m_data.m_dhcpserver.m_strDhcpServerMask = m_pDhcpMaskEditor->text();
+        m_data.m_dhcpserver.m_strDhcpLowerAddress = m_pDhcpLowerAddressEditor->text();
+        m_data.m_dhcpserver.m_strDhcpUpperAddress = m_pDhcpUpperAddressEditor->text();
+    }
+}
+

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetailsHost.h

@@ -2 +2 @@
  *
  * VBox frontends: Qt4 GUI ("VirtualBox"):
- * UIGlobalSettingsNetworkDetails class declaration
+ * UIGlobalSettingsNetworkDetailsHost class declaration
  */
 
 /*
- * Copyright (C) 2009-2010 Oracle Corporation
+ * Copyright (C) 2009-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -17 +17 @@
  */
 
-#ifndef __UIGlobalSettingsNetworkDetails_h__
-#define __UIGlobalSettingsNetworkDetails_h__
+#ifndef __UIGlobalSettingsNetworkDetailsHost_h__
+#define __UIGlobalSettingsNetworkDetailsHost_h__
 
 /* Local includes */
 #include "QIDialog.h"
 #include "QIWithRetranslateUI.h"
-#include "UIGlobalSettingsNetworkDetails.gen.h"
+#include "UIGlobalSettingsNetworkDetailsHost.gen.h"
 
 /* Forward decalrations: */
-class UIHostInterfaceItem;
+class UIDataNetworkHost;
 
 /* Global settings / Network page / Details sub-dialog: */
-class UIGlobalSettingsNetworkDetails : public QIWithRetranslateUI2<QIDialog>, public Ui::UIGlobalSettingsNetworkDetails
+class UIGlobalSettingsNetworkDetailsHost : public QIWithRetranslateUI2<QIDialog>, public Ui::UIGlobalSettingsNetworkDetailsHost
 {
     Q_OBJECT;
@@ -36 +36 @@
 
     /* Constructor: */
-    UIGlobalSettingsNetworkDetails(QWidget *pParent);
-
-    /* Get/return data to/from details sub-dialog: */
-    void getFromItem(UIHostInterfaceItem *aItem);
-    void putBackToItem();
+    UIGlobalSettingsNetworkDetailsHost(QWidget *pParent, UIDataNetworkHost &data);
 
 protected:
 
-    /* Validation stuff: */
+    /* Handler: Translation stuff: */
     void retranslateUi();
 
 private slots:
 
-    /* Various helper slots: */
-    void sltDhcpClientStatusChanged();
-    void sltDhcpServerStatusChanged();
+    /* Handlers: [Re]load stuff: */
+    void sltDhcpClientStatusChanged() { loadClientStuff(); }
+    void sltDhcpServerStatusChanged() { loadServerStuff(); }
+
+    /* Handler: Dialog stuff: */
+    void accept();
 
 private:
 
-    UIHostInterfaceItem *m_pItem;
+    /* Helpers: Load/Save stuff: */
+    void load();
+    void loadClientStuff();
+    void loadServerStuff();
+    void save();
+
+    /* Variable: External data reference: */
+    UIDataNetworkHost &m_data;
 };
 
-#endif // __UIGlobalSettingsNetworkDetails_h__
-
+#endif /* __UIGlobalSettingsNetworkDetailsHost_h__ */

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetailsHost.ui

@@ -13 +13 @@
  hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
  </comment>
- <class>UIGlobalSettingsNetworkDetails</class>
- <widget class="QWidget" name="UIGlobalSettingsNetworkDetails">
+ <class>UIGlobalSettingsNetworkDetailsHost</class>
+ <widget class="QWidget" name="UIGlobalSettingsNetworkDetailsHost">
   <property name="geometry">
    <rect>
@@ -342 +342 @@
    <sender>m_pButtonBox</sender>
    <signal>accepted()</signal>
-   <receiver>UIGlobalSettingsNetworkDetails</receiver>
+   <receiver>UIGlobalSettingsNetworkDetailsHost</receiver>
    <slot>accept()</slot>
    <hints>
@@ -358 +358 @@
    <sender>m_pButtonBox</sender>
    <signal>rejected()</signal>
-   <receiver>UIGlobalSettingsNetworkDetails</receiver>
+   <receiver>UIGlobalSettingsNetworkDetailsHost</receiver>
    <slot>reject()</slot>
    <hints>

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetailsNAT.cpp

@@ -3 +3 @@
  *
  * VBox frontends: Qt4 GUI ("VirtualBox"):
- * UIGlobalSettingsNetworkDetails class implementation
+ * UIGlobalSettingsNetworkDetailsNAT class implementation
  */
 
 /*
- * Copyright (C) 2009-2010 Oracle Corporation
+ * Copyright (C) 2009-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -18 +18 @@
  */
 
-/* Global includes */
-#include <QHostAddress>
+/* Qt includes: */
 #include <QRegExpValidator>
 
-/* Local includes */
+/* GUI includes: */
 #include "UIGlobalSettingsNetwork.h"
-#include "UIGlobalSettingsNetworkDetails.h"
+#include "UIGlobalSettingsNetworkDetailsNAT.h"
 
-/* Network page details constructor: */
-UIGlobalSettingsNetworkDetails::UIGlobalSettingsNetworkDetails(QWidget *pParent)
-    : QIWithRetranslateUI2<QIDialog>(pParent
-#ifdef Q_WS_MAC
-    ,Qt::Sheet
-#endif /* Q_WS_MAC */
-    )
-    , m_pItem(0)
+UIGlobalSettingsNetworkDetailsNAT::UIGlobalSettingsNetworkDetailsNAT(QWidget *pParent, UIDataNetworkNAT &data)
+    : QIWithRetranslateUI2<QIDialog>(pParent)
+    , m_data(data)
 {
     /* Apply UI decorations: */
-    Ui::UIGlobalSettingsNetworkDetails::setupUi(this);
+    Ui::UIGlobalSettingsNetworkDetailsNAT::setupUi(this);
 
     /* Setup dialog: */
@@ -42 +36 @@
 
     /* Setup validators: */
-    QString strTemplateIPv4("([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\."
-                            "([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\."
-                            "([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\."
-                            "([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])");
-    QString strTemplateIPv6("[0-9a-fA-Z]{1,4}:{1,2}[0-9a-fA-Z]{1,4}:{1,2}"
-                            "[0-9a-fA-Z]{1,4}:{1,2}[0-9a-fA-Z]{1,4}:{1,2}"
-                            "[0-9a-fA-Z]{1,4}:{1,2}[0-9a-fA-Z]{1,4}:{1,2}"
-                            "[0-9a-fA-Z]{1,4}:{1,2}[0-9a-fA-Z]{1,4}");
-
-    m_pIPv4Editor->setValidator(new QRegExpValidator(QRegExp(strTemplateIPv4), this));
-    m_pNMv4Editor->setValidator(new QRegExpValidator(QRegExp(strTemplateIPv4), this));
-    m_pIPv6Editor->setValidator(new QRegExpValidator(QRegExp(strTemplateIPv6), this));
-    m_pNMv6Editor->setValidator(new QRegExpValidator(QRegExp("[1-9][0-9]|1[0-1][0-9]|12[0-8]"), this));
-    m_pDhcpAddressEditor->setValidator(new QRegExpValidator(QRegExp(strTemplateIPv4), this));
-    m_pDhcpMaskEditor->setValidator(new QRegExpValidator(QRegExp(strTemplateIPv4), this));
-    m_pDhcpLowerAddressEditor->setValidator(new QRegExpValidator(QRegExp(strTemplateIPv4), this));
-    m_pDhcpUpperAddressEditor->setValidator(new QRegExpValidator(QRegExp(strTemplateIPv4), this));
-
-    /* Setup widgets */
-    m_pIPv6Editor->setFixedWidthByText(QString().fill('X', 32) + QString().fill(':', 7));
-
-#if 0 /* defined (Q_WS_WIN) */
-    QStyleOption options1;
-    options1.initFrom(m_pEnableManualCheckbox);
-    QGridLayout *playout1 = qobject_cast<QGridLayout*>(m_pDetailsTabWidget->widget(0)->layout());
-    int iWid1 = m_pEnableManualCheckbox->style()->pixelMetric(QStyle::PM_IndicatorWidth, &options1, m_pEnableManualCheckbox) +
-                m_pEnableManualCheckbox->style()->pixelMetric(QStyle::PM_CheckBoxLabelSpacing, &options1, m_pEnableManualCheckbox) -
-                playout1->spacing() - 1;
-    QSpacerItem *spacer1 = new QSpacerItem(iWid1, 0, QSizePolicy::Fixed, QSizePolicy::Fixed);
-    playout1->addItem(spacer1, 1, 0, 4);
-#else
-    m_pEnableManualCheckbox->setVisible(false);
-#endif
-
-    QStyleOption options2;
-    options2.initFrom(m_pEnabledDhcpServerCheckbox);
-    QGridLayout *pLayout2 = qobject_cast<QGridLayout*>(m_pDetailsTabWidget->widget(1)->layout());
-    int wid2 = m_pEnabledDhcpServerCheckbox->style()->pixelMetric(QStyle::PM_IndicatorWidth, &options2, m_pEnabledDhcpServerCheckbox) +
-               m_pEnabledDhcpServerCheckbox->style()->pixelMetric(QStyle::PM_CheckBoxLabelSpacing, &options2, m_pEnabledDhcpServerCheckbox) -
-               pLayout2->spacing() - 1;
-    QSpacerItem *pSpacer2 = new QSpacerItem(wid2, 0, QSizePolicy::Fixed, QSizePolicy::Fixed);
-    pLayout2->addItem(pSpacer2, 1, 0, 4);
-
-    /* Setup connections: */
-    connect(m_pEnableManualCheckbox, SIGNAL(stateChanged(int)), this, SLOT (sltDhcpClientStatusChanged()));
-    connect(m_pEnabledDhcpServerCheckbox, SIGNAL(stateChanged (int)), this, SLOT(sltDhcpServerStatusChanged()));
+    const QString strTemplateName("\\S+");
+    const QString strTemplateCIDRPrefix1("([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])");
+    const QString strTemplateCIDRPrefix2("([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])");
+    const QString strTemplateCIDRPostfix("([1-9]|1[0-9]|2[0-9]|3[0-2])");
+    const QString strTemplateCIDR("%1(\\.%2(\\.%2(\\.%2)?)?)?/%3");
+    const QString strTemplateCIDRFull = strTemplateCIDR.arg(strTemplateCIDRPrefix1, strTemplateCIDRPrefix2, strTemplateCIDRPostfix);
+    m_pEditorNetworkName->setValidator(new QRegExpValidator(QRegExp(strTemplateName), this));
+    m_pEditorNetworkCIDR->setValidator(new QRegExpValidator(QRegExp(strTemplateCIDRFull), this));
 
     /* Apply language settings: */
     retranslateUi();
 
+    /* Load: */
+    load();
+
     /* Fix minimum possible size: */
     resize(minimumSizeHint());
-    qApp->processEvents();
     setFixedSize(minimumSizeHint());
 }
 
-/* Get data to details sub-dialog: */
-void UIGlobalSettingsNetworkDetails::getFromItem(UIHostInterfaceItem *pItem)
+void UIGlobalSettingsNetworkDetailsNAT::retranslateUi()
 {
-    m_pItem = pItem;
-
-    /* Host-only Interface: */
-    m_pEnableManualCheckbox->setChecked(!m_pItem->isDhcpClientEnabled());
-#if !0 /* !defined (Q_WS_WIN) */
-    /* Disable automatic for all hosts for now: */
-    m_pEnableManualCheckbox->setChecked(true);
-    m_pEnableManualCheckbox->setEnabled(false);
-#endif
-    sltDhcpClientStatusChanged();
-
-    /* DHCP Server: */
-    m_pEnabledDhcpServerCheckbox->setChecked(m_pItem->isDhcpServerEnabled());
-    sltDhcpServerStatusChanged();
+    /* Translate uic generated strings: */
+    Ui::UIGlobalSettingsNetworkDetailsNAT::retranslateUi(this);
 }
 
-/* Return data from details sub-dialog: */
-void UIGlobalSettingsNetworkDetails::putBackToItem()
+void UIGlobalSettingsNetworkDetailsNAT::polishEvent(QShowEvent*)
 {
-    /* Host-only Interface: */
-    m_pItem->setDhcpClientEnabled(!m_pEnableManualCheckbox->isChecked());
-    if (m_pEnableManualCheckbox->isChecked())
-    {
-        m_pItem->setInterfaceAddress(m_pIPv4Editor->text());
-        m_pItem->setInterfaceMask(m_pNMv4Editor->text());
-        if (m_pItem->isIpv6Supported())
-        {
-            m_pItem->setInterfaceAddress6(m_pIPv6Editor->text());
-            m_pItem->setInterfaceMaskLength6(m_pNMv6Editor->text());
-        }
-    }
-
-    /* DHCP Server: */
-    m_pItem->setDhcpServerEnabled(m_pEnabledDhcpServerCheckbox->isChecked());
-    if (m_pEnabledDhcpServerCheckbox->isChecked())
-    {
-        m_pItem->setDhcpServerAddress(m_pDhcpAddressEditor->text());
-        m_pItem->setDhcpServerMask(m_pDhcpMaskEditor->text());
-        m_pItem->setDhcpLowerAddress(m_pDhcpLowerAddressEditor->text());
-        m_pItem->setDhcpUpperAddress(m_pDhcpUpperAddressEditor->text());
-    }
+    /* Update availability: */
+    m_pCheckboxAdvertiseDefaultIPv6Route->setEnabled(m_pCheckboxSupportsIPv6->isChecked());
+    m_pContainerOptions->setEnabled(m_pCheckboxNetwork->isChecked());
 }
 
-/* Validation stuff: */
-void UIGlobalSettingsNetworkDetails::retranslateUi()
+void UIGlobalSettingsNetworkDetailsNAT::accept()
 {
-    /* Translate uic generated strings: */
-    Ui::UIGlobalSettingsNetworkDetails::retranslateUi(this);
+    /* Save before accept: */
+    save();
+    /* Call to base-class: */
+    QIDialog::accept();
 }
 
-/* Handler for DHCP client settings change: */
-void UIGlobalSettingsNetworkDetails::sltDhcpClientStatusChanged()
+void UIGlobalSettingsNetworkDetailsNAT::load()
 {
-    bool fIsManual = m_pEnableManualCheckbox->isChecked();
-    bool fIsIpv6Supported = fIsManual && m_pItem->isIpv6Supported();
-
-    m_pIPv4Editor->clear();
-    m_pNMv4Editor->clear();
-    m_pIPv6Editor->clear();
-    m_pNMv6Editor->clear();
-
-    m_pIPv4Label->setEnabled(fIsManual);
-    m_pNMv4Label->setEnabled(fIsManual);
-    m_pIPv4Editor->setEnabled(fIsManual);
-    m_pNMv4Editor->setEnabled(fIsManual);
-    m_pIPv6Label->setEnabled(fIsIpv6Supported);
-    m_pNMv6Label->setEnabled(fIsIpv6Supported);
-    m_pIPv6Editor->setEnabled(fIsIpv6Supported);
-    m_pNMv6Editor->setEnabled(fIsIpv6Supported);
-
-    if (fIsManual)
-    {
-        m_pIPv4Editor->setText(m_pItem->interfaceAddress());
-        m_pNMv4Editor->setText(m_pItem->interfaceMask());
-        if (fIsIpv6Supported)
-        {
-            m_pIPv6Editor->setText(m_pItem->interfaceAddress6());
-            m_pNMv6Editor->setText(m_pItem->interfaceMaskLength6());
-        }
-    }
+    /* NAT Network: */
+    m_pCheckboxNetwork->setChecked(m_data.m_fEnabled);
+    m_pEditorNetworkName->setText(m_data.m_strNewName);
+    m_pEditorNetworkCIDR->setText(m_data.m_strCIDR);
+    m_pCheckboxSupportsDHCP->setChecked(m_data.m_fSupportsDHCP);
+    m_pCheckboxSupportsIPv6->setChecked(m_data.m_fSupportsIPv6);
+    m_pCheckboxAdvertiseDefaultIPv6Route->setChecked(m_data.m_fAdvertiseDefaultIPv6Route);
 }
 
-/* Handler for DHCP server settings change: */
-void UIGlobalSettingsNetworkDetails::sltDhcpServerStatusChanged()
+void UIGlobalSettingsNetworkDetailsNAT::save()
 {
-    bool fIsManual = m_pEnabledDhcpServerCheckbox->isChecked();
-
-    m_pDhcpAddressEditor->clear();
-    m_pDhcpMaskEditor->clear();
-    m_pDhcpLowerAddressEditor->clear();
-    m_pDhcpUpperAddressEditor->clear();
-
-    m_pDhcpAddressLabel->setEnabled(fIsManual);
-    m_pDhcpMaskLabel->setEnabled(fIsManual);
-    m_pDhcpLowerAddressLabel->setEnabled(fIsManual);
-    m_pDhcpUpperAddressLabel->setEnabled(fIsManual);
-    m_pDhcpAddressEditor->setEnabled(fIsManual);
-    m_pDhcpMaskEditor->setEnabled(fIsManual);
-    m_pDhcpLowerAddressEditor->setEnabled(fIsManual);
-    m_pDhcpUpperAddressEditor->setEnabled(fIsManual);
-
-    if (fIsManual)
-    {
-        m_pDhcpAddressEditor->setText(m_pItem->dhcpServerAddress());
-        m_pDhcpMaskEditor->setText(m_pItem->dhcpServerMask());
-        m_pDhcpLowerAddressEditor->setText(m_pItem->dhcpLowerAddress());
-        m_pDhcpUpperAddressEditor->setText(m_pItem->dhcpUpperAddress());
-    }
+    /* NAT Network: */
+    m_data.m_fEnabled = m_pCheckboxNetwork->isChecked();
+    m_data.m_strNewName = m_pEditorNetworkName->text();
+    m_data.m_strCIDR = m_pEditorNetworkCIDR->text();
+    m_data.m_fSupportsDHCP = m_pCheckboxSupportsDHCP->isChecked();
+    m_data.m_fSupportsIPv6 = m_pCheckboxSupportsIPv6->isChecked();
+    m_data.m_fAdvertiseDefaultIPv6Route = m_pCheckboxAdvertiseDefaultIPv6Route->isChecked();
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetailsNAT.h

@@ -2 +2 @@
  *
  * VBox frontends: Qt4 GUI ("VirtualBox"):
- * UIGlobalSettingsNetworkDetails class declaration
+ * UIGlobalSettingsNetworkDetailsNAT class declaration
  */
 
 /*
- * Copyright (C) 2009-2010 Oracle Corporation
+ * Copyright (C) 2009-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -17 +17 @@
  */
 
-#ifndef __UIGlobalSettingsNetworkDetails_h__
-#define __UIGlobalSettingsNetworkDetails_h__
+#ifndef __UIGlobalSettingsNetworkDetailsNAT_h__
+#define __UIGlobalSettingsNetworkDetailsNAT_h__
 
 /* Local includes */
 #include "QIDialog.h"
 #include "QIWithRetranslateUI.h"
-#include "UIGlobalSettingsNetworkDetails.gen.h"
+#include "UIGlobalSettingsNetworkDetailsNAT.gen.h"
 
 /* Forward decalrations: */
-class UIHostInterfaceItem;
+struct UIDataNetworkNAT;
 
 /* Global settings / Network page / Details sub-dialog: */
-class UIGlobalSettingsNetworkDetails : public QIWithRetranslateUI2<QIDialog>, public Ui::UIGlobalSettingsNetworkDetails
+class UIGlobalSettingsNetworkDetailsNAT : public QIWithRetranslateUI2<QIDialog>, public Ui::UIGlobalSettingsNetworkDetailsNAT
 {
     Q_OBJECT;
@@ -36 +36 @@
 
     /* Constructor: */
-    UIGlobalSettingsNetworkDetails(QWidget *pParent);
-
-    /* Get/return data to/from details sub-dialog: */
-    void getFromItem(UIHostInterfaceItem *aItem);
-    void putBackToItem();
+    UIGlobalSettingsNetworkDetailsNAT(QWidget *pParent, UIDataNetworkNAT &data);
 
 protected:
 
-    /* Validation stuff: */
+    /* Handler: Translation stuff: */
     void retranslateUi();
+
+    /* Handler: Polish event: */
+    void polishEvent(QShowEvent *pEvent);
 
 private slots:
 
-    /* Various helper slots: */
-    void sltDhcpClientStatusChanged();
-    void sltDhcpServerStatusChanged();
+    /* Handler: Dialog stuff: */
+    void accept();
 
 private:
 
-    UIHostInterfaceItem *m_pItem;
+    /* Helpers: Load/Save stuff: */
+    void load();
+    void save();
+
+    /* Variable: External data reference: */
+    UIDataNetworkNAT &m_data;
 };
 
-#endif // __UIGlobalSettingsNetworkDetails_h__
-
+#endif /* __UIGlobalSettingsNetworkDetailsNAT_h__ */

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetailsNAT.ui

@@ -3 +3 @@
  VBox frontends: Qt4 GUI ("VirtualBox"):
 
- Copyright (C) 2009-2012 Oracle Corporation
+ Copyright (C) 2009-2013 Oracle Corporation
 
  This file is part of VirtualBox Open Source Edition (OSE), as
@@ -13 +13 @@
  hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
  </comment>
- <class>UIGlobalSettingsNetworkDetails</class>
- <widget class="QWidget" name="UIGlobalSettingsNetworkDetails">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>402</width>
-    <height>255</height>
-   </rect>
+ <class>UIGlobalSettingsNetworkDetailsNAT</class>
+ <widget class="QWidget" name="UIGlobalSettingsNetworkDetailsNAT">
+  <property name="windowTitle">
+   <string>NAT Network Details</string>
   </property>
-  <property name="windowTitle">
-   <string>Host-only Network Details</string>
-  </property>
-  <layout class="QVBoxLayout">
-   <item>
-    <widget class="QITabWidget" name="m_pDetailsTabWidget">
-     <property name="sizePolicy">
-      <sizepolicy vsizetype="Expanding" hsizetype="Preferred">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
+  <layout class="QGridLayout">
+   <item row="0" column="0">
+    <widget class="QCheckBox" name="m_pCheckboxNetwork">
+     <property name="text">
+      <string>Network &amp;Enabled</string>
      </property>
-     <property name="currentIndex">
-      <number>0</number>
+     <property name="toolTip">
+      <string>Enable this NAT network.</string>
      </property>
-     <widget class="QWidget" name="m_pInterfaceTab">
-      <attribute name="title">
-       <string>&amp;Adapter</string>
-      </attribute>
-      <layout class="QGridLayout">
-       <item row="0" column="0" colspan="3">
-        <widget class="QCheckBox" name="m_pEnableManualCheckbox">
-         <property name="text">
-          <string>Manual &amp;Configuration</string>
-         </property>
-         <property name="checked">
-          <bool>true</bool>
-         </property>
-         <property name="toolTip">
-          <string>Use manual configuration for this host-only network adapter.</string>
-         </property>
-        </widget>
-       </item>
-       <item row="1" column="1">
-        <widget class="QLabel" name="m_pIPv4Label">
-         <property name="text">
-          <string>&amp;IPv4 Address:</string>
-         </property>
-         <property name="alignment">
-          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-         </property>
-         <property name="buddy">
-          <cstring>m_pIPv4Editor</cstring>
-         </property>
-        </widget>
-       </item>
-       <item row="1" column="2">
-        <widget class="QILineEdit" name="m_pIPv4Editor">
-         <property name="sizePolicy">
-          <sizepolicy vsizetype="Fixed" hsizetype="Expanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="toolTip">
-          <string>Displays the host IPv4 address for this adapter.</string>
-         </property>
-        </widget>
-       </item>
-       <item row="2" column="1">
-        <widget class="QLabel" name="m_pNMv4Label">
-         <property name="text">
-          <string>IPv4 Network &amp;Mask:</string>
-         </property>
-         <property name="alignment">
-          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-         </property>
-         <property name="buddy">
-          <cstring>m_pNMv4Editor</cstring>
-         </property>
-        </widget>
-       </item>
-       <item row="2" column="2">
-        <widget class="QILineEdit" name="m_pNMv4Editor">
-         <property name="sizePolicy">
-          <sizepolicy vsizetype="Fixed" hsizetype="Expanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="toolTip">
-          <string>Displays the host IPv4 network mask for this adapter.</string>
-         </property>
-        </widget>
-       </item>
-       <item row="3" column="1">
-        <widget class="QLabel" name="m_pIPv6Label">
-         <property name="text">
-          <string>I&amp;Pv6 Address:</string>
-         </property>
-         <property name="alignment">
-          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-         </property>
-         <property name="buddy">
-          <cstring>m_pIPv6Editor</cstring>
-         </property>
-        </widget>
-       </item>
-       <item row="3" column="2">
-        <widget class="QILineEdit" name="m_pIPv6Editor">
-         <property name="sizePolicy">
-          <sizepolicy vsizetype="Fixed" hsizetype="Expanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="toolTip">
-          <string>Displays the host IPv6 address for this adapter if IPv6 is supported.</string>
-         </property>
-        </widget>
-       </item>
-       <item row="4" column="1">
-        <widget class="QLabel" name="m_pNMv6Label">
-         <property name="text">
-          <string>IPv6 Network Mask &amp;Length:</string>
-         </property>
-         <property name="alignment">
-          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-         </property>
-         <property name="buddy">
-          <cstring>m_pNMv6Editor</cstring>
-         </property>
-        </widget>
-       </item>
-       <item row="4" column="2">
-        <widget class="QILineEdit" name="m_pNMv6Editor">
-         <property name="sizePolicy">
-          <sizepolicy vsizetype="Fixed" hsizetype="Expanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="toolTip">
-          <string>Displays the host IPv6 network mask prefix length for this adapter if IPv6 is supported.</string>
-         </property>
-        </widget>
-       </item>
-       <item row="5" column="0" colspan="3">
-        <spacer name="verticalSpacer1">
-         <property name="orientation">
-          <enum>Qt::Vertical</enum>
-         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>0</width>
-           <height>0</height>
-          </size>
-         </property>
-        </spacer>
-       </item>
-      </layout>
-     </widget>
-     <widget class="QWidget" name="m_pDhcpServerTab">
-      <attribute name="title">
-       <string>&amp;DHCP Server</string>
-      </attribute>
-      <layout class="QGridLayout">
-       <item row="0" column="0" colspan="3">
-        <widget class="QCheckBox" name="m_pEnabledDhcpServerCheckbox">
-         <property name="text">
-          <string>&amp;Enable Server</string>
-         </property>
-         <property name="toolTip">
-          <string>Indicates whether the DHCP Server is enabled on machine startup or not.</string>
-         </property>
-        </widget>
-       </item>
-       <item row="1" column="1">
-        <widget class="QLabel" name="m_pDhcpAddressLabel">
-         <property name="text">
-          <string>Server Add&amp;ress:</string>
-         </property>
-         <property name="alignment">
-          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-         </property>
-         <property name="buddy">
-          <cstring>m_pDhcpAddressEditor</cstring>
-         </property>
-        </widget>
-       </item>
-       <item row="1" column="2">
-        <widget class="QILineEdit" name="m_pDhcpAddressEditor">
-         <property name="sizePolicy">
-          <sizepolicy vsizetype="Fixed" hsizetype="Expanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="toolTip">
-          <string>Displays the address of the DHCP server servicing the network associated with this host-only adapter.</string>
-         </property>
-        </widget>
-       </item>
-       <item row="2" column="1">
-        <widget class="QLabel" name="m_pDhcpMaskLabel">
-         <property name="text">
-          <string>Server &amp;Mask:</string>
-         </property>
-         <property name="alignment">
-          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-         </property>
-         <property name="buddy">
-          <cstring>m_pDhcpMaskEditor</cstring>
-         </property>
-        </widget>
-       </item>
-       <item row="2" column="2">
-        <widget class="QILineEdit" name="m_pDhcpMaskEditor">
-         <property name="sizePolicy">
-          <sizepolicy vsizetype="Fixed" hsizetype="Expanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="toolTip">
-          <string>Displays the network mask of the DHCP server servicing the network associated with this host-only adapter.</string>
-         </property>
-        </widget>
-       </item>
-       <item row="3" column="1">
-        <widget class="QLabel" name="m_pDhcpLowerAddressLabel">
-         <property name="text">
-          <string>&amp;Lower Address Bound:</string>
-         </property>
-         <property name="alignment">
-          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-         </property>
-         <property name="buddy">
-          <cstring>m_pDhcpLowerAddressEditor</cstring>
-         </property>
-        </widget>
-       </item>
-       <item row="3" column="2">
-        <widget class="QILineEdit" name="m_pDhcpLowerAddressEditor">
-         <property name="sizePolicy">
-          <sizepolicy vsizetype="Fixed" hsizetype="Expanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="toolTip">
-          <string>Displays the lower address bound offered by the DHCP server servicing the network associated with this host-only adapter.</string>
-         </property>
-        </widget>
-       </item>
-       <item row="4" column="1">
-        <widget class="QLabel" name="m_pDhcpUpperAddressLabel">
-         <property name="text">
-          <string>&amp;Upper Address Bound:</string>
-         </property>
-         <property name="alignment">
-          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-         </property>
-         <property name="buddy">
-          <cstring>m_pDhcpUpperAddressEditor</cstring>
-         </property>
-        </widget>
-       </item>
-       <item row="4" column="2">
-        <widget class="QILineEdit" name="m_pDhcpUpperAddressEditor">
-         <property name="sizePolicy">
-          <sizepolicy vsizetype="Fixed" hsizetype="Expanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="toolTip">
-          <string>Displays the upper address bound offered by the DHCP server servicing the network associated with this host-only adapter.</string>
-         </property>
-        </widget>
-       </item>
-       <item row="5" column="0" colspan="3">
-        <spacer name="verticalSpacer2">
-         <property name="orientation">
-          <enum>Qt::Vertical</enum>
-         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>0</width>
-           <height>0</height>
-          </size>
-         </property>
-        </spacer>
-       </item>
-      </layout>
-     </widget>
     </widget>
    </item>
-   <item>
+   <item row="1" column="0" colspan="2">
+    <widget class="QWidget" name="m_pContainerOptions">
+     <layout class="QGridLayout">
+      <item row="0" column="0" rowspan="3">
+       <spacer>
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeType">
+         <enum>QSizePolicy::Fixed</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>0</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item row="0" column="1">
+       <widget class="QLabel" name="m_pLabelNetworkName">
+        <property name="text">
+         <string>Network &amp;Name:</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+        </property>
+        <property name="buddy">
+         <cstring>m_pEditorNetworkName</cstring>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="2" colspan="2">
+       <widget class="QLineEdit" name="m_pEditorNetworkName">
+        <property name="toolTip">
+         <string>Displays the name for this network.</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="QLabel" name="m_pLabelNetworkCIDR">
+        <property name="text">
+         <string>Network &amp;CIDR:</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+        </property>
+        <property name="buddy">
+         <cstring>m_pEditorNetworkCIDR</cstring>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="2" colspan="2">
+       <widget class="QLineEdit" name="m_pEditorNetworkCIDR">
+        <property name="toolTip">
+         <string>Displays the CIDR for this network.</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QLabel" name="m_pLabelOptionsAdvanced">
+        <property name="alignment">
+         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignTop</set>
+        </property>
+        <property name="text">
+         <string>Network Options:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="2">
+       <widget class="QCheckBox" name="m_pCheckboxSupportsDHCP">
+        <property name="text">
+         <string>Supports &amp;DHCP</string>
+        </property>
+        <property name="toolTip">
+         <string>Determines whether this network supports DHCP.</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="2">
+       <widget class="QCheckBox" name="m_pCheckboxSupportsIPv6">
+        <property name="text">
+         <string>Supports &amp;IPv6</string>
+        </property>
+        <property name="toolTip">
+         <string>Determines whether this network supports IPv6.</string>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="2">
+       <widget class="QCheckBox" name="m_pCheckboxAdvertiseDefaultIPv6Route">
+        <property name="text">
+         <string>Advertise Default IPv6 &amp;Route</string>
+        </property>
+        <property name="toolTip">
+         <string>Determines whether default IPv6 route should be advertised for this network.</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item row="2" column="0" colspan="2">
+    <spacer>
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>0</width>
+       <height>0</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="3" column="0" colspan="2">
     <widget class="QIDialogButtonBox" name="m_pButtonBox">
      <property name="standardButtons">
@@ -322 +155 @@
  <customwidgets>
   <customwidget>
-   <class>QILineEdit</class>
-   <extends>QLineEdit</extends>
-   <header>QILineEdit.h</header>
-  </customwidget>
-  <customwidget>
    <class>QIDialogButtonBox</class>
    <extends>QDialogButtonBox</extends>
    <header>QIDialogButtonBox.h</header>
-  </customwidget>
-  <customwidget>
-   <class>QITabWidget</class>
-   <extends>QTabWidget</extends>
-   <header>QITabWidget.h</header>
   </customwidget>
  </customwidgets>
@@ -340 +163 @@
  <connections>
   <connection>
+   <sender>m_pCheckboxNetwork</sender>
+   <signal>toggled(bool)</signal>
+   <receiver>m_pContainerOptions</receiver>
+   <slot>setEnabled(bool)</slot>
+  </connection>
+  <connection>
+   <sender>m_pCheckboxSupportsIPv6</sender>
+   <signal>toggled(bool)</signal>
+   <receiver>m_pCheckboxAdvertiseDefaultIPv6Route</receiver>
+   <slot>setEnabled(bool)</slot>
+  </connection>
+  <connection>
    <sender>m_pButtonBox</sender>
    <signal>accepted()</signal>
-   <receiver>UIGlobalSettingsNetworkDetails</receiver>
+   <receiver>UIGlobalSettingsNetworkDetailsNAT</receiver>
    <slot>accept()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>162</x>
-     <y>339</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>162</x>
-     <y>179</y>
-    </hint>
-   </hints>
   </connection>
   <connection>
    <sender>m_pButtonBox</sender>
    <signal>rejected()</signal>
-   <receiver>UIGlobalSettingsNetworkDetails</receiver>
+   <receiver>UIGlobalSettingsNetworkDetailsNAT</receiver>
    <slot>reject()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>162</x>
-     <y>339</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>162</x>
-     <y>179</y>
-    </hint>
-   </hints>
   </connection>
  </connections>