VirtualBox

Changeset 101594 in vbox for trunk/src


Ignore:
Timestamp:
Oct 25, 2023 7:21:57 PM (16 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
159678
Message:

FE/Qt: bugref:10513: Machine settings / Network page: Reworking editor embedding, it's more simple now and similar to other pages.

Location:
trunk/src/VBox/Frontends/VirtualBox/src/settings/machine
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r101591 r101594  
    158158
    159159
    160 /** Machine settings: Network Adapter tab. */
    161 class UIMachineSettingsNetwork : public UIEditor
    162 {
    163     Q_OBJECT;
    164 
    165 signals:
    166 
    167     /** Notifies about alternative name was changed. */
    168     void sigAlternativeNameChanged();
    169 
    170     /** Notifies about validity changed. */
    171     void sigValidityChanged();
    172 
    173 public:
    174 
    175     /** Constructs tab passing @a pParent to the base-class.
    176       * @param  pParentPage  Holds the parent page reference allowing to access some of API there. */
    177     UIMachineSettingsNetwork(UIEditor *pParent, UIMachineSettingsNetworkPage *pParentPage);
    178 
    179     /** Loads adapter data from @a adapterCache. */
    180     void getAdapterDataFromCache(const UISettingsCacheMachineNetworkAdapter &adapterCache);
    181     /** Saves adapter data to @a adapterCache. */
    182     void putAdapterDataToCache(UISettingsCacheMachineNetworkAdapter &adapterCache);
    183 
    184     /** Performs validation, updates @a messages list if something is wrong. */
    185     bool validate(QList<UIValidationMessage> &messages);
    186 
    187     /** Configures tab order according to passed @a pWidget. */
    188     QWidget *setOrderAfter(QWidget *pWidget);
    189 
    190     /** Returns tab title. */
    191     QString tabTitle() const;
    192     /** Returns tab attachment type. */
    193     KNetworkAttachmentType attachmentType() const;
    194     /** Returne tab alternative name for @a enmType specified. */
    195     QString alternativeName(KNetworkAttachmentType enmType = KNetworkAttachmentType_Null) const;
    196 
    197     /** Performs tab polishing. */
    198     void polishTab();
    199     /** Reloads tab alternatives. */
    200     void reloadAlternatives();
    201 
    202 protected:
    203 
    204     /** Handles translation event. */
    205     void retranslateUi();
    206 
    207 private slots:
    208 
    209     /** Handles adapter alternative name change. */
    210     void sltHandleAlternativeNameChange();
    211 
    212 private:
    213 
    214     /** Prepares all. */
    215     void prepare();
    216     /** Prepares widgets. */
    217     void prepareWidgets();
    218     /** Prepares connections. */
    219     void prepareConnections();
    220 
    221     /** Holds parent page reference. */
    222     UIMachineSettingsNetworkPage *m_pParentPage;
    223 
    224     /** Holds tab slot number. */
    225     int  m_iSlot;
    226 
    227     /** Holds the network settings editor instance. */
    228     UINetworkSettingsEditor *m_pEditorNetworkSettings;
    229 };
    230 
    231 
    232 /*********************************************************************************************************************************
    233 *   Class UIMachineSettingsNetwork implementation.                                                                               *
    234 *********************************************************************************************************************************/
    235 
    236 UIMachineSettingsNetwork::UIMachineSettingsNetwork(UIEditor *pParent, UIMachineSettingsNetworkPage *pParentPage)
    237     : UIEditor(pParent)
    238     , m_pParentPage(pParentPage)
    239     , m_iSlot(-1)
    240     , m_pEditorNetworkSettings(0)
    241 {
    242     prepare();
    243 }
    244 
    245 void UIMachineSettingsNetwork::getAdapterDataFromCache(const UISettingsCacheMachineNetworkAdapter &adapterCache)
    246 {
    247     /* Get old data: */
    248     const UIDataSettingsMachineNetworkAdapter &oldAdapterData = adapterCache.base();
    249 
    250     /* Load slot number: */
    251     m_iSlot = oldAdapterData.m_iSlot;
    252 
    253     if (m_pEditorNetworkSettings)
    254     {
    255         /* Load adapter activity state: */
    256         m_pEditorNetworkSettings->setFeatureEnabled(oldAdapterData.m_fAdapterEnabled);
    257 
    258         /* Load attachment type: */
    259         m_pEditorNetworkSettings->setValueType(oldAdapterData.m_attachmentType);
    260         /* Load alternative names: */
    261         m_pEditorNetworkSettings->setValueName(KNetworkAttachmentType_Bridged, wipedOutString(oldAdapterData.m_strBridgedAdapterName));
    262         m_pEditorNetworkSettings->setValueName(KNetworkAttachmentType_Internal, wipedOutString(oldAdapterData.m_strInternalNetworkName));
    263         m_pEditorNetworkSettings->setValueName(KNetworkAttachmentType_HostOnly, wipedOutString(oldAdapterData.m_strHostInterfaceName));
    264         m_pEditorNetworkSettings->setValueName(KNetworkAttachmentType_Generic, wipedOutString(oldAdapterData.m_strGenericDriverName));
    265         m_pEditorNetworkSettings->setValueName(KNetworkAttachmentType_NATNetwork, wipedOutString(oldAdapterData.m_strNATNetworkName));
    266 #ifdef VBOX_WITH_CLOUD_NET
    267         m_pEditorNetworkSettings->setValueName(KNetworkAttachmentType_Cloud, wipedOutString(oldAdapterData.m_strCloudNetworkName));
    268 #endif
    269 #ifdef VBOX_WITH_VMNET
    270         m_pEditorNetworkSettings->setValueName(KNetworkAttachmentType_HostOnlyNetwork, wipedOutString(oldAdapterData.m_strHostOnlyNetworkName));
    271 #endif
    272 
    273         /* Load settings: */
    274         m_pEditorNetworkSettings->setAdapterType(oldAdapterData.m_adapterType);
    275         m_pEditorNetworkSettings->setPromiscuousMode(oldAdapterData.m_promiscuousMode);
    276         m_pEditorNetworkSettings->setMACAddress(oldAdapterData.m_strMACAddress);
    277         m_pEditorNetworkSettings->setGenericProperties(oldAdapterData.m_strGenericProperties);
    278         m_pEditorNetworkSettings->setCableConnected(oldAdapterData.m_fCableConnected);
    279 
    280         /* Load port forwarding rules: */
    281         UIPortForwardingDataList portForwardingRules;
    282         for (int i = 0; i < adapterCache.childCount(); ++i)
    283             portForwardingRules << adapterCache.child(i).base();
    284         m_pEditorNetworkSettings->setPortForwardingRules(portForwardingRules);
    285     }
    286 
    287     /* Reload alternatives: */
    288     reloadAlternatives();
    289 }
    290 
    291 void UIMachineSettingsNetwork::putAdapterDataToCache(UISettingsCacheMachineNetworkAdapter &adapterCache)
    292 {
    293     /* Prepare new data: */
    294     UIDataSettingsMachineNetworkAdapter newAdapterData;
    295 
    296     /* Save slot number: */
    297     newAdapterData.m_iSlot = m_iSlot;
    298 
    299     if (m_pEditorNetworkSettings)
    300     {
    301         /* Save adapter activity state: */
    302         newAdapterData.m_fAdapterEnabled = m_pEditorNetworkSettings->isFeatureEnabled();
    303 
    304         /* Save attachment type & alternative name: */
    305         newAdapterData.m_attachmentType = attachmentType();
    306         newAdapterData.m_strBridgedAdapterName = m_pEditorNetworkSettings->valueName(KNetworkAttachmentType_Bridged);
    307         newAdapterData.m_strInternalNetworkName = m_pEditorNetworkSettings->valueName(KNetworkAttachmentType_Internal);
    308         newAdapterData.m_strHostInterfaceName = m_pEditorNetworkSettings->valueName(KNetworkAttachmentType_HostOnly);
    309         newAdapterData.m_strGenericDriverName = m_pEditorNetworkSettings->valueName(KNetworkAttachmentType_Generic);
    310         newAdapterData.m_strNATNetworkName = m_pEditorNetworkSettings->valueName(KNetworkAttachmentType_NATNetwork);
    311 #ifdef VBOX_WITH_CLOUD_NET
    312         newAdapterData.m_strCloudNetworkName = m_pEditorNetworkSettings->valueName(KNetworkAttachmentType_Cloud);
    313 #endif
    314 #ifdef VBOX_WITH_VMNET
    315         newAdapterData.m_strHostOnlyNetworkName = m_pEditorNetworkSettings->valueName(KNetworkAttachmentType_HostOnlyNetwork);
    316 #endif
    317 
    318         /* Save settings: */
    319         newAdapterData.m_adapterType = m_pEditorNetworkSettings->adapterType();
    320         newAdapterData.m_promiscuousMode = m_pEditorNetworkSettings->promiscuousMode();
    321         newAdapterData.m_strMACAddress = m_pEditorNetworkSettings->macAddress();
    322         newAdapterData.m_strGenericProperties = m_pEditorNetworkSettings->genericProperties();
    323         newAdapterData.m_fCableConnected = m_pEditorNetworkSettings->cableConnected();
    324 
    325         /* Save port forwarding rules: */
    326         foreach (const UIDataPortForwardingRule &rule, m_pEditorNetworkSettings->portForwardingRules())
    327             adapterCache.child(rule.name).cacheCurrentData(rule);
    328     }
    329 
    330     /* Cache new data: */
    331     adapterCache.cacheCurrentData(newAdapterData);
    332 }
    333 
    334 bool UIMachineSettingsNetwork::validate(QList<UIValidationMessage> &messages)
    335 {
    336     /* Pass by default: */
    337     bool fPass = true;
    338 
    339     /* Prepare message: */
    340     UIValidationMessage message;
    341     message.first = UITranslator::removeAccelMark(tabTitle());
    342 
    343     /* Validate enabled adapter only: */
    344     if (   m_pEditorNetworkSettings
    345         && m_pEditorNetworkSettings->isFeatureEnabled())
    346     {
    347         /* Validate alternatives: */
    348         switch (attachmentType())
    349         {
    350             case KNetworkAttachmentType_Bridged:
    351             {
    352                 if (alternativeName().isNull())
    353                 {
    354                     message.second << tr("No bridged network adapter is currently selected.");
    355                     fPass = false;
    356                 }
    357                 break;
    358             }
    359             case KNetworkAttachmentType_Internal:
    360             {
    361                 if (alternativeName().isNull())
    362                 {
    363                     message.second << tr("No internal network name is currently specified.");
    364                     fPass = false;
    365                 }
    366                 break;
    367             }
    368 #ifndef VBOX_WITH_VMNET
    369             case KNetworkAttachmentType_HostOnly:
    370             {
    371                 if (alternativeName().isNull())
    372                 {
    373                     message.second << tr("No host-only network adapter is currently selected.");
    374                     fPass = false;
    375                 }
    376                 break;
    377             }
    378 #else /* VBOX_WITH_VMNET */
    379             case KNetworkAttachmentType_HostOnly:
    380             {
    381                 message.second << tr("Host-only adapters are no longer supported, use host-only networks instead.");
    382                 fPass = false;
    383                 break;
    384             }
    385 #endif /* VBOX_WITH_VMNET */
    386             case KNetworkAttachmentType_Generic:
    387             {
    388                 if (alternativeName().isNull())
    389                 {
    390                     message.second << tr("No generic driver is currently selected.");
    391                     fPass = false;
    392                 }
    393                 break;
    394             }
    395             case KNetworkAttachmentType_NATNetwork:
    396             {
    397                 if (alternativeName().isNull())
    398                 {
    399                     message.second << tr("No NAT network name is currently specified.");
    400                     fPass = false;
    401                 }
    402                 break;
    403             }
    404 #ifdef VBOX_WITH_CLOUD_NET
    405             case KNetworkAttachmentType_Cloud:
    406             {
    407                 if (alternativeName().isNull())
    408                 {
    409                     message.second << tr("No cloud network name is currently specified.");
    410                     fPass = false;
    411                 }
    412                 break;
    413             }
    414 #endif /* VBOX_WITH_CLOUD_NET */
    415 #ifdef VBOX_WITH_VMNET
    416             case KNetworkAttachmentType_HostOnlyNetwork:
    417             {
    418                 if (alternativeName().isNull())
    419                 {
    420                     message.second << tr("No host-only network name is currently specified.");
    421                     fPass = false;
    422                 }
    423                 break;
    424             }
    425 #endif /* VBOX_WITH_VMNET */
    426             default:
    427                 break;
    428         }
    429 
    430         /* Validate MAC-address length: */
    431         if (m_pEditorNetworkSettings->macAddress().size() < 12)
    432         {
    433             message.second << tr("The MAC address must be 12 hexadecimal digits long.");
    434             fPass = false;
    435         }
    436 
    437         /* Make sure MAC-address is unicast: */
    438         if (m_pEditorNetworkSettings->macAddress().size() >= 2)
    439         {
    440             if (m_pEditorNetworkSettings->macAddress().indexOf(QRegularExpression("^[0-9A-Fa-f][02468ACEace]")) != 0)
    441             {
    442                 message.second << tr("The second digit in the MAC address may not be odd as only unicast addresses are allowed.");
    443                 fPass = false;
    444             }
    445         }
    446     }
    447 
    448     /* Serialize message: */
    449     if (!message.second.isEmpty())
    450         messages << message;
    451 
    452     /* Return result: */
    453     return fPass;
    454 }
    455 
    456 QWidget *UIMachineSettingsNetwork::setOrderAfter(QWidget *pWidget)
    457 {
    458     setTabOrder(pWidget, m_pEditorNetworkSettings);
    459     return m_pEditorNetworkSettings;
    460 }
    461 
    462 QString UIMachineSettingsNetwork::tabTitle() const
    463 {
    464     return UICommon::tr("Adapter %1").arg(QString("&%1").arg(m_iSlot + 1));
    465 }
    466 
    467 KNetworkAttachmentType UIMachineSettingsNetwork::attachmentType() const
    468 {
    469     return m_pEditorNetworkSettings ? m_pEditorNetworkSettings->valueType() : KNetworkAttachmentType_Null;
    470 }
    471 
    472 QString UIMachineSettingsNetwork::alternativeName(KNetworkAttachmentType enmType /* = KNetworkAttachmentType_Null */) const
    473 {
    474     if (enmType == KNetworkAttachmentType_Null)
    475         enmType = attachmentType();
    476     return m_pEditorNetworkSettings ? m_pEditorNetworkSettings->valueName(enmType) : QString();
    477 }
    478 
    479 void UIMachineSettingsNetwork::polishTab()
    480 {
    481     if (   m_pEditorNetworkSettings
    482         && m_pParentPage)
    483     {
    484         /* General stuff: */
    485         m_pEditorNetworkSettings->setFeatureAvailable(m_pParentPage->isMachineOffline());
    486 
    487         /* Attachment stuff: */
    488         m_pEditorNetworkSettings->setAttachmentOptionsAvailable(m_pParentPage->isMachineInValidMode());
    489 
    490         /* Advanced stuff: */
    491         m_pEditorNetworkSettings->setAdapterOptionsAvailable(m_pParentPage->isMachineOffline());
    492         m_pEditorNetworkSettings->setPromiscuousOptionsAvailable(   attachmentType() != KNetworkAttachmentType_Null
    493                                                                  && attachmentType() != KNetworkAttachmentType_Generic
    494                                                                  && attachmentType() != KNetworkAttachmentType_NAT);
    495         m_pEditorNetworkSettings->setMACOptionsAvailable(m_pParentPage->isMachineOffline());
    496         m_pEditorNetworkSettings->setGenericPropertiesAvailable(attachmentType() == KNetworkAttachmentType_Generic);
    497         m_pEditorNetworkSettings->setCableOptionsAvailable(m_pParentPage->isMachineInValidMode());
    498         m_pEditorNetworkSettings->setForwardingOptionsAvailable(attachmentType() == KNetworkAttachmentType_NAT);
    499     }
    500 }
    501 
    502 void UIMachineSettingsNetwork::reloadAlternatives()
    503 {
    504     if (   m_pEditorNetworkSettings
    505         && m_pParentPage)
    506     {
    507         m_pEditorNetworkSettings->setValueNames(KNetworkAttachmentType_Bridged, m_pParentPage->bridgedAdapterList());
    508         m_pEditorNetworkSettings->setValueNames(KNetworkAttachmentType_Internal, m_pParentPage->internalNetworkList());
    509         m_pEditorNetworkSettings->setValueNames(KNetworkAttachmentType_HostOnly, m_pParentPage->hostInterfaceList());
    510         m_pEditorNetworkSettings->setValueNames(KNetworkAttachmentType_Generic, m_pParentPage->genericDriverList());
    511         m_pEditorNetworkSettings->setValueNames(KNetworkAttachmentType_NATNetwork, m_pParentPage->natNetworkList());
    512 #ifdef VBOX_WITH_CLOUD_NET
    513         m_pEditorNetworkSettings->setValueNames(KNetworkAttachmentType_Cloud, m_pParentPage->cloudNetworkList());
    514 #endif
    515 #ifdef VBOX_WITH_VMNET
    516         m_pEditorNetworkSettings->setValueNames(KNetworkAttachmentType_HostOnlyNetwork, m_pParentPage->hostOnlyNetworkList());
    517 #endif
    518     }
    519 }
    520 
    521 void UIMachineSettingsNetwork::retranslateUi()
    522 {
    523     /* Reload alternatives: */
    524     reloadAlternatives();
    525 }
    526 
    527 void UIMachineSettingsNetwork::sltHandleAlternativeNameChange()
    528 {
    529     if (m_pEditorNetworkSettings)
    530     {
    531         /* Notify other adapter tabs if alternative name for certain type is changed: */
    532         switch (attachmentType())
    533         {
    534             case KNetworkAttachmentType_Internal:
    535             case KNetworkAttachmentType_Generic:
    536             {
    537                 if (!m_pEditorNetworkSettings->valueName(attachmentType()).isNull())
    538                     emit sigAlternativeNameChanged();
    539                 break;
    540             }
    541             default:
    542                 break;
    543         }
    544     }
    545 
    546     /* Notify validity changed: */
    547     emit sigValidityChanged();
    548 }
    549 
    550 void UIMachineSettingsNetwork::prepare()
    551 {
    552     /* Prepare everything: */
    553     prepareWidgets();
    554     prepareConnections();
    555 
    556     /* Apply language settings: */
    557     retranslateUi();
    558 }
    559 
    560 void UIMachineSettingsNetwork::prepareWidgets()
    561 {
    562     /* Prepare main layout: */
    563     QVBoxLayout *pLayout = new QVBoxLayout(this);
    564     if (pLayout)
    565     {
    566         pLayout->setContentsMargins(0, 0, 0, 0);
    567 
    568         /* Prepare settings editor: */
    569         m_pEditorNetworkSettings = new UINetworkSettingsEditor(this);
    570         if (m_pEditorNetworkSettings)
    571         {
    572             addEditor(m_pEditorNetworkSettings);
    573             pLayout->addWidget(m_pEditorNetworkSettings);
    574         }
    575 
    576         pLayout->addStretch();
    577     }
    578 }
    579 
    580 void UIMachineSettingsNetwork::prepareConnections()
    581 {
    582     if (m_pEditorNetworkSettings)
    583     {
    584         /* Attachment connections: */
    585         connect(m_pEditorNetworkSettings, &UINetworkSettingsEditor::sigFeatureStateChanged,
    586                 this, &UIMachineSettingsNetwork::sigValidityChanged);
    587         connect(m_pEditorNetworkSettings, &UINetworkSettingsEditor::sigAttachmentTypeChanged,
    588                 this, &UIMachineSettingsNetwork::sigValidityChanged);
    589         connect(m_pEditorNetworkSettings, &UINetworkSettingsEditor::sigAlternativeNameChanged,
    590                 this, &UIMachineSettingsNetwork::sltHandleAlternativeNameChange);
    591 
    592         /* Advanced connections: */
    593         connect(m_pEditorNetworkSettings, &UINetworkSettingsEditor::sigMACAddressChanged,
    594                 this, &UIMachineSettingsNetwork::sigValidityChanged);
    595     }
    596 }
    597 
    598 
    599160/*********************************************************************************************************************************
    600161*   Class UIMachineSettingsNetworkPage implementation.                                                                           *
    … …  
    712273        return;
    713274
    714     /* Setup tab order: */
    715     AssertPtrReturnVoid(firstWidget());
    716     setTabOrder(firstWidget(), m_pTabWidget->focusProxy());
    717     QWidget *pLastFocusWidget = m_pTabWidget->focusProxy();
    718 
    719     /* For each adapter: */
     275    /* Load old data from cache: */
    720276    for (int iSlot = 0; iSlot < m_pTabWidget->count(); ++iSlot)
    721     {
    722         /* Get adapter page: */
    723         UIMachineSettingsNetwork *pTab = m_tabEditors.at(iSlot);
    724         AssertPtrReturnVoid(pTab);
    725 
    726         /* Load old data from cache: */
    727         pTab->getAdapterDataFromCache(m_pCache->child(iSlot));
    728 
    729         /* Setup tab order: */
    730         pLastFocusWidget = pTab->setOrderAfter(pLastFocusWidget);
    731     }
     277        getFromCache(iSlot, m_pCache->child(iSlot));
    732278
    733279    /* Apply language settings: */
    … …  
    751297    UIDataSettingsMachineNetwork newNetworkData;
    752298
    753     /* For each adapter: */
     299    /* Gather new data to cache: */
    754300    for (int iSlot = 0; iSlot < m_pTabWidget->count(); ++iSlot)
    755     {
    756         /* Get adapter page: */
    757         UIMachineSettingsNetwork *pTab = m_tabEditors.at(iSlot);
    758         AssertPtrReturnVoid(pTab);
    759 
    760         /* Gather new data: */
    761         pTab->putAdapterDataToCache(m_pCache->child(iSlot));
    762     }
     301        putToCache(iSlot, m_pCache->child(iSlot));
    763302
    764303    /* Cache new data: */
    … …  
    787326    bool fValid = true;
    788327
    789     /* Delegate validation to adapter tabs: */
     328    /* Delegate validation to particular tab-editor: */
    790329    for (int iSlot = 0; iSlot < m_pTabWidget->count(); ++iSlot)
    791     {
    792         UIMachineSettingsNetwork *pTab = m_tabEditors.at(iSlot);
    793         AssertPtrReturn(pTab, false);
    794         if (!pTab->validate(messages))
     330        if (!validate(iSlot, messages))
    795331            fValid = false;
    796     }
    797332
    798333    /* Return result: */
    … …  
    808343    for (int iSlot = 0; iSlot < m_pTabWidget->count(); ++iSlot)
    809344    {
    810         UIMachineSettingsNetwork *pTab = m_tabEditors.at(iSlot);
    811         AssertPtrReturnVoid(pTab);
    812         m_pTabWidget->setTabText(iSlot, pTab->tabTitle());
     345        m_pTabWidget->setTabText(iSlot, tabTitle(iSlot));
     346        reloadAlternatives(iSlot);
    813347    }
    814348}
    … …  
    828362                                     m_pCache->childCount() > iSlot &&
    829363                                     m_pCache->child(iSlot).base().m_fAdapterEnabled));
    830         UIMachineSettingsNetwork *pTab = m_tabEditors.at(iSlot);
    831         AssertPtrReturnVoid(pTab);
    832         pTab->polishTab();
     364        polishTab(iSlot);
    833365    }
    834366}
    … …  
    851383        return;
    852384
    853     /* Determine the sender tab: */
    854     UIMachineSettingsNetwork *pSender = qobject_cast<UIMachineSettingsNetwork*>(sender());
     385    /* Determine the sender tab-editor: */
     386    UINetworkSettingsEditor *pSender = qobject_cast<UINetworkSettingsEditor*>(sender());
    855387    AssertPtrReturnVoid(pSender);
    856388
    857     /* Enumerate alternatives for certain types: */
    858     switch (pSender->attachmentType())
    859     {
    860         case KNetworkAttachmentType_Internal: refreshInternalNetworkList(); break;
    861         case KNetworkAttachmentType_Generic: refreshGenericDriverList(); break;
    862         default: break;
     389    /* Determine the sender slot: */
     390    const int iSenderSlot = m_tabEditors.indexOf(pSender);
     391
     392    /* Check if we need to update other adapter tabs if
     393     * alternative name for certain type is changed: */
     394    bool fUpdateOthers = false;
     395    switch (attachmentType(iSenderSlot))
     396    {
     397        case KNetworkAttachmentType_Internal:
     398        {
     399            if (!pSender->valueName(attachmentType(iSenderSlot)).isNull())
     400            {
     401                refreshInternalNetworkList();
     402                fUpdateOthers = true;
     403            }
     404            break;
     405        }
     406        case KNetworkAttachmentType_Generic:
     407        {
     408            if (!pSender->valueName(attachmentType(iSenderSlot)).isNull())
     409            {
     410                refreshGenericDriverList();
     411                fUpdateOthers = true;
     412            }
     413            break;
     414        }
     415        default:
     416            break;
    863417    }
    864418
    865419    /* Update alternatives for all the tabs besides the sender: */
    866     for (int iSlot = 0; iSlot < m_pTabWidget->count(); ++iSlot)
    867     {
    868         /* Get the iterated tab: */
    869         UIMachineSettingsNetwork *pTab = m_tabEditors.at(iSlot);
    870         AssertPtrReturnVoid(pTab);
    871 
    872         /* Update all the tabs (except sender): */
    873         if (pTab != pSender)
    874             pTab->reloadAlternatives();
    875     }
     420    if (fUpdateOthers)
     421        for (int iSlot = 0; iSlot < m_pTabWidget->count(); ++iSlot)
     422            if (iSlot != iSenderSlot)
     423                reloadAlternatives(iSlot);
     424
     425    /* Revalidate full page: */
     426    revalidate();
    876427}
    877428
    … …  
    932483#endif
    933484
    934             /* Prepare name and system editor: */
    935             UIMachineSettingsNetwork *pEditor = new UIMachineSettingsNetwork(pTab, this);
     485            /* Prepare settings editor: */
     486            UINetworkSettingsEditor *pEditor = new UINetworkSettingsEditor(this);
    936487            if (pEditor)
    937488            {
    … …  
    950501}
    951502
    952 void UIMachineSettingsNetworkPage::prepareConnections(UIMachineSettingsNetwork *pTabEditor)
    953 {
    954     /* Tab connections: */
    955     connect(pTabEditor, &UIMachineSettingsNetwork::sigAlternativeNameChanged,
     503void UIMachineSettingsNetworkPage::prepareConnections(UINetworkSettingsEditor *pTabEditor)
     504{
     505    /* Attachment connections: */
     506    connect(pTabEditor, &UINetworkSettingsEditor::sigFeatureStateChanged,
     507            this, &UIMachineSettingsNetworkPage::revalidate);
     508    connect(pTabEditor, &UINetworkSettingsEditor::sigAttachmentTypeChanged,
     509            this, &UIMachineSettingsNetworkPage::revalidate);
     510    connect(pTabEditor, &UINetworkSettingsEditor::sigAlternativeNameChanged,
    956511            this, &UIMachineSettingsNetworkPage::sltHandleAlternativeNameChange);
    957     connect(pTabEditor, &UIMachineSettingsNetwork::sigValidityChanged,
     512
     513    /* Advanced connections: */
     514    connect(pTabEditor, &UINetworkSettingsEditor::sigMACAddressChanged,
    958515            this, &UIMachineSettingsNetworkPage::revalidate);
    959516}
    … …  
    964521    delete m_pCache;
    965522    m_pCache = 0;
     523}
     524
     525void UIMachineSettingsNetworkPage::polishTab(int iSlot)
     526{
     527    /* Acquire tab-editor: */
     528    UINetworkSettingsEditor *pTabEditor = m_tabEditors.at(iSlot);
     529    AssertPtrReturnVoid(pTabEditor);
     530
     531    /* General stuff: */
     532    pTabEditor->setFeatureAvailable(isMachineOffline());
     533
     534    /* Attachment stuff: */
     535    pTabEditor->setAttachmentOptionsAvailable(isMachineInValidMode());
     536
     537    /* Advanced stuff: */
     538    pTabEditor->setAdapterOptionsAvailable(isMachineOffline());
     539    pTabEditor->setPromiscuousOptionsAvailable(   attachmentType(iSlot) != KNetworkAttachmentType_Null
     540                                               && attachmentType(iSlot) != KNetworkAttachmentType_Generic
     541                                               && attachmentType(iSlot) != KNetworkAttachmentType_NAT);
     542    pTabEditor->setMACOptionsAvailable(isMachineOffline());
     543    pTabEditor->setGenericPropertiesAvailable(attachmentType(iSlot) == KNetworkAttachmentType_Generic);
     544    pTabEditor->setCableOptionsAvailable(isMachineInValidMode());
     545    pTabEditor->setForwardingOptionsAvailable(attachmentType(iSlot) == KNetworkAttachmentType_NAT);
     546}
     547
     548void UIMachineSettingsNetworkPage::getFromCache(int iSlot, const UISettingsCacheMachineNetworkAdapter &adapterCache)
     549{
     550    /* Acquire tab-editor: */
     551    UINetworkSettingsEditor *pTabEditor = m_tabEditors.at(iSlot);
     552    AssertPtrReturnVoid(pTabEditor);
     553
     554    /* Get old data: */
     555    const UIDataSettingsMachineNetworkAdapter &oldAdapterData = adapterCache.base();
     556
     557    if (pTabEditor)
     558    {
     559        /* Load adapter activity state: */
     560        pTabEditor->setFeatureEnabled(oldAdapterData.m_fAdapterEnabled);
     561
     562        /* Load attachment type: */
     563        pTabEditor->setValueType(oldAdapterData.m_attachmentType);
     564        /* Load alternative names: */
     565        pTabEditor->setValueName(KNetworkAttachmentType_Bridged, wipedOutString(oldAdapterData.m_strBridgedAdapterName));
     566        pTabEditor->setValueName(KNetworkAttachmentType_Internal, wipedOutString(oldAdapterData.m_strInternalNetworkName));
     567        pTabEditor->setValueName(KNetworkAttachmentType_HostOnly, wipedOutString(oldAdapterData.m_strHostInterfaceName));
     568        pTabEditor->setValueName(KNetworkAttachmentType_Generic, wipedOutString(oldAdapterData.m_strGenericDriverName));
     569        pTabEditor->setValueName(KNetworkAttachmentType_NATNetwork, wipedOutString(oldAdapterData.m_strNATNetworkName));
     570#ifdef VBOX_WITH_CLOUD_NET
     571        pTabEditor->setValueName(KNetworkAttachmentType_Cloud, wipedOutString(oldAdapterData.m_strCloudNetworkName));
     572#endif
     573#ifdef VBOX_WITH_VMNET
     574        pTabEditor->setValueName(KNetworkAttachmentType_HostOnlyNetwork, wipedOutString(oldAdapterData.m_strHostOnlyNetworkName));
     575#endif
     576
     577        /* Load settings: */
     578        pTabEditor->setAdapterType(oldAdapterData.m_adapterType);
     579        pTabEditor->setPromiscuousMode(oldAdapterData.m_promiscuousMode);
     580        pTabEditor->setMACAddress(oldAdapterData.m_strMACAddress);
     581        pTabEditor->setGenericProperties(oldAdapterData.m_strGenericProperties);
     582        pTabEditor->setCableConnected(oldAdapterData.m_fCableConnected);
     583
     584        /* Load port forwarding rules: */
     585        UIPortForwardingDataList portForwardingRules;
     586        for (int i = 0; i < adapterCache.childCount(); ++i)
     587            portForwardingRules << adapterCache.child(i).base();
     588        pTabEditor->setPortForwardingRules(portForwardingRules);
     589    }
     590
     591    /* Reload alternatives: */
     592    reloadAlternatives(iSlot);
     593}
     594
     595void UIMachineSettingsNetworkPage::putToCache(int iSlot, UISettingsCacheMachineNetworkAdapter &adapterCache)
     596{
     597    /* Acquire tab-editor: */
     598    UINetworkSettingsEditor *pTabEditor = m_tabEditors.at(iSlot);
     599    AssertPtrReturnVoid(pTabEditor);
     600
     601    /* Prepare new data: */
     602    UIDataSettingsMachineNetworkAdapter newAdapterData;
     603
     604    /* Save slot number: */
     605    newAdapterData.m_iSlot = iSlot;
     606
     607    if (pTabEditor)
     608    {
     609        /* Save adapter activity state: */
     610        newAdapterData.m_fAdapterEnabled = pTabEditor->isFeatureEnabled();
     611
     612        /* Save attachment type & alternative name: */
     613        newAdapterData.m_attachmentType = attachmentType(iSlot);
     614        newAdapterData.m_strBridgedAdapterName = pTabEditor->valueName(KNetworkAttachmentType_Bridged);
     615        newAdapterData.m_strInternalNetworkName = pTabEditor->valueName(KNetworkAttachmentType_Internal);
     616        newAdapterData.m_strHostInterfaceName = pTabEditor->valueName(KNetworkAttachmentType_HostOnly);
     617        newAdapterData.m_strGenericDriverName = pTabEditor->valueName(KNetworkAttachmentType_Generic);
     618        newAdapterData.m_strNATNetworkName = pTabEditor->valueName(KNetworkAttachmentType_NATNetwork);
     619#ifdef VBOX_WITH_CLOUD_NET
     620        newAdapterData.m_strCloudNetworkName = pTabEditor->valueName(KNetworkAttachmentType_Cloud);
     621#endif
     622#ifdef VBOX_WITH_VMNET
     623        newAdapterData.m_strHostOnlyNetworkName = pTabEditor->valueName(KNetworkAttachmentType_HostOnlyNetwork);
     624#endif
     625
     626        /* Save settings: */
     627        newAdapterData.m_adapterType = pTabEditor->adapterType();
     628        newAdapterData.m_promiscuousMode = pTabEditor->promiscuousMode();
     629        newAdapterData.m_strMACAddress = pTabEditor->macAddress();
     630        newAdapterData.m_strGenericProperties = pTabEditor->genericProperties();
     631        newAdapterData.m_fCableConnected = pTabEditor->cableConnected();
     632
     633        /* Save port forwarding rules: */
     634        foreach (const UIDataPortForwardingRule &rule, pTabEditor->portForwardingRules())
     635            adapterCache.child(rule.name).cacheCurrentData(rule);
     636    }
     637
     638    /* Cache new data: */
     639    adapterCache.cacheCurrentData(newAdapterData);
     640}
     641
     642void UIMachineSettingsNetworkPage::reloadAlternatives(int iSlot)
     643{
     644    /* Acquire tab-editor: */
     645    UINetworkSettingsEditor *pTabEditor = m_tabEditors.at(iSlot);
     646    AssertPtrReturnVoid(pTabEditor);
     647
     648    pTabEditor->setValueNames(KNetworkAttachmentType_Bridged, bridgedAdapterList());
     649    pTabEditor->setValueNames(KNetworkAttachmentType_Internal, internalNetworkList());
     650    pTabEditor->setValueNames(KNetworkAttachmentType_HostOnly, hostInterfaceList());
     651    pTabEditor->setValueNames(KNetworkAttachmentType_Generic, genericDriverList());
     652    pTabEditor->setValueNames(KNetworkAttachmentType_NATNetwork, natNetworkList());
     653#ifdef VBOX_WITH_CLOUD_NET
     654    pTabEditor->setValueNames(KNetworkAttachmentType_Cloud, cloudNetworkList());
     655#endif
     656#ifdef VBOX_WITH_VMNET
     657    pTabEditor->setValueNames(KNetworkAttachmentType_HostOnlyNetwork, hostOnlyNetworkList());
     658#endif
     659}
     660
     661KNetworkAttachmentType UIMachineSettingsNetworkPage::attachmentType(int iSlot) const
     662{
     663    /* Acquire tab-editor: */
     664    UINetworkSettingsEditor *pTabEditor = m_tabEditors.at(iSlot);
     665    AssertPtrReturn(pTabEditor, KNetworkAttachmentType_Null);
     666    return pTabEditor->valueType();
     667}
     668
     669QString UIMachineSettingsNetworkPage::alternativeName(int iSlot,
     670                                                      KNetworkAttachmentType enmType /* = KNetworkAttachmentType_Null */) const
     671{
     672    /* Acquire tab-editor: */
     673    UINetworkSettingsEditor *pTabEditor = m_tabEditors.at(iSlot);
     674    AssertPtrReturn(pTabEditor, QString());
     675    if (enmType == KNetworkAttachmentType_Null)
     676        enmType = attachmentType(iSlot);
     677    return pTabEditor->valueName(enmType);
     678}
     679
     680bool UIMachineSettingsNetworkPage::validate(int iSlot, QList<UIValidationMessage> &messages)
     681{
     682    /* Acquire tab-editor: */
     683    UINetworkSettingsEditor *pTabEditor = m_tabEditors.at(iSlot);
     684    AssertPtrReturn(pTabEditor, false);
     685
     686    /* Pass by default: */
     687    bool fPass = true;
     688
     689    /* Prepare message: */
     690    UIValidationMessage message;
     691    message.first = UITranslator::removeAccelMark(tabTitle(iSlot));
     692
     693    /* Validate enabled adapter only: */
     694    if (   pTabEditor
     695        && pTabEditor->isFeatureEnabled())
     696    {
     697        /* Validate alternatives: */
     698        switch (attachmentType(iSlot))
     699        {
     700            case KNetworkAttachmentType_Bridged:
     701            {
     702                if (alternativeName(iSlot).isNull())
     703                {
     704                    message.second << tr("No bridged network adapter is currently selected.");
     705                    fPass = false;
     706                }
     707                break;
     708            }
     709            case KNetworkAttachmentType_Internal:
     710            {
     711                if (alternativeName(iSlot).isNull())
     712                {
     713                    message.second << tr("No internal network name is currently specified.");
     714                    fPass = false;
     715                }
     716                break;
     717            }
     718#ifndef VBOX_WITH_VMNET
     719            case KNetworkAttachmentType_HostOnly:
     720            {
     721                if (alternativeName(iSlot).isNull())
     722                {
     723                    message.second << tr("No host-only network adapter is currently selected.");
     724                    fPass = false;
     725                }
     726                break;
     727            }
     728#else /* VBOX_WITH_VMNET */
     729            case KNetworkAttachmentType_HostOnly:
     730            {
     731                message.second << tr("Host-only adapters are no longer supported, use host-only networks instead.");
     732                fPass = false;
     733                break;
     734            }
     735#endif /* VBOX_WITH_VMNET */
     736            case KNetworkAttachmentType_Generic:
     737            {
     738                if (alternativeName(iSlot).isNull())
     739                {
     740                    message.second << tr("No generic driver is currently selected.");
     741                    fPass = false;
     742                }
     743                break;
     744            }
     745            case KNetworkAttachmentType_NATNetwork:
     746            {
     747                if (alternativeName(iSlot).isNull())
     748                {
     749                    message.second << tr("No NAT network name is currently specified.");
     750                    fPass = false;
     751                }
     752                break;
     753            }
     754#ifdef VBOX_WITH_CLOUD_NET
     755            case KNetworkAttachmentType_Cloud:
     756            {
     757                if (alternativeName(iSlot).isNull())
     758                {
     759                    message.second << tr("No cloud network name is currently specified.");
     760                    fPass = false;
     761                }
     762                break;
     763            }
     764#endif /* VBOX_WITH_CLOUD_NET */
     765#ifdef VBOX_WITH_VMNET
     766            case KNetworkAttachmentType_HostOnlyNetwork:
     767            {
     768                if (alternativeName(iSlot).isNull())
     769                {
     770                    message.second << tr("No host-only network name is currently specified.");
     771                    fPass = false;
     772                }
     773                break;
     774            }
     775#endif /* VBOX_WITH_VMNET */
     776            default:
     777                break;
     778        }
     779
     780        /* Validate MAC-address length: */
     781        if (pTabEditor->macAddress().size() < 12)
     782        {
     783            message.second << tr("The MAC address must be 12 hexadecimal digits long.");
     784            fPass = false;
     785        }
     786
     787        /* Make sure MAC-address is unicast: */
     788        if (pTabEditor->macAddress().size() >= 2)
     789        {
     790            if (pTabEditor->macAddress().indexOf(QRegularExpression("^[0-9A-Fa-f][02468ACEace]")) != 0)
     791            {
     792                message.second << tr("The second digit in the MAC address may not be odd as only unicast addresses are allowed.");
     793                fPass = false;
     794            }
     795        }
     796    }
     797
     798    /* Serialize message: */
     799    if (!message.second.isEmpty())
     800        messages << message;
     801
     802    /* Return result: */
     803    return fPass;
    966804}
    967805
    … …  
    987825    for (int iSlot = 0; iSlot < m_pTabWidget->count(); ++iSlot)
    988826    {
    989         UIMachineSettingsNetwork *pTab = m_tabEditors.at(iSlot);
    990         AssertPtrReturnVoid(pTab);
    991         const QString strName = pTab->alternativeName(KNetworkAttachmentType_Internal);
     827        const QString strName = alternativeName(iSlot, KNetworkAttachmentType_Internal);
    992828        if (!strName.isEmpty() && !m_internalNetworkList.contains(strName))
    993829            m_internalNetworkList << strName;
    … …  
    1032868    for (int iSlot = 0; iSlot < m_pTabWidget->count(); ++iSlot)
    1033869    {
    1034         UIMachineSettingsNetwork *pTab = m_tabEditors.at(iSlot);
    1035         AssertPtrReturnVoid(pTab);
    1036         const QString strName = pTab->alternativeName(KNetworkAttachmentType_Generic);
     870        const QString strName = alternativeName(iSlot, KNetworkAttachmentType_Generic);
    1037871        if (!strName.isEmpty() && !m_genericDriverList.contains(strName))
    1038872            m_genericDriverList << strName;
    … …  
    1044878    /* Reload nat networks: */
    1045879    m_natNetworkList = UINetworkAttachmentEditor::natNetworks();
     880}
     881
     882/* static */
     883QString UIMachineSettingsNetworkPage::tabTitle(int iSlot)
     884{
     885    return UICommon::tr("Adapter %1").arg(QString("&%1").arg(iSlot + 1));
    1046886}
    1047887
    … …  
    13321172    return fSuccess;
    13331173}
    1334 
    1335 # include "UIMachineSettingsNetwork.moc"

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsNetwork.h

    r101591 r101594  
    3838/* Forward declarations: */
    3939class QITabWidget;
    40 class UIMachineSettingsNetwork;
     40class UINetworkSettingsEditor;
    4141struct UIDataSettingsMachineNetwork;
    4242struct UIDataSettingsMachineNetworkAdapter;
    … …  
    123123    void prepareTab();
    124124    /** Prepares connections. */
    125     void prepareConnections(UIMachineSettingsNetwork *pTabEditor);
     125    void prepareConnections(UINetworkSettingsEditor *pTabEditor);
    126126    /** Cleanups all. */
    127127    void cleanup();
     128
     129    /** Performs tab polishing for specified @a iSlot. */
     130    void polishTab(int iSlot);
     131
     132    /** Loads adapter data for specified @a iSlot from @a adapterCache to corresponding widgets. */
     133    void getFromCache(int iSlot, const UISettingsCacheMachineNetworkAdapter &adapterCache);
     134    /** Saves adapter data for specified @a iSlot from corresponding widgets to @a adapterCache. */
     135    void putToCache(int iSlot, UISettingsCacheMachineNetworkAdapter &adapterCache);
     136
     137    /** Reloads tab alternatives for specified @a iSlot. */
     138    void reloadAlternatives(int iSlot);
     139
     140    /** Returns tab attachment type for specified @a iSlot. */
     141    KNetworkAttachmentType attachmentType(int iSlot) const;
     142    /** Returne tab alternative name for specified @a iSlot and @a enmType. */
     143    QString alternativeName(int iSlot, KNetworkAttachmentType enmType = KNetworkAttachmentType_Null) const;
     144
     145    /** Performs validation for specified @a iSlot, updates @a messages list if something is wrong. */
     146    bool validate(int iSlot, QList<UIValidationMessage> &messages);
    128147
    129148    /** Repopulates bridged adapter list. */
    … …  
    145164    void refreshHostOnlyNetworkList();
    146165#endif
     166
     167    /** Returns tab title for specified @a iSlot. */
     168    static QString tabTitle(int iSlot);
    147169
    148170    /** Loads generic properties from passed @a adapter. */
    … …  
    185207    QITabWidget *m_pTabWidget;
    186208
    187     /** Holds the list of tab editors. */
    188     QList<UIMachineSettingsNetwork*>  m_tabEditors;
     209    /** Holds the list of tab-editors. */
     210    QList<UINetworkSettingsEditor*>  m_tabEditors;
    189211};
    190212
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