VirtualBox

Changeset 67017 in vbox for trunk


Ignore:
Timestamp:
May 22, 2017 2:44:36 PM (7 years ago)
Author:
vboxsync
Message:

FE/Qt: Extensions: QIManagerDialog, a new QMainWindow extension to be used with various managers like Virtual Media and Host Network one.

Location:
trunk/src/VBox/Frontends/VirtualBox
Files:
1 edited
2 copied

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

    r66856 r67017  
    311311        src/extensions/QIMainDialog.h \
    312312        src/extensions/QIMainWindow.h \
     313        src/extensions/QIManagerDialog.h \
    313314        src/extensions/QIMenu.h \
    314315        src/extensions/QIMessageBox.h \
     
    612613        src/extensions/QIMainDialog.cpp \
    613614        src/extensions/QIMainWindow.cpp \
     615        src/extensions/QIManagerDialog.cpp \
    614616        src/extensions/QIMenu.cpp \
    615617        src/extensions/QIMessageBox.cpp \
  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIManagerDialog.cpp

    r66972 r67017  
    11/* $Id$ */
    22/** @file
    3  * VBox Qt GUI - UIHostNetworkManager class implementation.
     3 * VBox Qt GUI - QIManagerDialog class implementation.
    44 */
    55
     
    2121
    2222/* Qt includes: */
    23 # include <QHeaderView>
    2423# include <QMenuBar>
    2524# include <QPushButton>
     
    2726/* GUI includes: */
    2827# include "QIDialogButtonBox.h"
    29 # include "QITreeWidget.h"
    30 # include "UIIconPool.h"
    31 # include "UIHostNetworkDetailsDialog.h"
    32 # include "UIHostNetworkManager.h"
    33 # include "UIHostNetworkUtils.h"
    34 # include "UIMessageCenter.h"
    35 # include "UIToolBar.h"
     28# include "QIManagerDialog.h"
     29# include "UIDesktopWidgetWatchdog.h"
    3630# ifdef VBOX_WS_MAC
     31#  include "UIToolBar.h"
    3732#  include "UIWindowMenuManager.h"
    3833# endif /* VBOX_WS_MAC */
     34# include "UIMessageCenter.h"
    3935# include "VBoxGlobal.h"
    40 
    41 /* COM includes: */
    42 # include "CDHCPServer.h"
    43 # include "CHost.h"
    44 # include "CHostNetworkInterface.h"
    45 
    46 /* Other VBox includes: */
    47 # include <iprt/cidr.h>
    4836
    4937#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    5038
    5139
    52 /** Tree-widget column tags. */
    53 enum
    54 {
    55     Column_Name,
    56     Column_IPv4,
    57     Column_IPv6,
    58     Column_DHCP,
    59     Column_Max,
    60 };
    61 
    62 
    63 /** Host Network Manager: Tree-widget item. */
    64 class UIItemHostNetwork : public QITreeWidgetItem, public UIDataHostNetwork
    65 {
    66 public:
    67 
    68     /** Updates item fields from data. */
    69     void updateFields();
    70 
    71     /** Returns item name. */
    72     QString name() const { return m_interface.m_strName; }
    73 
    74 private:
    75 
    76     /** Returns CIDR for a passed @a strMask. */
    77     static int maskToCidr(const QString &strMask);
    78 };
    79 
    80 
    8140/*********************************************************************************************************************************
    82 *   Class UIItemHostNetwork implementation.                                                                                      *
     41*   Class QIManagerDialogFactory implementation.                                                                                 *
    8342*********************************************************************************************************************************/
    8443
    85 void UIItemHostNetwork::updateFields()
     44void QIManagerDialogFactory::prepare(QIManagerDialog *&pDialog, QWidget *pCenterWidget /* = 0 */)
    8645{
    87     /* Compose item fields: */
    88     setText(Column_Name, m_interface.m_strName);
    89     setText(Column_IPv4, m_interface.m_strAddress.isEmpty() ? QString() :
    90                          QString("%1/%2").arg(m_interface.m_strAddress).arg(maskToCidr(m_interface.m_strMask)));
    91     setText(Column_IPv6, m_interface.m_strAddress6.isEmpty() || !m_interface.m_fSupportedIPv6 ? QString() :
    92                          QString("%1/%2").arg(m_interface.m_strAddress6).arg(m_interface.m_strMaskLength6.toInt()));
    93     setText(Column_DHCP, UIHostNetworkManager::tr("Enable", "DHCP Server"));
    94     setCheckState(Column_DHCP, m_dhcpserver.m_fEnabled ? Qt::Checked : Qt::Unchecked);
    95 
    96     /* Compose item tool-tip: */
    97     const QString strTable("<table cellspacing=5>%1</table>");
    98     const QString strHeader("<tr><td><nobr>%1:&nbsp;</nobr></td><td><nobr>%2</nobr></td></tr>");
    99     const QString strSubHeader("<tr><td><nobr>&nbsp;&nbsp;%1:&nbsp;</nobr></td><td><nobr>%2</nobr></td></tr>");
    100     QString strToolTip;
    101 
    102     /* Interface information: */
    103     strToolTip += strHeader.arg(UIHostNetworkManager::tr("Adapter"))
    104                            .arg(m_interface.m_fDHCPEnabled ?
    105                                 UIHostNetworkManager::tr("Automatically configured", "interface") :
    106                                 UIHostNetworkManager::tr("Manually configured", "interface"));
    107     strToolTip += strSubHeader.arg(UIHostNetworkManager::tr("IPv4 Address"))
    108                               .arg(m_interface.m_strAddress.isEmpty() ?
    109                                    UIHostNetworkManager::tr ("Not set", "address") :
    110                                    m_interface.m_strAddress) +
    111                   strSubHeader.arg(UIHostNetworkManager::tr("IPv4 Network Mask"))
    112                               .arg(m_interface.m_strMask.isEmpty() ?
    113                                    UIHostNetworkManager::tr ("Not set", "mask") :
    114                                    m_interface.m_strMask);
    115     if (m_interface.m_fSupportedIPv6)
    116     {
    117         strToolTip += strSubHeader.arg(UIHostNetworkManager::tr("IPv6 Address"))
    118                                   .arg(m_interface.m_strAddress6.isEmpty() ?
    119                                        UIHostNetworkManager::tr("Not set", "address") :
    120                                        m_interface.m_strAddress6) +
    121                       strSubHeader.arg(UIHostNetworkManager::tr("IPv6 Network Mask Length"))
    122                                   .arg(m_interface.m_strMaskLength6.isEmpty() ?
    123                                        UIHostNetworkManager::tr("Not set", "length") :
    124                                        m_interface.m_strMaskLength6);
    125     }
    126 
    127     /* DHCP server information: */
    128     strToolTip += strHeader.arg(UIHostNetworkManager::tr("DHCP Server"))
    129                            .arg(m_dhcpserver.m_fEnabled ?
    130                                 UIHostNetworkManager::tr("Enabled", "server") :
    131                                 UIHostNetworkManager::tr("Disabled", "server"));
    132     if (m_dhcpserver.m_fEnabled)
    133     {
    134         strToolTip += strSubHeader.arg(UIHostNetworkManager::tr("Address"))
    135                                   .arg(m_dhcpserver.m_strAddress.isEmpty() ?
    136                                        UIHostNetworkManager::tr("Not set", "address") :
    137                                        m_dhcpserver.m_strAddress) +
    138                       strSubHeader.arg(UIHostNetworkManager::tr("Network Mask"))
    139                                   .arg(m_dhcpserver.m_strMask.isEmpty() ?
    140                                        UIHostNetworkManager::tr("Not set", "mask") :
    141                                        m_dhcpserver.m_strMask) +
    142                       strSubHeader.arg(UIHostNetworkManager::tr("Lower Bound"))
    143                                   .arg(m_dhcpserver.m_strLowerAddress.isEmpty() ?
    144                                        UIHostNetworkManager::tr("Not set", "bound") :
    145                                        m_dhcpserver.m_strLowerAddress) +
    146                       strSubHeader.arg(UIHostNetworkManager::tr("Upper Bound"))
    147                                   .arg(m_dhcpserver.m_strUpperAddress.isEmpty() ?
    148                                        UIHostNetworkManager::tr("Not set", "bound") :
    149                                        m_dhcpserver.m_strUpperAddress);
    150     }
    151 
    152     /* Assign tool-tip finally: */
    153     setToolTip(Column_Name, strTable.arg(strToolTip));
     46    create(pDialog, pCenterWidget);
     47    pDialog->prepare();
    15448}
    15549
    156 /* static */
    157 int UIItemHostNetwork::maskToCidr(const QString &strMask)
     50void QIManagerDialogFactory::cleanup(QIManagerDialog *&pDialog)
    15851{
    159     /* Parse passed mask: */
    160     QList<int> address;
    161     foreach (const QString &strValue, strMask.split('.'))
    162         address << strValue.toInt();
    163 
    164     /* Calculate CIDR: */
    165     int iCidr = 0;
    166     for (int i = 0; i < 4 || i < address.size(); ++i)
    167     {
    168         switch(address.at(i))
    169         {
    170             case 0x80: iCidr += 1; break;
    171             case 0xC0: iCidr += 2; break;
    172             case 0xE0: iCidr += 3; break;
    173             case 0xF0: iCidr += 4; break;
    174             case 0xF8: iCidr += 5; break;
    175             case 0xFC: iCidr += 6; break;
    176             case 0xFE: iCidr += 7; break;
    177             case 0xFF: iCidr += 8; break;
    178             /* Return CIDR prematurelly: */
    179             default: return iCidr;
    180         }
    181     }
    182 
    183     /* Return CIDR: */
    184     return iCidr;
     52    pDialog->cleanup();
     53    delete pDialog;
     54    pDialog = 0;
    18555}
    18656
    18757
    18858/*********************************************************************************************************************************
    189 *   Class UIHostNetworkManagerWidget implementation.                                                                             *
     59*   Class QIManagerDialog implementation.                                                                                        *
    19060*********************************************************************************************************************************/
    19161
    192 UIHostNetworkManagerWidget::UIHostNetworkManagerWidget(QWidget *pParent /* = 0 */)
    193     : QIWithRetranslateUI<QWidget>(pParent)
    194     , m_pToolBar(0)
    195     , m_pMenu(0)
    196     , m_pActionAdd(0)
    197     , m_pActionRemove(0)
    198     , m_pActionDetails(0)
    199     , m_pActionCommit(0)
    200     , m_pTreeWidget(0)
    201     , m_pDetailsWidget(0)
     62QIManagerDialog::QIManagerDialog(QWidget *pCenterWidget)
     63    : pCenterWidget(pCenterWidget)
     64    , m_pWidget(0)
     65    , m_pWidgetMenu(0)
     66#ifdef VBOX_WS_MAC
     67    , m_pWidgetToolbar(0)
     68#endif
     69    , m_pButtonBox(0)
    20270{
    203     /* Prepare: */
    204     prepare();
    20571}
    20672
    207 void UIHostNetworkManagerWidget::retranslateUi()
     73void QIManagerDialog::closeEvent(QCloseEvent *pEvent)
    20874{
    209     /* Translate menu: */
    210     if (m_pMenu)
    211         m_pMenu->setTitle(UIHostNetworkManager::tr("&Network"));
    212 
    213     /* Translate actions: */
    214     if (m_pActionAdd)
    215     {
    216         m_pActionAdd->setText(UIHostNetworkManager::tr("&Create"));
    217         m_pActionAdd->setToolTip(UIHostNetworkManager::tr("Create Host-only Network (%1)").arg(m_pActionAdd->shortcut().toString()));
    218         m_pActionAdd->setStatusTip(UIHostNetworkManager::tr("Creates new host-only network."));
    219     }
    220     if (m_pActionRemove)
    221     {
    222         m_pActionRemove->setText(UIHostNetworkManager::tr("&Remove..."));
    223         m_pActionRemove->setToolTip(UIHostNetworkManager::tr("Remove Host-only Network (%1)").arg(m_pActionRemove->shortcut().toString()));
    224         m_pActionRemove->setStatusTip(UIHostNetworkManager::tr("Removes selected host-only network."));
    225     }
    226     if (m_pActionDetails)
    227     {
    228         m_pActionDetails->setText(UIHostNetworkManager::tr("&Details..."));
    229         m_pActionDetails->setToolTip(UIHostNetworkManager::tr("Open Host-only Network Details (%1)").arg(m_pActionDetails->shortcut().toString()));
    230         m_pActionDetails->setStatusTip(UIHostNetworkManager::tr("Opens pane with the selected host-only network details."));
    231     }
    232     if (m_pActionCommit)
    233     {
    234         m_pActionCommit->setText(UIHostNetworkManager::tr("&Apply..."));
    235         m_pActionCommit->setToolTip(UIHostNetworkManager::tr("Apply Changes in Host-only Network Details (%1)").arg(m_pActionCommit->shortcut().toString()));
    236         m_pActionCommit->setStatusTip(UIHostNetworkManager::tr("Applies changes in host-only network details pane."));
    237     }
    238 
    239     /* Adjust toolbar: */
    240 #ifdef VBOX_WS_MAC
    241     // WORKAROUND:
    242     // There is a bug in Qt Cocoa which result in showing a "more arrow" when
    243     // the necessary size of the toolbar is increased. Also for some languages
    244     // the with doesn't match if the text increase. So manually adjust the size
    245     // after changing the text.
    246     if (m_pToolBar)
    247         m_pToolBar->updateLayout();
    248 #endif
    249 
    250     /* Translate tree-widget: */
    251     const QStringList fields = QStringList()
    252                                << UIHostNetworkManager::tr("Name")
    253                                << UIHostNetworkManager::tr("IPv4 Address/Mask")
    254                                << UIHostNetworkManager::tr("IPv6 Address/Mask")
    255                                << UIHostNetworkManager::tr("DHCP Server");
    256     m_pTreeWidget->setHeaderLabels(fields);
     75    /* Ignore the event itself: */
     76    pEvent->ignore();
     77    /* But tell the listener to close us: */
     78    emit sigClose();
    25779}
    25880
    259 void UIHostNetworkManagerWidget::resizeEvent(QResizeEvent *pEvent)
     81void QIManagerDialog::prepare()
    26082{
    261     /* Call to base-class: */
    262     QIWithRetranslateUI<QWidget>::resizeEvent(pEvent);
    263 
    264     /* Adjust tree-widget: */
    265     sltAdjustTreeWidget();
    266 }
    267 
    268 void UIHostNetworkManagerWidget::showEvent(QShowEvent *pEvent)
    269 {
    270     /* Call to base-class: */
    271     QIWithRetranslateUI<QWidget>::showEvent(pEvent);
    272 
    273     /* Adjust tree-widget: */
    274     sltAdjustTreeWidget();
    275 }
    276 
    277 void UIHostNetworkManagerWidget::sltAddHostNetwork()
    278 {
    279     /* Get host for further activities: */
    280     CHost comHost = vboxGlobal().host();
    281 
    282     /* Create interface: */
    283     CHostNetworkInterface comInterface;
    284     CProgress progress = comHost.CreateHostOnlyNetworkInterface(comInterface);
    285 
    286     /* Show error message if necessary: */
    287     if (!comHost.isOk() || progress.isNull())
    288         msgCenter().cannotCreateHostNetworkInterface(comHost, this);
    289     else
    290     {
    291         /* Show interface creation progress: */
    292         msgCenter().showModalProgressDialog(progress, tr("Networking"), ":/progress_network_interface_90px.png", this, 0);
    293 
    294         /* Show error message if necessary: */
    295         if (!progress.isOk() || progress.GetResultCode() != 0)
    296             msgCenter().cannotCreateHostNetworkInterface(progress, this);
    297         else
    298         {
    299             /* Get network name for further activities: */
    300             const QString strNetworkName = comInterface.GetNetworkName();
    301 
    302             /* Show error message if necessary: */
    303             if (!comInterface.isOk())
    304                 msgCenter().cannotAcquireHostNetworkInterfaceParameter(comInterface, this);
    305             else
    306             {
    307                 /* Get VBox for further activities: */
    308                 CVirtualBox comVBox = vboxGlobal().virtualBox();
    309 
    310                 /* Find corresponding DHCP server (create if necessary): */
    311                 CDHCPServer comServer = comVBox.FindDHCPServerByNetworkName(strNetworkName);
    312                 if (!comVBox.isOk() || comServer.isNull())
    313                     comServer = comVBox.CreateDHCPServer(strNetworkName);
    314 
    315                 /* Show error message if necessary: */
    316                 if (!comVBox.isOk() || comServer.isNull())
    317                     msgCenter().cannotCreateDHCPServer(comVBox, strNetworkName, this);
    318             }
    319 
    320             /* Add interface to the tree: */
    321             UIDataHostNetwork data;
    322             loadHostNetwork(comInterface, data);
    323             createItemForNetworkHost(data, true);
    324 
    325             /* Adjust tree-widget: */
    326             sltAdjustTreeWidget();
    327         }
    328     }
    329 }
    330 
    331 void UIHostNetworkManagerWidget::sltRemoveHostNetwork()
    332 {
    333     /* Get network item: */
    334     UIItemHostNetwork *pItem = static_cast<UIItemHostNetwork*>(m_pTreeWidget->currentItem());
    335     AssertMsgReturnVoid(pItem, ("Current item must not be null!\n"));
    336 
    337     /* Get interface name: */
    338     const QString strInterfaceName(pItem->name());
    339 
    340     /* Confirm host network removal: */
    341     if (!msgCenter().confirmHostOnlyInterfaceRemoval(strInterfaceName, this))
    342         return;
    343 
    344     /* Get host for further activities: */
    345     CHost comHost = vboxGlobal().host();
    346 
    347     /* Find corresponding interface: */
    348     const CHostNetworkInterface &comInterface = comHost.FindHostNetworkInterfaceByName(strInterfaceName);
    349 
    350     /* Show error message if necessary: */
    351     if (!comHost.isOk() || comInterface.isNull())
    352         msgCenter().cannotFindHostNetworkInterface(comHost, strInterfaceName, this);
    353     else
    354     {
    355         /* Get network name for further activities: */
    356         QString strNetworkName;
    357         if (comInterface.isOk())
    358             strNetworkName = comInterface.GetNetworkName();
    359         /* Get interface id for further activities: */
    360         QString strInterfaceId;
    361         if (comInterface.isOk())
    362             strInterfaceId = comInterface.GetId();
    363 
    364         /* Show error message if necessary: */
    365         if (!comInterface.isOk())
    366             msgCenter().cannotAcquireHostNetworkInterfaceParameter(comInterface, this);
    367         else
    368         {
    369             /* Get VBox for further activities: */
    370             CVirtualBox comVBox = vboxGlobal().virtualBox();
    371 
    372             /* Find corresponding DHCP server: */
    373             const CDHCPServer &comServer = comVBox.FindDHCPServerByNetworkName(strNetworkName);
    374             if (comVBox.isOk() && comServer.isNotNull())
    375             {
    376                 /* Remove server if any: */
    377                 comVBox.RemoveDHCPServer(comServer);
    378 
    379                 /* Show error message if necessary: */
    380                 if (!comVBox.isOk())
    381                     msgCenter().cannotRemoveDHCPServer(comVBox, strInterfaceName, this);
    382             }
    383 
    384             /* Remove interface finally: */
    385             CProgress progress = comHost.RemoveHostOnlyNetworkInterface(strInterfaceId);
    386 
    387             /* Show error message if necessary: */
    388             if (!comHost.isOk() || progress.isNull())
    389                 msgCenter().cannotRemoveHostNetworkInterface(comHost, strInterfaceName, this);
    390             else
    391             {
    392                 /* Show interface removal progress: */
    393                 msgCenter().showModalProgressDialog(progress, tr("Networking"), ":/progress_network_interface_90px.png", this, 0);
    394 
    395                 /* Show error message if necessary: */
    396                 if (!progress.isOk() || progress.GetResultCode() != 0)
    397                     return msgCenter().cannotRemoveHostNetworkInterface(progress, strInterfaceName, this);
    398                 else
    399                 {
    400                     /* Remove interface from the tree: */
    401                     delete pItem;
    402 
    403                     /* Adjust tree-widget: */
    404                     sltAdjustTreeWidget();
    405                 }
    406             }
    407         }
    408     }
    409 }
    410 
    411 void UIHostNetworkManagerWidget::sltToggleHostNetworkDetailsVisibility(bool fShow)
    412 {
    413     /* Show/hide details area and Apply button: */
    414     m_pDetailsWidget->setVisible(fShow);
    415     m_pActionCommit->setVisible(fShow);
    416 }
    417 
    418 void UIHostNetworkManagerWidget::sltApplyHostNetworkDetailsChanges()
    419 {
    420     /* Disable button first of all: */
    421     m_pActionCommit->setEnabled(false);
    422 
    423     /* Get network item: */
    424     UIItemHostNetwork *pItem = static_cast<UIItemHostNetwork*>(m_pTreeWidget->currentItem());
    425     AssertMsgReturnVoid(pItem, ("Current item must not be null!\n"));
    426 
    427     /* Get item data: */
    428     UIDataHostNetwork oldData = *pItem;
    429     UIDataHostNetwork newData = m_pDetailsWidget->data();
    430 
    431     /* Get host for further activities: */
    432     CHost comHost = vboxGlobal().host();
    433 
    434     /* Find corresponding interface: */
    435     CHostNetworkInterface comInterface = comHost.FindHostNetworkInterfaceByName(oldData.m_interface.m_strName);
    436 
    437     /* Show error message if necessary: */
    438     if (!comHost.isOk() || comInterface.isNull())
    439         msgCenter().cannotFindHostNetworkInterface(comHost, oldData.m_interface.m_strName, this);
    440     else
    441     {
    442         /* Save automatic interface configuration: */
    443         if (newData.m_interface.m_fDHCPEnabled)
    444         {
    445             if (   comInterface.isOk()
    446                 && !oldData.m_interface.m_fDHCPEnabled)
    447                 comInterface.EnableDynamicIPConfig();
    448         }
    449         /* Save manual interface configuration: */
    450         else
    451         {
    452             /* Save IPv4 interface configuration: */
    453             if (   comInterface.isOk()
    454                 && (   oldData.m_interface.m_fDHCPEnabled
    455                     || newData.m_interface.m_strAddress != oldData.m_interface.m_strAddress
    456                     || newData.m_interface.m_strMask != oldData.m_interface.m_strMask))
    457                 comInterface.EnableStaticIPConfig(newData.m_interface.m_strAddress, newData.m_interface.m_strMask);
    458             /* Save IPv6 interface configuration: */
    459             if (   comInterface.isOk()
    460                 && newData.m_interface.m_fSupportedIPv6
    461                 && (   oldData.m_interface.m_fDHCPEnabled
    462                     || newData.m_interface.m_strAddress6 != oldData.m_interface.m_strAddress6
    463                     || newData.m_interface.m_strMaskLength6 != oldData.m_interface.m_strMaskLength6))
    464                 comInterface.EnableStaticIPConfigV6(newData.m_interface.m_strAddress6, newData.m_interface.m_strMaskLength6.toULong());
    465         }
    466 
    467         /* Show error message if necessary: */
    468         if (!comInterface.isOk())
    469             msgCenter().cannotSaveHostNetworkInterfaceParameter(comInterface, this);
    470         else
    471         {
    472             /* Get network name for further activities: */
    473             const QString strNetworkName = comInterface.GetNetworkName();
    474 
    475             /* Show error message if necessary: */
    476             if (!comInterface.isOk())
    477                 msgCenter().cannotAcquireHostNetworkInterfaceParameter(comInterface, this);
    478             else
    479             {
    480                 /* Get VBox for further activities: */
    481                 CVirtualBox comVBox = vboxGlobal().virtualBox();
    482 
    483                 /* Find corresponding DHCP server (create if necessary): */
    484                 CDHCPServer comServer = comVBox.FindDHCPServerByNetworkName(strNetworkName);
    485                 if (!comVBox.isOk() || comServer.isNull())
    486                     comServer = comVBox.CreateDHCPServer(strNetworkName);
    487 
    488                 /* Show error message if necessary: */
    489                 if (!comVBox.isOk() || comServer.isNull())
    490                     msgCenter().cannotCreateDHCPServer(comVBox, strNetworkName, this);
    491                 else
    492                 {
    493                     /* Save whether DHCP server is enabled: */
    494                     if (   comServer.isOk()
    495                         && newData.m_dhcpserver.m_fEnabled != oldData.m_dhcpserver.m_fEnabled)
    496                         comServer.SetEnabled(newData.m_dhcpserver.m_fEnabled);
    497                     /* Save DHCP server configuration: */
    498                     if (   comServer.isOk()
    499                         && newData.m_dhcpserver.m_fEnabled
    500                         && (   newData.m_dhcpserver.m_strAddress != oldData.m_dhcpserver.m_strAddress
    501                             || newData.m_dhcpserver.m_strMask != oldData.m_dhcpserver.m_strMask
    502                             || newData.m_dhcpserver.m_strLowerAddress != oldData.m_dhcpserver.m_strLowerAddress
    503                             || newData.m_dhcpserver.m_strUpperAddress != oldData.m_dhcpserver.m_strUpperAddress))
    504                         comServer.SetConfiguration(newData.m_dhcpserver.m_strAddress, newData.m_dhcpserver.m_strMask,
    505                                                    newData.m_dhcpserver.m_strLowerAddress, newData.m_dhcpserver.m_strUpperAddress);
    506 
    507                     /* Show error message if necessary: */
    508                     if (!comServer.isOk())
    509                         msgCenter().cannotSaveDHCPServerParameter(comServer, this);
    510                 }
    511             }
    512         }
    513 
    514         /* Find corresponding interface again (if necessary): */
    515         if (!comInterface.isOk())
    516         {
    517             comInterface = comHost.FindHostNetworkInterfaceByName(oldData.m_interface.m_strName);
    518 
    519             /* Show error message if necessary: */
    520             if (!comHost.isOk() || comInterface.isNull())
    521                 msgCenter().cannotFindHostNetworkInterface(comHost, oldData.m_interface.m_strName, this);
    522         }
    523 
    524         /* If interface is Ok now: */
    525         if (comInterface.isNotNull() && comInterface.isOk())
    526         {
    527             /* Update interface in the tree: */
    528             UIDataHostNetwork data;
    529             loadHostNetwork(comInterface, data);
    530             updateItemForNetworkHost(data, true, pItem);
    531 
    532             /* Make sure current item fetched: */
    533             sltHandleCurrentItemChange();
    534 
    535             /* Adjust tree-widget: */
    536             sltAdjustTreeWidget();
    537         }
    538     }
    539 }
    540 
    541 void UIHostNetworkManagerWidget::sltAdjustTreeWidget()
    542 {
    543     /* Get the tree-widget abstract interface: */
    544     QAbstractItemView *pItemView = m_pTreeWidget;
    545     /* Get the tree-widget header-view: */
    546     QHeaderView *pItemHeader = m_pTreeWidget->header();
    547 
    548     /* Calculate the total tree-widget width: */
    549     const int iTotal = m_pTreeWidget->viewport()->width();
    550     /* Look for a minimum width hints for non-important columns: */
    551     const int iMinWidth1 = qMax(pItemView->sizeHintForColumn(Column_IPv4), pItemHeader->sectionSizeHint(Column_IPv4));
    552     const int iMinWidth2 = qMax(pItemView->sizeHintForColumn(Column_IPv6), pItemHeader->sectionSizeHint(Column_IPv6));
    553     const int iMinWidth3 = qMax(pItemView->sizeHintForColumn(Column_DHCP), pItemHeader->sectionSizeHint(Column_DHCP));
    554     /* Propose suitable width hints for non-important columns: */
    555     const int iWidth1 = iMinWidth1 < iTotal / Column_Max ? iMinWidth1 : iTotal / Column_Max;
    556     const int iWidth2 = iMinWidth2 < iTotal / Column_Max ? iMinWidth2 : iTotal / Column_Max;
    557     const int iWidth3 = iMinWidth3 < iTotal / Column_Max ? iMinWidth3 : iTotal / Column_Max;
    558     /* Apply the proposal: */
    559     m_pTreeWidget->setColumnWidth(Column_IPv4, iWidth1);
    560     m_pTreeWidget->setColumnWidth(Column_IPv6, iWidth2);
    561     m_pTreeWidget->setColumnWidth(Column_DHCP, iWidth3);
    562     m_pTreeWidget->setColumnWidth(Column_Name, iTotal - iWidth1 - iWidth2 - iWidth3);
    563 }
    564 
    565 void UIHostNetworkManagerWidget::sltHandleItemChange(QTreeWidgetItem *pItem)
    566 {
    567     /* Get network item: */
    568     UIItemHostNetwork *pChangedItem = static_cast<UIItemHostNetwork*>(pItem);
    569     AssertMsgReturnVoid(pChangedItem, ("Changed item must not be null!\n"));
    570 
    571     /* Get item data: */
    572     UIDataHostNetwork oldData = *pChangedItem;
    573 
    574     /* Make sure dhcp server status changed: */
    575     if (   (   oldData.m_dhcpserver.m_fEnabled
    576             && pChangedItem->checkState(Column_DHCP) == Qt::Checked)
    577         || (   !oldData.m_dhcpserver.m_fEnabled
    578             && pChangedItem->checkState(Column_DHCP) == Qt::Unchecked))
    579         return;
    580 
    581     /* Get host for further activities: */
    582     CHost comHost = vboxGlobal().host();
    583 
    584     /* Find corresponding interface: */
    585     CHostNetworkInterface comInterface = comHost.FindHostNetworkInterfaceByName(oldData.m_interface.m_strName);
    586 
    587     /* Show error message if necessary: */
    588     if (!comHost.isOk() || comInterface.isNull())
    589         msgCenter().cannotFindHostNetworkInterface(comHost, oldData.m_interface.m_strName, this);
    590     else
    591     {
    592         /* Get network name for further activities: */
    593         const QString strNetworkName = comInterface.GetNetworkName();
    594 
    595         /* Show error message if necessary: */
    596         if (!comInterface.isOk())
    597             msgCenter().cannotAcquireHostNetworkInterfaceParameter(comInterface, this);
    598         else
    599         {
    600             /* Get VBox for further activities: */
    601             CVirtualBox comVBox = vboxGlobal().virtualBox();
    602 
    603             /* Find corresponding DHCP server (create if necessary): */
    604             CDHCPServer comServer = comVBox.FindDHCPServerByNetworkName(strNetworkName);
    605             if (!comVBox.isOk() || comServer.isNull())
    606                 comServer = comVBox.CreateDHCPServer(strNetworkName);
    607 
    608             /* Show error message if necessary: */
    609             if (!comVBox.isOk() || comServer.isNull())
    610                 msgCenter().cannotCreateDHCPServer(comVBox, strNetworkName, this);
    611             else
    612             {
    613                 /* Save whether DHCP server is enabled: */
    614                 if (comServer.isOk())
    615                     comServer.SetEnabled(!oldData.m_dhcpserver.m_fEnabled);
    616                 /* Save default DHCP server configuration if current is invalid: */
    617                 if (   comServer.isOk()
    618                     && !oldData.m_dhcpserver.m_fEnabled
    619                     && (   oldData.m_dhcpserver.m_strAddress == "0.0.0.0"
    620                         || oldData.m_dhcpserver.m_strMask == "0.0.0.0"
    621                         || oldData.m_dhcpserver.m_strLowerAddress == "0.0.0.0"
    622                         || oldData.m_dhcpserver.m_strUpperAddress == "0.0.0.0"))
    623                 {
    624                     const QStringList &proposal = makeDhcpServerProposal(oldData.m_interface.m_strAddress,
    625                                                                          oldData.m_interface.m_strMask);
    626                     comServer.SetConfiguration(proposal.at(0), proposal.at(1), proposal.at(2), proposal.at(3));
    627                 }
    628 
    629                 /* Show error message if necessary: */
    630                 if (!comServer.isOk())
    631                     msgCenter().cannotSaveDHCPServerParameter(comServer, this);
    632                 {
    633                     /* Update interface in the tree: */
    634                     UIDataHostNetwork data;
    635                     loadHostNetwork(comInterface, data);
    636                     updateItemForNetworkHost(data, true, pChangedItem);
    637 
    638                     /* Make sure current item fetched: */
    639                     sltHandleCurrentItemChange();
    640 
    641                     /* Adjust tree-widget: */
    642                     sltAdjustTreeWidget();
    643                 }
    644             }
    645         }
    646     }
    647 }
    648 
    649 void UIHostNetworkManagerWidget::sltHandleCurrentItemChange()
    650 {
    651     /* Get network item: */
    652     UIItemHostNetwork *pItem = static_cast<UIItemHostNetwork*>(m_pTreeWidget->currentItem());
    653 
    654     /* Update actions availability: */
    655     m_pActionRemove->setEnabled(pItem);
    656     m_pActionDetails->setEnabled(pItem);
    657     m_pActionCommit->setEnabled(false);
    658 
    659     /* If there is an item => update details data: */
    660     if (pItem)
    661         m_pDetailsWidget->setData(*pItem);
    662     else
    663     {
    664         /* Otherwise => clear details and close the area: */
    665         m_pDetailsWidget->clearData();
    666         sltToggleHostNetworkDetailsVisibility(false);
    667     }
    668 }
    669 
    670 void UIHostNetworkManagerWidget::sltHandleContextMenuRequest(const QPoint &pos)
    671 {
    672     /* Compose temporary context-menu: */
    673     QMenu menu;
    674     if (m_pTreeWidget->itemAt(pos))
    675     {
    676         menu.addAction(m_pActionRemove);
    677         menu.addAction(m_pActionDetails);
    678         menu.addAction(m_pActionCommit);
    679     }
    680     else
    681     {
    682         menu.addAction(m_pActionAdd);
    683     }
    684     /* And show it: */
    685     menu.exec(m_pTreeWidget->mapToGlobal(pos));
    686 }
    687 
    688 void UIHostNetworkManagerWidget::prepare()
    689 {
    690     /* Prepare this: */
    691     prepareThis();
    692 
    693     /* Apply language settings: */
    694     retranslateUi();
    695 
    696     /* Load host networks: */
    697     loadHostNetworks();
    698 }
    699 
    700 void UIHostNetworkManagerWidget::prepareThis()
    701 {
    702     /* Prepare actions: */
    703     prepareActions();
    704     /* Prepare widget: */
    705     prepareWidgets();
    706 }
    707 
    708 void UIHostNetworkManagerWidget::prepareActions()
    709 {
    710     /* Create 'Add' action: */
    711     m_pActionAdd = new QAction(this);
    712     AssertPtrReturnVoid(m_pActionAdd);
    713     {
    714         /* Configure 'Add' action: */
    715         m_pActionAdd->setShortcut(QKeySequence("Ctrl+A"));
    716         m_pActionAdd->setIcon(UIIconPool::iconSetFull(":/add_host_iface_22px.png",
    717                                                       ":/add_host_iface_16px.png",
    718                                                       ":/add_host_iface_disabled_22px.png",
    719                                                       ":/add_host_iface_disabled_16px.png"));
    720         connect(m_pActionAdd, &QAction::triggered, this, &UIHostNetworkManagerWidget::sltAddHostNetwork);
    721     }
    722 
    723     /* Create 'Remove' action: */
    724     m_pActionRemove = new QAction(this);
    725     AssertPtrReturnVoid(m_pActionRemove);
    726     {
    727         /* Configure 'Remove' action: */
    728         m_pActionRemove->setShortcut(QKeySequence("Del"));
    729         m_pActionRemove->setIcon(UIIconPool::iconSetFull(":/remove_host_iface_22px.png",
    730                                                          ":/remove_host_iface_16px.png",
    731                                                          ":/remove_host_iface_disabled_22px.png",
    732                                                          ":/remove_host_iface_disabled_16px.png"));
    733         connect(m_pActionRemove, &QAction::triggered, this, &UIHostNetworkManagerWidget::sltRemoveHostNetwork);
    734     }
    735 
    736     /* Create 'Details' action: */
    737     m_pActionDetails = new QAction(this);
    738     AssertPtrReturnVoid(m_pActionDetails);
    739     {
    740         /* Configure 'Details' action: */
    741         m_pActionDetails->setCheckable(true);
    742         m_pActionDetails->setShortcut(QKeySequence("Ctrl+Space"));
    743         m_pActionDetails->setIcon(UIIconPool::iconSetFull(":/edit_host_iface_22px.png",
    744                                                           ":/edit_host_iface_16px.png",
    745                                                           ":/edit_host_iface_disabled_22px.png",
    746                                                           ":/edit_host_iface_disabled_16px.png"));
    747         connect(m_pActionDetails, &QAction::toggled, this, &UIHostNetworkManagerWidget::sltToggleHostNetworkDetailsVisibility);
    748     }
    749 
    750     /* Create 'Apply' action: */
    751     m_pActionCommit = new QAction(this);
    752     AssertPtrReturnVoid(m_pActionCommit);
    753     {
    754         /* Configure 'Apply' action: */
    755         m_pActionCommit->setVisible(false);
    756         m_pActionCommit->setShortcut(QKeySequence("Ctrl+Return"));
    757         m_pActionCommit->setIcon(UIIconPool::iconSetFull(":/edit_host_iface_22px.png",
    758                                                          ":/edit_host_iface_16px.png",
    759                                                          ":/edit_host_iface_disabled_22px.png",
    760                                                          ":/edit_host_iface_disabled_16px.png"));
    761         connect(m_pActionDetails, &QAction::toggled, m_pActionCommit, &QAction::setVisible);
    762         connect(m_pActionCommit, &QAction::triggered, this, &UIHostNetworkManagerWidget::sltApplyHostNetworkDetailsChanges);
    763     }
    764 
    765     /* Prepare menu: */
    766     prepareMenu();
    767 }
    768 
    769 void UIHostNetworkManagerWidget::prepareMenu()
    770 {
    771     /* Create 'Network' menu: */
    772     m_pMenu = new QMenu(this);
    773     AssertPtrReturnVoid(m_pMenu);
    774     {
    775         /* Configure menu: */
    776         m_pMenu->addAction(m_pActionAdd);
    777         m_pMenu->addAction(m_pActionRemove);
    778         m_pMenu->addAction(m_pActionDetails);
    779         m_pMenu->addAction(m_pActionCommit);
    780     }
    781 }
    782 
    783 void UIHostNetworkManagerWidget::prepareWidgets()
    784 {
    785     /* Create main-layout: */
    786     new QVBoxLayout(this);
    787     AssertPtrReturnVoid(layout());
    788     {
    789         /* Configure layout: */
    790         layout()->setContentsMargins(0, 0, 0, 0);
    791 #ifdef VBOX_WS_MAC
    792         layout()->setSpacing(10);
    793 #else
    794         layout()->setSpacing(4);
    795 #endif
    796 
    797         /* Prepare toolbar: */
    798         prepareToolBar();
    799         /* Prepare tree-widget: */
    800         prepareTreeWidget();
    801         /* Prepare details-widget: */
    802         prepareDetailsWidget();
    803     }
    804 }
    805 
    806 void UIHostNetworkManagerWidget::prepareToolBar()
    807 {
    808     /* Create toolbar: */
    809     m_pToolBar = new UIToolBar(parentWidget());
    810     AssertPtrReturnVoid(m_pToolBar);
    811     {
    812         /* Configure toolbar: */
    813         const QStyle *pStyle = QApplication::style();
    814         const int iIconMetric = (int)(pStyle->pixelMetric(QStyle::PM_SmallIconSize) * 1.375);
    815         m_pToolBar->setIconSize(QSize(iIconMetric, iIconMetric));
    816         m_pToolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
    817         /* Add toolbar actions: */
    818         if (m_pActionAdd)
    819             m_pToolBar->addAction(m_pActionAdd);
    820         if (m_pActionRemove)
    821             m_pToolBar->addAction(m_pActionRemove);
    822         if ((m_pActionAdd || m_pActionRemove) && (m_pActionDetails || m_pActionCommit))
    823             m_pToolBar->addSeparator();
    824         if (m_pActionDetails)
    825             m_pToolBar->addAction(m_pActionDetails);
    826         if (m_pActionCommit)
    827             m_pToolBar->addAction(m_pActionCommit);
    828 #ifndef VBOX_WS_MAC
    829         /* Add into layout: */
    830         layout()->addWidget(m_pToolBar);
    831 #endif
    832     }
    833 }
    834 
    835 void UIHostNetworkManagerWidget::prepareTreeWidget()
    836 {
    837     /* Create tree-widget: */
    838     m_pTreeWidget = new QITreeWidget;
    839     AssertPtrReturnVoid(m_pTreeWidget);
    840     {
    841         /* Configure tree-widget: */
    842         m_pTreeWidget->setRootIsDecorated(false);
    843         m_pTreeWidget->setAlternatingRowColors(true);
    844         m_pTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
    845         m_pTreeWidget->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    846         m_pTreeWidget->setColumnCount(Column_Max);
    847         m_pTreeWidget->setSortingEnabled(true);
    848         m_pTreeWidget->sortByColumn(Column_Name, Qt::AscendingOrder);
    849         m_pTreeWidget->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Expanding);
    850         connect(m_pTreeWidget, &QITreeWidget::currentItemChanged,
    851                 this, &UIHostNetworkManagerWidget::sltHandleCurrentItemChange);
    852         connect(m_pTreeWidget, &QITreeWidget::customContextMenuRequested,
    853                 this, &UIHostNetworkManagerWidget::sltHandleContextMenuRequest);
    854         connect(m_pTreeWidget, &QITreeWidget::itemChanged,
    855                 this, &UIHostNetworkManagerWidget::sltHandleItemChange);
    856         connect(m_pTreeWidget, &QITreeWidget::itemDoubleClicked,
    857                 m_pActionDetails, &QAction::setChecked);
    858 
    859         /* Add into layout: */
    860         layout()->addWidget(m_pTreeWidget);
    861     }
    862 }
    863 
    864 void UIHostNetworkManagerWidget::prepareDetailsWidget()
    865 {
    866     /* Create details-widget: */
    867     m_pDetailsWidget = new UIHostNetworkDetailsDialog;
    868     AssertPtrReturnVoid(m_pDetailsWidget);
    869     {
    870         /* Configure details-widget: */
    871         m_pDetailsWidget->setVisible(false);
    872         m_pDetailsWidget->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
    873         connect(m_pDetailsWidget, &UIHostNetworkDetailsDialog::sigDataChanged,
    874                 m_pActionCommit, &QAction::setEnabled);
    875 
    876         /* Add into layout: */
    877         layout()->addWidget(m_pDetailsWidget);
    878     }
    879 }
    880 
    881 void UIHostNetworkManagerWidget::loadHostNetworks()
    882 {
    883     /* Clear tree first of all: */
    884     m_pTreeWidget->clear();
    885 
    886     /* Get host for further activities: */
    887     const CHost comHost = vboxGlobal().host();
    888 
    889     /* Get interfaces for further activities: */
    890     const QVector<CHostNetworkInterface> interfaces = comHost.GetNetworkInterfaces();
    891 
    892     /* Show error message if necessary: */
    893     if (!comHost.isOk())
    894         msgCenter().cannotAcquireHostNetworkInterfaces(comHost, this);
    895     else
    896     {
    897         /* For each host-only interface => load it to the tree: */
    898         foreach (const CHostNetworkInterface &comInterface, interfaces)
    899             if (comInterface.GetInterfaceType() == KHostNetworkInterfaceType_HostOnly)
    900             {
    901                 UIDataHostNetwork data;
    902                 loadHostNetwork(comInterface, data);
    903                 createItemForNetworkHost(data, false);
    904             }
    905 
    906         /* Choose the 1st item as current initially: */
    907         m_pTreeWidget->setCurrentItem(m_pTreeWidget->topLevelItem(0));
    908         sltHandleCurrentItemChange();
    909 
    910         /* Adjust tree-widget: */
    911         sltAdjustTreeWidget();
    912     }
    913 }
    914 
    915 void UIHostNetworkManagerWidget::loadHostNetwork(const CHostNetworkInterface &comInterface, UIDataHostNetwork &data)
    916 {
    917     /* Gather interface settings: */
    918     if (comInterface.isOk())
    919         data.m_interface.m_strName = comInterface.GetName();
    920     if (comInterface.isOk())
    921         data.m_interface.m_fDHCPEnabled = comInterface.GetDHCPEnabled();
    922     if (comInterface.isOk())
    923         data.m_interface.m_strAddress = comInterface.GetIPAddress();
    924     if (comInterface.isOk())
    925         data.m_interface.m_strMask = comInterface.GetNetworkMask();
    926     if (comInterface.isOk())
    927         data.m_interface.m_fSupportedIPv6 = comInterface.GetIPV6Supported();
    928     if (comInterface.isOk())
    929         data.m_interface.m_strAddress6 = comInterface.GetIPV6Address();
    930     if (comInterface.isOk())
    931         data.m_interface.m_strMaskLength6 = QString::number(comInterface.GetIPV6NetworkMaskPrefixLength());
    932 
    933     /* Get host interface network name for further activities: */
    934     QString strNetworkName;
    935     if (comInterface.isOk())
    936         strNetworkName = comInterface.GetNetworkName();
    937 
    938     /* Show error message if necessary: */
    939     if (!comInterface.isOk())
    940         msgCenter().cannotAcquireHostNetworkInterfaceParameter(comInterface, this);
    941 
    942     /* Get VBox for further activities: */
    943     CVirtualBox comVBox = vboxGlobal().virtualBox();
    944 
    945     /* Find corresponding DHCP server (create if necessary): */
    946     CDHCPServer comServer = comVBox.FindDHCPServerByNetworkName(strNetworkName);
    947     if (!comVBox.isOk() || comServer.isNull())
    948         comServer = comVBox.CreateDHCPServer(strNetworkName);
    949 
    950     /* Show error message if necessary: */
    951     if (!comVBox.isOk() || comServer.isNull())
    952         msgCenter().cannotCreateDHCPServer(comVBox, strNetworkName, this);
    953     else
    954     {
    955         /* Gather DHCP server settings: */
    956         if (comServer.isOk())
    957             data.m_dhcpserver.m_fEnabled = comServer.GetEnabled();
    958         if (comServer.isOk())
    959             data.m_dhcpserver.m_strAddress = comServer.GetIPAddress();
    960         if (comServer.isOk())
    961             data.m_dhcpserver.m_strMask = comServer.GetNetworkMask();
    962         if (comServer.isOk())
    963             data.m_dhcpserver.m_strLowerAddress = comServer.GetLowerIP();
    964         if (comServer.isOk())
    965             data.m_dhcpserver.m_strUpperAddress = comServer.GetUpperIP();
    966 
    967         /* Show error message if necessary: */
    968         if (!comServer.isOk())
    969             return msgCenter().cannotAcquireDHCPServerParameter(comServer, this);
    970     }
    971 }
    972 
    973 void UIHostNetworkManagerWidget::createItemForNetworkHost(const UIDataHostNetwork &data, bool fChooseItem)
    974 {
    975     /* Create new item: */
    976     UIItemHostNetwork *pItem = new UIItemHostNetwork;
    977     AssertPtrReturnVoid(pItem);
    978     {
    979         /* Configure item: */
    980         pItem->UIDataHostNetwork::operator=(data);
    981         pItem->updateFields();
    982         /* Add item to the tree: */
    983         m_pTreeWidget->addTopLevelItem(pItem);
    984         /* And choose it as current if necessary: */
    985         if (fChooseItem)
    986             m_pTreeWidget->setCurrentItem(pItem);
    987     }
    988 }
    989 
    990 void UIHostNetworkManagerWidget::updateItemForNetworkHost(const UIDataHostNetwork &data, bool fChooseItem, UIItemHostNetwork *pItem)
    991 {
    992     /* Update passed item: */
    993     AssertPtrReturnVoid(pItem);
    994     {
    995         /* Configure item: */
    996         pItem->UIDataHostNetwork::operator=(data);
    997         pItem->updateFields();
    998         /* And choose it as current if necessary: */
    999         if (fChooseItem)
    1000             m_pTreeWidget->setCurrentItem(pItem);
    1001     }
    1002 }
    1003 
    1004 
    1005 /*********************************************************************************************************************************
    1006 *   Class UIHostNetworkManager implementation.                                                                                   *
    1007 *********************************************************************************************************************************/
    1008 
    1009 /* static */
    1010 UIHostNetworkManager *UIHostNetworkManager::s_pInstance = 0;
    1011 UIHostNetworkManager *UIHostNetworkManager::instance() { return s_pInstance; }
    1012 
    1013 UIHostNetworkManager::UIHostNetworkManager(QWidget *pCenterWidget)
    1014     : m_pPseudoParentWidget(pCenterWidget)
    1015     , m_pWidget(0)
    1016     , m_pButtonBox(0)
    1017 {
    1018     /* Prepare instance: */
    1019     s_pInstance = this;
    1020 
    1021     /* Prepare: */
    1022     prepare();
    1023 }
    1024 
    1025 UIHostNetworkManager::~UIHostNetworkManager()
    1026 {
    1027     /* Cleanup: */
    1028     cleanup();
    1029 
    1030     /* Cleanup instance: */
    1031     s_pInstance = 0;
    1032 }
    1033 
    1034 /* static */
    1035 void UIHostNetworkManager::showModeless(QWidget *pCenterWidget /* = 0 */)
    1036 {
    1037     /* Create instance if not yet created: */
    1038     if (!s_pInstance)
    1039         new UIHostNetworkManager(pCenterWidget);
    1040 
    1041     /* Show instance: */
    1042     s_pInstance->show();
    1043     s_pInstance->setWindowState(s_pInstance->windowState() & ~Qt::WindowMinimized);
    1044     s_pInstance->activateWindow();
    1045 }
    1046 
    1047 void UIHostNetworkManager::retranslateUi()
    1048 {
    1049     /* Translate window title: */
    1050     setWindowTitle(tr("Host Network Manager"));
    1051 }
    1052 
    1053 void UIHostNetworkManager::prepare()
    1054 {
    1055     /* Prepare this: */
    1056     prepareThis();
    1057 
    1058     /* Apply language settings: */
    1059     retranslateUi();
    1060 
    1061     /* Center according pseudo-parent widget: */
    1062     VBoxGlobal::centerWidget(this, m_pPseudoParentWidget, false);
    1063 }
    1064 
    1065 void UIHostNetworkManager::prepareThis()
    1066 {
    1067     /* Initial size: */
    1068     resize(620, 460);
    1069 
    1070     /* Dialog should delete itself on 'close': */
    1071     setAttribute(Qt::WA_DeleteOnClose);
    1072     /* And no need to count it as important for application.
    1073      * This way it will NOT be taken into account
    1074      * when other top-level windows will be closed: */
     83    /* Tell the application we are not that important: */
    107584    setAttribute(Qt::WA_QuitOnClose, false);
    107685
    1077     /* Apply window icons: */
    1078     setWindowIcon(UIIconPool::iconSetFull(":/host_iface_manager_32px.png", ":/host_iface_manager_16px.png"));
     86    /* Invent initial size: */
     87    QSize proposedSize;
     88    const int iHostScreen = gpDesktop->screenNumber(pCenterWidget);
     89    if (iHostScreen >= 0 && iHostScreen < gpDesktop->screenCount())
     90    {
     91        /* On the basis of current host-screen geometry if possible: */
     92        const QRect screenGeometry = gpDesktop->screenGeometry(iHostScreen);
     93        if (screenGeometry.isValid())
     94            proposedSize = screenGeometry.size() * 2 / 5;
     95    }
     96    /* Fallback to default size if we failed: */
     97    if (proposedSize.isNull())
     98        proposedSize = QSize(800, 600);
     99    /* Resize to initial size: */
     100    resize(proposedSize);
    1079101
     102    /* Prepare dialog: */
     103    prepareDialog();
    1080104    /* Prepare central-widget: */
    1081105    prepareCentralWidget();
    1082106    /* Prepare menu-bar: */
    1083107    prepareMenuBar();
     108#ifdef VBOX_WS_MAC
    1084109    /* Prepare toolbar: */
    1085110    prepareToolBar();
     111#endif
     112
     113    /* Center according requested widget: */
     114    VBoxGlobal::centerWidget(this, pCenterWidget, false);
    1086115}
    1087116
    1088 void UIHostNetworkManager::prepareCentralWidget()
     117void QIManagerDialog::prepareCentralWidget()
    1089118{
    1090119    /* Create central-widget: */
     
    1108137}
    1109138
    1110 void UIHostNetworkManager::prepareWidget()
    1111 {
    1112     /* Create widget: */
    1113     m_pWidget = new UIHostNetworkManagerWidget(this);
    1114     AssertPtrReturnVoid(m_pWidget);
    1115     {
    1116         /* Add to layout: */
    1117         centralWidget()->layout()->addWidget(m_pWidget);
    1118     }
    1119 }
    1120 
    1121 void UIHostNetworkManager::prepareButtonBox()
     139void QIManagerDialog::prepareButtonBox()
    1122140{
    1123141    /* Create button-box: */
     
    1129147        m_pButtonBox->button(QDialogButtonBox::Close)->setShortcut(Qt::Key_Escape);
    1130148        connect(m_pButtonBox, SIGNAL(helpRequested()), &msgCenter(), SLOT(sltShowHelpHelpDialog()));
    1131         connect(m_pButtonBox, &QIDialogButtonBox::rejected, this, &UIHostNetworkManager::close);
     149        connect(m_pButtonBox, &QIDialogButtonBox::rejected, this, &QIManagerDialog::sigClose);
    1132150
    1133151        /* Add into layout: */
     
    1136154}
    1137155
    1138 void UIHostNetworkManager::prepareMenuBar()
     156void QIManagerDialog::prepareMenuBar()
    1139157{
    1140     /* Add 'Network' menu: */
    1141     menuBar()->addMenu(m_pWidget->menu());
     158    /* Add widget menu: */
     159    menuBar()->addMenu(m_pWidgetMenu);
    1142160
    1143161#ifdef VBOX_WS_MAC
     
    1149167}
    1150168
    1151 void UIHostNetworkManager::prepareToolBar()
     169#ifdef VBOX_WS_MAC
     170void QIManagerDialog::prepareToolBar()
    1152171{
    1153 #ifdef VBOX_WS_MAC
    1154172    /* Enable unified toolbar on macOS: */
    1155     addToolBar(m_pWidget->toolbar());
    1156     m_pWidget->toolbar()->enableMacToolbar();
     173    addToolBar(m_pWidgetToolbar);
     174    m_pWidgetToolbar->enableMacToolbar();
     175}
    1157176#endif
    1158 }
    1159177
    1160 void UIHostNetworkManager::cleanupMenuBar()
     178void QIManagerDialog::cleanupMenuBar()
    1161179{
    1162180#ifdef VBOX_WS_MAC
     
    1168186}
    1169187
    1170 void UIHostNetworkManager::cleanup()
     188void QIManagerDialog::cleanup()
    1171189{
    1172190    /* Cleanup menu-bar: */
  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIManagerDialog.h

    r66972 r67017  
    11/* $Id$ */
    22/** @file
    3  * VBox Qt GUI - UIHostNetworkManager class declaration.
     3 * VBox Qt GUI - QIManagerDialog class declaration.
    44 */
    55
     
    1616 */
    1717
    18 #ifndef ___UIHostNetworkManager_h___
    19 #define ___UIHostNetworkManager_h___
     18#ifndef ___QIManagerDialog_h___
     19#define ___QIManagerDialog_h___
    2020
    2121/* Qt includes: */
    2222#include <QMainWindow>
    2323
    24 /* GUI includes: */
    25 #include "QIWithRetranslateUI.h"
    26 
    2724/* Forward declarations: */
    28 class CHostNetworkInterface;
    29 class QAbstractButton;
    30 class QTreeWidgetItem;
    3125class QIDialogButtonBox;
    32 class QITreeWidget;
    33 class UIHostNetworkDetailsDialog;
    34 class UIItemHostNetwork;
     26class QIManagerDialog;
     27#ifdef VBOX_WS_MAC
    3528class UIToolBar;
    36 struct UIDataHostNetwork;
     29#endif
    3730
    3831
    39 /** Host Network Manager widget. */
    40 class UIHostNetworkManagerWidget : public QIWithRetranslateUI<QWidget>
     32/** Manager dialog factory insterface. */
     33class QIManagerDialogFactory
     34{
     35public:
     36
     37    /** Constructs Manager dialog factory. */
     38    QIManagerDialogFactory() {}
     39    /** Destructs Manager dialog factory. */
     40    virtual ~QIManagerDialogFactory() {}
     41
     42    /** Prepares Manager dialog @a pDialog instance.
     43      * @param  pCenterWidget  Brings the widget reference to center according to. */
     44    virtual void prepare(QIManagerDialog *&pDialog, QWidget *pCenterWidget = 0);
     45    /** Cleanups Manager dialog @a pDialog instance. */
     46    virtual void cleanup(QIManagerDialog *&pDialog);
     47
     48protected:
     49
     50    /** Creates derived @a pDialog instance.
     51      * @param  pCenterWidget  Brings the widget reference to center according to. */
     52    virtual void create(QIManagerDialog *&pDialog, QWidget *pCenterWidget) = 0;
     53};
     54
     55
     56/** QMainWindow sub-class used as various manager dialogs. */
     57class QIManagerDialog : public QMainWindow
    4158{
    4259    Q_OBJECT;
    4360
    44 public:
     61signals:
    4562
    46     /** Constructs Host Network Manager widget. */
    47     UIHostNetworkManagerWidget(QWidget *pParent = 0);
    48 
    49     /** Returns the menu. */
    50     QMenu *menu() const { return m_pMenu; }
    51 
    52 #ifdef VBOX_WS_MAC
    53     /** Returns the toolbar. */
    54     UIToolBar *toolbar() const { return m_pToolBar; }
    55 #endif
     63    /** Notifies listener about dialog should be closed. */
     64    void sigClose();
    5665
    5766protected:
    5867
     68    /** Constructs Manager dialog.
     69      * @param  pCenterWidget  Brings the widget reference to center according to. */
     70    QIManagerDialog(QWidget *pCenterWidget);
     71
     72    /** @name Prepare/cleanup cascade.
     73      * @{ */
     74        /** Prepares dialog. */
     75        virtual void prepareDialog() {}
     76        /** Prepares widget. */
     77        virtual void prepareWidget() {}
     78    /** @} */
     79
     80    /** @name Widget stuff.
     81      * @{ */
     82        /** Defines the @a pWidget instance. */
     83        void setWidget(QWidget *pWidget) { m_pWidget = pWidget; }
     84        /** Defines the @a pWidgetMenu instance. */
     85        void setWidgetMenu(QMenu *pWidgetMenu) { m_pWidgetMenu = pWidgetMenu; }
     86#ifdef VBOX_WS_MAC
     87        /** Defines the @a pWidgetToolbar instance. */
     88        void setWidgetToolbar(UIToolBar *pWidgetToolbar) { m_pWidgetToolbar = pWidgetToolbar; }
     89#endif
     90    /** @} */
     91
    5992    /** @name Event-handling stuff.
    6093      * @{ */
    61         /** Handles translation event. */
    62         virtual void retranslateUi() /* override */;
    63 
    64         /** Handles resize @a pEvent. */
    65         virtual void resizeEvent(QResizeEvent *pEvent) /* override */;
    66 
    67         /** Handles show @a pEvent. */
    68         virtual void showEvent(QShowEvent *pEvent) /* override */;
    69     /** @} */
    70 
    71 private slots:
    72 
    73     /** @name Menu/action stuff.
    74       * @{ */
    75         /** Handles command to add host network. */
    76         void sltAddHostNetwork();
    77         /** Handles command to remove host network. */
    78         void sltRemoveHostNetwork();
    79         /** Handles command to make host network details @a fVisible. */
    80         void sltToggleHostNetworkDetailsVisibility(bool fVisible);
    81         /** Handles command to apply host network details changes. */
    82         void sltApplyHostNetworkDetailsChanges();
    83     /** @} */
    84 
    85     /** @name Tree-widget stuff.
    86       * @{ */
    87         /** Handles command to adjust tree-widget. */
    88         void sltAdjustTreeWidget();
    89 
    90         /** Handles tree-widget @a pItem change. */
    91         void sltHandleItemChange(QTreeWidgetItem *pItem);
    92         /** Handles tree-widget current item change. */
    93         void sltHandleCurrentItemChange();
    94         /** Handles context menu request for tree-widget @a position. */
    95         void sltHandleContextMenuRequest(const QPoint &position);
     94        /** Handles close @a pEvent. */
     95        void closeEvent(QCloseEvent *pEvent);
    9696    /** @} */
    9797
     
    102102        /** Prepares all. */
    103103        void prepare();
    104         /** Prepares this. */
    105         void prepareThis();
    106         /** Prepares actions. */
    107         void prepareActions();
    108         /** Prepares menu. */
    109         void prepareMenu();
    110         /** Prepares widgets. */
    111         void prepareWidgets();
    112         /** Prepares toolbar. */
    113         void prepareToolBar();
    114         /** Prepares tree-widget. */
    115         void prepareTreeWidget();
    116         /** Prepares details-widget. */
    117         void prepareDetailsWidget();
    118     /** @} */
    119 
    120     /** @name Loading stuff.
    121       * @{ */
    122         /** Loads host networks. */
    123         void loadHostNetworks();
    124         /** Loads host @a comInterface data to passed @a data container. */
    125         void loadHostNetwork(const CHostNetworkInterface &comInterface, UIDataHostNetwork &data);
    126     /** @} */
    127 
    128     /** @name Tree-widget stuff.
    129       * @{ */
    130         /** Creates a new tree-widget item on the basis of passed @a data, @a fChooseItem if requested. */
    131         void createItemForNetworkHost(const UIDataHostNetwork &data, bool fChooseItem);
    132         /** Updates the passed tree-widget item on the basis of passed @a data, @a fChooseItem if requested. */
    133         void updateItemForNetworkHost(const UIDataHostNetwork &data, bool fChooseItem, UIItemHostNetwork *pItem);
    134     /** @} */
    135 
    136     /** @name Toolbar and menu variables.
    137       * @{ */
    138         /** Holds the toolbar instance. */
    139         UIToolBar *m_pToolBar;
    140         /** Holds menu-bar menu object instance. */
    141         QMenu     *m_pMenu;
    142         /** Holds the Add action instance. */
    143         QAction   *m_pActionAdd;
    144         /** Holds the Remove action instance. */
    145         QAction   *m_pActionRemove;
    146         /** Holds the Details action instance. */
    147         QAction   *m_pActionDetails;
    148         /** Holds the Commit action instance. */
    149         QAction   *m_pActionCommit;
    150     /** @} */
    151 
    152     /** @name Splitter variables.
    153       * @{ */
    154         /** Holds the tree-widget instance. */
    155         QITreeWidget *m_pTreeWidget;
    156         /** Holds the details-widget instance. */
    157         UIHostNetworkDetailsDialog *m_pDetailsWidget;
    158     /** @} */
    159 };
    160 
    161 
    162 /** Host Network Manager dialog. */
    163 class UIHostNetworkManager : public QIWithRetranslateUI<QMainWindow>
    164 {
    165     Q_OBJECT;
    166 
    167     /** Constructs Host Network Manager dialog.
    168       * @param  pCenterWidget  Brings the pseudo-parent widget to center according to. */
    169     UIHostNetworkManager(QWidget *pCenterWidget);
    170     /** Destructs Host Network Manager dialog. */
    171     ~UIHostNetworkManager();
    172 
    173 public:
    174 
    175     /** Returns Host Network Manager singleton instance. */
    176     static UIHostNetworkManager *instance();
    177     /** Shows Host Network Manager singleton instance, creates new if necessary. */
    178     static void showModeless(QWidget *pCenterWidget);
    179 
    180 protected:
    181 
    182     /** @name Event-handling stuff.
    183       * @{ */
    184         /** Handles translation event. */
    185         virtual void retranslateUi() /* override */;
    186     /** @} */
    187 
    188 private:
    189 
    190     /** @name Prepare/cleanup cascade.
    191       * @{ */
    192         /** Prepares all. */
    193         void prepare();
    194         /** Prepares this. */
    195         void prepareThis();
    196104        /** Prepares central-widget. */
    197105        void prepareCentralWidget();
    198         /** Prepares widget. */
    199         void prepareWidget();
    200106        /** Prepares button-box. */
    201107        void prepareButtonBox();
    202108        /** Prepares menu-bar. */
    203109        void prepareMenuBar();
     110#ifdef VBOX_WS_MAC
    204111        /** Prepares toolbar. */
    205112        void prepareToolBar();
     113#endif
    206114
    207115        /** Cleanup menu-bar. */
     
    211119    /** @} */
    212120
    213     /** @name General variables.
     121    /** @name General stuff.
    214122      * @{ */
    215         /** Holds the Host Network Manager singleton instance. */
    216         static UIHostNetworkManager *s_pInstance;
    217 
    218123        /** Holds the widget reference to center Host Network Manager according. */
    219         QWidget *m_pPseudoParentWidget;
     124        QWidget *pCenterWidget;
    220125    /** @} */
    221126
    222     /** @name Widget variables.
     127    /** @name Widget stuff.
    223128      * @{ */
    224129        /** Holds the widget instance. */
    225         UIHostNetworkManagerWidget *m_pWidget;
     130        QWidget *m_pWidget;
     131
     132        /** Holds the widget menu instance. */
     133        QMenu     *m_pWidgetMenu;
     134#ifdef VBOX_WS_MAC
     135        /** Holds the widget toolbar instance. */
     136        UIToolBar *m_pWidgetToolbar;
     137#endif
    226138    /** @} */
    227139
    228     /** @name Button-box variables.
     140    /** @name Button-box stuff.
    229141      * @{ */
    230142        /** Holds the dialog button-box instance. */
    231143        QIDialogButtonBox *m_pButtonBox;
    232144    /** @} */
     145
     146    /** Allow factory access to private/protected members: */
     147    friend class QIManagerDialogFactory;
    233148};
    234149
    235 #endif /* !___UIHostNetworkManager_h___ */
     150#endif /* !___QIManagerDialog_h___ */
    236151
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette