File indexing completed on 2024-09-15 04:54:58

 /*
     SPDX-FileCopyrightText: 2013 Lukas Tinkl <ltinkl@redhat.com>
     SPDX-FileCopyrightText: 2013 Jan Grulich <jgrulich@redhat.com>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "ssidcombobox.h"
 #include "uiutils.h"
 
 #include <NetworkManagerQt/Manager>
 #include <NetworkManagerQt/WirelessDevice>
 
 #include <KLocalizedString>
 
 bool signalCompare(const NetworkManager::WirelessNetwork::Ptr &one, const NetworkManager::WirelessNetwork::Ptr &two)
 {
     return one->signalStrength() > two->signalStrength();
 }
 
 SsidComboBox::SsidComboBox(QWidget *parent)
     : KComboBox(parent)
 {
     setEditable(true);
     setInsertPolicy(QComboBox::NoInsert);
 
     connect(this, &SsidComboBox::editTextChanged, this, &SsidComboBox::slotEditTextChanged);
     connect(this, QOverload<int>::of(&SsidComboBox::activated), this, &SsidComboBox::slotCurrentIndexChanged);
 }
 
 QString SsidComboBox::ssid() const
 {
     if (currentIndex() == 0 || currentText() != itemData(currentIndex()).toString()) {
         return currentText();
     } else {
         return itemData(currentIndex()).toString();
     }
 }
 
 void SsidComboBox::slotEditTextChanged(const QString &text)
 {
     if (!text.contains(QLatin1String("Security:")) && !text.contains(QLatin1String("Frequency:"))) {
         Q_EMIT ssidChanged();
     }
 }
 
 void SsidComboBox::slotCurrentIndexChanged(int)
 {
     setEditText(itemData(currentIndex()).toString());
 }
 
 void SsidComboBox::init(const QString &ssid)
 {
     m_initialSsid = ssid;
 
     // qCDebug(PLASMA_NM_EDITOR_LOG) << "Initial ssid:" << m_initialSsid;
 
     QList<NetworkManager::WirelessNetwork::Ptr> networks;
 
     for (const NetworkManager::Device::Ptr &device : NetworkManager::networkInterfaces()) {
         if (device->type() == NetworkManager::Device::Wifi) {
             NetworkManager::WirelessDevice::Ptr wifiDevice = device.objectCast<NetworkManager::WirelessDevice>();
 
             for (const NetworkManager::WirelessNetwork::Ptr &newNetwork : wifiDevice->networks()) {
                 bool found = false;
                 for (const NetworkManager::WirelessNetwork::Ptr &existingNetwork : networks) {
                     if (newNetwork->ssid() == existingNetwork->ssid()) {
                         if (newNetwork->signalStrength() > existingNetwork->signalStrength()) {
                             networks.removeOne(existingNetwork);
                             break;
                         } else {
                             found = true;
                             break;
                         }
                     }
                 }
                 if (!found) {
                     networks << newNetwork;
                 }
             }
         }
     }
 
     std::sort(networks.begin(), networks.end(), signalCompare);
     addSsidsToCombo(networks);
 
     int index = findData(m_initialSsid);
     if (index == -1) {
         insertItem(0, m_initialSsid, m_initialSsid);
         setCurrentIndex(0);
     } else {
         setCurrentIndex(index);
     }
     setEditText(m_initialSsid);
 }
 
 void SsidComboBox::addSsidsToCombo(const QList<NetworkManager::WirelessNetwork::Ptr> &networks)
 {
     QList<NetworkManager::WirelessDevice::Ptr> wifiDevices;
 
     for (const NetworkManager::Device::Ptr &dev : NetworkManager::networkInterfaces()) {
         if (dev->type() == NetworkManager::Device::Wifi) {
             wifiDevices << dev.objectCast<NetworkManager::WirelessDevice>();
         }
     }
 
     bool empty = true;
 
     for (const NetworkManager::WirelessNetwork::Ptr &network : networks) {
         NetworkManager::AccessPoint::Ptr accessPoint = network->referenceAccessPoint();
 
         if (!accessPoint) {
             continue;
         }
 
         for (const NetworkManager::WirelessDevice::Ptr &wifiDev : std::as_const(wifiDevices)) {
             if (wifiDev->findNetwork(network->ssid()) == network) {
                 if (!empty) {
                     insertSeparator(count());
                 }
                 empty = false;
 
                 NetworkManager::WirelessSecurityType security =
                     NetworkManager::findBestWirelessSecurity(wifiDev->wirelessCapabilities(),
                                                              true,
                                                              (wifiDev->mode() == NetworkManager::WirelessDevice::Adhoc),
                                                              accessPoint->capabilities(),
                                                              accessPoint->wpaFlags(),
                                                              accessPoint->rsnFlags());
                 if (security != NetworkManager::UnknownSecurity && security != NetworkManager::NoneSecurity) {
                     const QString text = i18n("%1 (%2%)\nSecurity: %3\nFrequency: %4 Mhz",
                                               accessPoint->ssid(),
                                               network->signalStrength(),
                                               UiUtils::labelFromWirelessSecurity(security),
                                               accessPoint->frequency());
                     addItem(QIcon::fromTheme(QStringLiteral("object-locked")), text, accessPoint->ssid());
                 } else {
                     const QString text =
                         i18n("%1 (%2%)\nSecurity: Insecure\nFrequency: %3 Mhz", accessPoint->ssid(), network->signalStrength(), accessPoint->frequency());
                     addItem(QIcon::fromTheme(QStringLiteral("object-unlocked")), text, accessPoint->ssid());
                 }
             }
         }
     }
 }
 
 #include "moc_ssidcombobox.cpp"