Add new WiFi menu

main/CMakeLists.txt

@@ -71,7 +71,6 @@ set(headers
     displays/lockscreen.h
     displays/menudisplaywithtime.cpp
     displays/menus/aboutmenu.h
-    displays/menus/accesspointwifisettingsmenu.h
     displays/menus/batterydebugmenu.h
     displays/menus/batterymenu.h
     displays/menus/blesettingsmenu.h
@@ -93,7 +92,6 @@ set(headers
     displays/menus/feedbackdebugmenu.h
     displays/menus/garagenmenu.h
     displays/menus/gametrakmodesettingsmenu.h
-    displays/menus/genericwifisettingsmenu.h
     displays/menus/graphsmenu.h
     displays/menus/greenpassmenu.h
     displays/menus/handbremssettingsmenu.h
@@ -111,6 +109,7 @@ set(headers
     displays/menus/motorfeedbackdebugmenu.h
     displays/menus/motorstatedebugmenu.h
     displays/menus/motortestmodesettingsmenu.h
+    displays/menus/networksettingsmenu.h
     displays/menus/otamenu.h
     displays/menus/presetsmenu.h
     displays/menus/profilesmenu.h
@@ -120,15 +119,14 @@ set(headers
     displays/menus/selectmodemenu.h
     displays/menus/selectotabuildmenu.h
     displays/menus/settingsmenu.h
-    displays/menus/stationwifisettingsmenu.h
     displays/menus/statisticsmenu.h
     displays/menus/taskmanagermenu.h
     displays/menus/tempomatmodesettingsmenu.h
     displays/menus/timersmenu.h
     displays/menus/timesettingsmenu.h
     displays/menus/udpcloudsettingsmenu.h
-    displays/menus/wifiscanmenu.h
+    displays/menus/wifistasettingsmenu.h
-    displays/menus/wifisettingsmenu.h
+    displays/menus/wifiapsettingsmenu.h
     displays/metersdisplay.h
     displays/pingpongdisplay.h
     displays/popups/alertdisplay.h
@@ -222,7 +220,20 @@ set(headers
     widgets/doubleprogressbar.h
     displays/menudisplaywithtime.h
     wifi_bobbycar.h
-    wifitexthelpers.h
+    texthelpers/networktexthelpers.h
+    texthelpers/wifistatexthelpers.h
+    wifiguiutils.h
+    accessors/wifistaconfigaccessors.h
+    displays/menus/wifistascanmenu.h
+    displays/menus/wifistaconfigsmenu.h
+    displays/menus/wifistascanentrymenu.h
+    displays/menus/wifiapclientsmenu.h
+    displays/menus/wifistaconfigentrymenu.h
+    texthelpers/wifistaconfigtexthelpers.h
+    accessors/wifiapconfigaccessors.h
+    texthelpers/wifiaptexthelpers.h
+    actions/wifistascanaction.h
+    actions/wifistascanclearaction.h
 )
 
 set(sources
@@ -297,7 +308,6 @@ set(sources
     displays/ledstripcolorsdisplay.cpp
     displays/lockscreen.cpp
     displays/menus/aboutmenu.cpp
-    displays/menus/accesspointwifisettingsmenu.cpp
     displays/menus/batterydebugmenu.cpp
     displays/menus/batterymenu.cpp
     displays/menus/blesettingsmenu.cpp
@@ -319,7 +329,6 @@ set(sources
     displays/menus/feedbackdebugmenu.cpp
     displays/menus/garagenmenu.cpp
     displays/menus/gametrakmodesettingsmenu.cpp
-    displays/menus/genericwifisettingsmenu.cpp
     displays/menus/graphsmenu.cpp
     displays/menus/greenpassmenu.cpp
     displays/menus/handbremssettingsmenu.cpp
@@ -337,6 +346,7 @@ set(sources
     displays/menus/motorfeedbackdebugmenu.cpp
     displays/menus/motorstatedebugmenu.cpp
     displays/menus/motortestmodesettingsmenu.cpp
+    displays/menus/networksettingsmenu.cpp
     displays/menus/otamenu.cpp
     displays/menus/presetsmenu.cpp
     displays/menus/profilesmenu.cpp
@@ -346,15 +356,14 @@ set(sources
     displays/menus/selectmodemenu.cpp
     displays/menus/selectotabuildmenu.cpp
     displays/menus/settingsmenu.cpp
-    displays/menus/stationwifisettingsmenu.cpp
     displays/menus/statisticsmenu.cpp
     displays/menus/taskmanagermenu.cpp
     displays/menus/tempomatmodesettingsmenu.cpp
     displays/menus/timersmenu.cpp
     displays/menus/timesettingsmenu.cpp
     displays/menus/udpcloudsettingsmenu.cpp
-    displays/menus/wifiscanmenu.cpp
+    displays/menus/wifistasettingsmenu.cpp
-    displays/menus/wifisettingsmenu.cpp
+    displays/menus/wifiapsettingsmenu.cpp
     displays/metersdisplay.cpp
     displays/pingpongdisplay.cpp
     displays/popups/alertdisplay.cpp
@@ -448,7 +457,20 @@ set(sources
     webserver_newsettings.cpp
     widgets/doubleprogressbar.cpp
     wifi_bobbycar.cpp
-    wifitexthelpers.cpp
+    texthelpers/networktexthelpers.cpp
+    texthelpers/wifistatexthelpers.cpp
+    wifiguiutils.cpp
+    accessors/wifistaconfigaccessors.cpp
+    displays/menus/wifistascanmenu.cpp
+    displays/menus/wifistaconfigsmenu.cpp
+    displays/menus/wifistascanentrymenu.cpp
+    displays/menus/wifiapclientsmenu.cpp
+    displays/menus/wifistaconfigentrymenu.cpp
+    texthelpers/wifistaconfigtexthelpers.cpp
+    accessors/wifiapconfigaccessors.cpp
+    texthelpers/wifiaptexthelpers.cpp
+    actions/wifistascanaction.cpp
+    actions/wifistascanclearaction.cpp
 )
 
 set(dependencies

main/accessors/wifiapconfigaccessors.cpp

@@ -0,0 +1,12 @@
+#include "wifiapconfigaccessors.h"
+
+// local includes
+#include "newsettings.h"
+
+using namespace espgui;
+
+bool WifiApEnabledAccessor::getValue() const { return configs.wifiApEnabled.value; }
+void WifiApEnabledAccessor::setValue(bool value) { configs.write_config(configs.wifiApEnabled, value); }
+
+//bool WifiApDisableWhenOnlineAccessor::getValue() const { return configs.wifiDisableApWhenOnline.value; }
+//void WifiApDisableWhenOnlineAccessor::setValue(bool value) { configs.write_config(configs.wifiDisableApWhenOnline, value); }

main/accessors/wifiapconfigaccessors.h

@@ -0,0 +1,22 @@
+#pragma once
+
+// system includes
+#include <string>
+
+// 3rdparty lib includes
+#include <accessorinterface.h>
+#include <espwifiutils.h>
+
+class WifiApEnabledAccessor : public virtual espgui::AccessorInterface<bool>
+{
+public:
+    bool getValue() const override;
+    void setValue(bool value) override;
+};
+
+//class WifiApDisableWhenOnlineAccessor : public virtual espgui::AccessorInterface<bool>
+//{
+//public:
+//    bool getValue() const override;
+//    void setValue(bool value) override;
+//};

main/accessors/wifistaconfigaccessors.cpp

@@ -0,0 +1,39 @@
+#include "wifistaconfigaccessors.h"
+
+// local includes
+#include "newsettings.h"
+
+using namespace espgui;
+
+bool WifiStaEnabledAccessor::getValue() const { return configs.wifiStaEnabled.value; }
+void WifiStaEnabledAccessor::setValue(bool value) { configs.write_config(configs.wifiStaEnabled, value); }
+
+std::string WifiStaConfigSsidAccessor::getValue() const { return configs.wifi_configs[m_index].ssid.value; }
+void WifiStaConfigSsidAccessor::setValue(std::string value) { configs.write_config(configs.wifi_configs[m_index].ssid, value); }
+
+std::string WifiStaConfigKeyAccessor::getValue() const { return configs.wifi_configs[m_index].key.value; }
+void WifiStaConfigKeyAccessor::setValue(std::string value) { configs.write_config(configs.wifi_configs[m_index].key, value); }
+
+bool WifiStaConfigUseStaticIpAccessor::getValue() const { return configs.wifi_configs[m_index].useStaticIp.value; }
+void WifiStaConfigUseStaticIpAccessor::setValue(bool value) { configs.write_config(configs.wifi_configs[m_index].useStaticIp, value); }
+
+wifi_stack::ip_address_t WifiStaConfigStaticIpAccessor::getValue() const { return configs.wifi_configs[m_index].staticIp.value; }
+void WifiStaConfigStaticIpAccessor::setValue(wifi_stack::ip_address_t value) { configs.write_config(configs.wifi_configs[m_index].staticIp, value); }
+
+wifi_stack::ip_address_t WifiStaConfigStaticSubnetAccessor::getValue() const { return configs.wifi_configs[m_index].staticSubnet.value; }
+void WifiStaConfigStaticSubnetAccessor::setValue(wifi_stack::ip_address_t value) { configs.write_config(configs.wifi_configs[m_index].staticSubnet, value); }
+
+wifi_stack::ip_address_t WifiStaConfigStaticGatewayAccessor::getValue() const { return configs.wifi_configs[m_index].staticGateway.value; }
+void WifiStaConfigStaticGatewayAccessor::setValue(wifi_stack::ip_address_t value) { configs.write_config(configs.wifi_configs[m_index].staticGateway, value); }
+
+bool WifiStaConfigUseStaticDnsAccessor::getValue() const { return configs.wifi_configs[m_index].useStaticDns.value; }
+void WifiStaConfigUseStaticDnsAccessor::setValue(bool value) { configs.write_config(configs.wifi_configs[m_index].useStaticDns, value); }
+
+wifi_stack::ip_address_t WifiStaConfigStaticDns0Accessor::getValue() const { return configs.wifi_configs[m_index].staticDns0.value; }
+void WifiStaConfigStaticDns0Accessor::setValue(wifi_stack::ip_address_t value) { configs.write_config(configs.wifi_configs[m_index].staticDns0, value); }
+
+wifi_stack::ip_address_t WifiStaConfigStaticDns1Accessor::getValue() const { return configs.wifi_configs[m_index].staticDns1.value; }
+void WifiStaConfigStaticDns1Accessor::setValue(wifi_stack::ip_address_t value) { configs.write_config(configs.wifi_configs[m_index].staticDns1, value); }
+
+wifi_stack::ip_address_t WifiStaConfigStaticDns2Accessor::getValue() const { return configs.wifi_configs[m_index].staticDns2.value; }
+void WifiStaConfigStaticDns2Accessor::setValue(wifi_stack::ip_address_t value) { configs.write_config(configs.wifi_configs[m_index].staticDns2, value); }

main/accessors/wifistaconfigaccessors.h

@@ -0,0 +1,137 @@
+#pragma once
+
+#include "sdkconfig.h"
+
+// system includes
+#include <string>
+
+// 3rdparty lib includes
+#include <accessorinterface.h>
+#include <espwifiutils.h>
+
+class WifiStaEnabledAccessor : public virtual espgui::AccessorInterface<bool>
+{
+public:
+    bool getValue() const override;
+    void setValue(bool value) override;
+};
+
+class WifiStaConfigSsidAccessor : public virtual espgui::AccessorInterface<std::string>
+{
+public:
+    WifiStaConfigSsidAccessor(int index) : m_index{index} {}
+
+    std::string getValue() const override;
+    void setValue(std::string value) override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigKeyAccessor : public virtual espgui::AccessorInterface<std::string>
+{
+public:
+    WifiStaConfigKeyAccessor(int index) : m_index{index} {}
+
+    std::string getValue() const override;
+    void setValue(std::string value) override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigUseStaticIpAccessor : public virtual espgui::AccessorInterface<bool>
+{
+public:
+    WifiStaConfigUseStaticIpAccessor(int index) : m_index{index} {}
+
+    bool getValue() const override;
+    void setValue(bool value) override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigStaticIpAccessor : public virtual espgui::AccessorInterface<wifi_stack::ip_address_t>
+{
+public:
+    WifiStaConfigStaticIpAccessor(int index) : m_index{index} {}
+
+    wifi_stack::ip_address_t getValue() const override;
+    void setValue(wifi_stack::ip_address_t value) override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigStaticSubnetAccessor : public virtual espgui::AccessorInterface<wifi_stack::ip_address_t>
+{
+public:
+    WifiStaConfigStaticSubnetAccessor(int index) : m_index{index} {}
+
+    wifi_stack::ip_address_t getValue() const override;
+    void setValue(wifi_stack::ip_address_t value) override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigStaticGatewayAccessor : public virtual espgui::AccessorInterface<wifi_stack::ip_address_t>
+{
+public:
+    WifiStaConfigStaticGatewayAccessor(int index) : m_index{index} {}
+
+    wifi_stack::ip_address_t getValue() const override;
+    void setValue(wifi_stack::ip_address_t value) override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigUseStaticDnsAccessor : public virtual espgui::AccessorInterface<bool>
+{
+public:
+    WifiStaConfigUseStaticDnsAccessor(int index) : m_index{index} {}
+
+    bool getValue() const override;
+    void setValue(bool value) override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigStaticDns0Accessor : public virtual espgui::AccessorInterface<wifi_stack::ip_address_t>
+{
+public:
+    WifiStaConfigStaticDns0Accessor(int index) : m_index{index} {}
+
+    wifi_stack::ip_address_t getValue() const override;
+    void setValue(wifi_stack::ip_address_t value) override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigStaticDns1Accessor : public virtual espgui::AccessorInterface<wifi_stack::ip_address_t>
+{
+public:
+    WifiStaConfigStaticDns1Accessor(int index) : m_index{index} {}
+
+    wifi_stack::ip_address_t getValue() const override;
+    void setValue(wifi_stack::ip_address_t value) override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigStaticDns2Accessor : public virtual espgui::AccessorInterface<wifi_stack::ip_address_t>
+{
+public:
+    WifiStaConfigStaticDns2Accessor(int index) : m_index{index} {}
+
+    wifi_stack::ip_address_t getValue() const override;
+    void setValue(wifi_stack::ip_address_t value) override;
+
+private:
+    const int m_index;
+};

main/actions/wifistascanaction.cpp

@@ -0,0 +1,20 @@
+#include "wifistascanaction.h"
+
+// esp-idf includes
+#include <esp_log.h>
+
+// local includes
+#include "wifi_bobbycar.h"
+
+namespace {
+constexpr const char * const TAG = "BOBBY";
+} // namespace
+
+void WifiStaScanAction::triggered()
+{
+    if (const auto result = wifi_scan(); result != ESP_OK)
+    {
+        ESP_LOGE(TAG, "wifi_scan() failed: %s", esp_err_to_name(result));
+        return;
+    }
+}

main/actions/wifistascanaction.h

@@ -0,0 +1,10 @@
+#pragma once
+
+// 3rdparty lib includes
+#include <actioninterface.h>
+
+class WifiStaScanAction : public virtual espgui::ActionInterface
+{
+public:
+    void triggered() override;
+};

main/actions/wifistascanclearaction.cpp

@@ -0,0 +1,9 @@
+#include "wifistascanclearaction.h"
+
+// 3rdparty lib includes
+#include <espwifistack.h>
+
+void WifiStaScanClearAction::triggered()
+{
+    wifi_stack::delete_scan_result();
+}

main/actions/wifistascanclearaction.h

@@ -0,0 +1,10 @@
+#pragma once
+
+// 3rdparty lib includes
+#include <actioninterface.h>
+
+class WifiStaScanClearAction : public virtual espgui::ActionInterface
+{
+public:
+    void triggered() override;
+};

main/displays/menus/accesspointwifisettingsmenu.cpp

@@ -1,33 +0,0 @@
-#include "accesspointwifisettingsmenu.h"
-
-// local includes
-#include "accessors/settingsaccessors.h"
-#include "actions/dummyaction.h"
-#include "actions/switchscreenaction.h"
-#include "actions/toggleboolaction.h"
-#include "checkboxicon.h"
-#include "displays/menus/wifisettingsmenu.h"
-#include "icons/back.h"
-#include "menuitem.h"
-#include "wifitexthelpers.h"
-
-using namespace espgui;
-
-AccessPointWifiSettingsMenu::AccessPointWifiSettingsMenu()
-{
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIAPENABLED>,  ToggleBoolAction, CheckboxIcon, WifiApEnabledAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, WifiSoftApGetStationNumText,                  StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiSoftApIpText,                             StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiSoftApBroadcastIpText,                    StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiSoftApNetworkIdText,                      StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiSoftApSubnetCidrText,                     StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiSoftApIpV6Text,                           StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiSoftApHostnameText,                       StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiSoftApMacAddressText,                     StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                        SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
-}
-
-void AccessPointWifiSettingsMenu::back()
-{
-    switchScreen<WifiSettingsMenu>();
-}

main/displays/menus/accesspointwifisettingsmenu.h

@@ -1,14 +0,0 @@
-#pragma once
-
-// local includes
-#include "displays/bobbymenudisplay.h"
-#include "texts.h"
-
-class AccessPointWifiSettingsMenu :
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_ACCESSPOINTWIFISETTINGS>
-{
-public:
-    AccessPointWifiSettingsMenu();
-    void back() override;
-};

main/displays/menus/genericwifisettingsmenu.h

@@ -1,30 +0,0 @@
-#pragma once
-
-// local includes
-#include "displays/bobbymenudisplay.h"
-#include "changevaluedisplay.h"
-#include "menuitem.h"
-#include "actions/dummyaction.h"
-#include "actions/toggleboolaction.h"
-#include "actions/switchscreenaction.h"
-#include "checkboxicon.h"
-#include "icons/back.h"
-#include "wifitexthelpers.h"
-#include "accessors/wifiaccessors.h"
-#include "texts.h"
-
-using namespace espgui;
-
-namespace {
-class GenericWifiSettingsMenu :
-    public BobbyMenuDisplay,
-    public StaticText<TEXT_GENERICWIFISETTINGS>,
-    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
-{
-public:
-    GenericWifiSettingsMenu()
-    {
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
-    }
-};
-} // namespace

main/displays/menus/networksettingsmenu.cpp

@@ -0,0 +1,45 @@
+#include "networksettingsmenu.h"
+
+// 3rdparty lib includes
+#include <menuitem.h>
+#include <actions/dummyaction.h>
+#include <actions/switchscreenaction.h>
+#include <icons/back.h>
+#include <screenmanager.h>
+#include <fmt/format.h>
+
+// local includes
+#include "wifistasettingsmenu.h"
+#include "wifiapsettingsmenu.h"
+#include "settingsmenu.h"
+#include "texthelpers/networktexthelpers.h"
+
+using namespace espgui;
+
+namespace {
+constexpr char TEXT_STASETTINGS[] = "STA Settings";
+constexpr char TEXT_APSETTINGS[] = "AP Settings";
+//constexpr char TEXT_BACK[] = "Back";
+} // namespace
+
+NetworkSettingsMenu::NetworkSettingsMenu()
+{
+    constructMenuItem<makeComponent<MenuItem,     StaticText<TEXT_STASETTINGS>, SwitchScreenAction<WifiStaSettingsMenu>>>();
+    constructMenuItem<makeComponent<MenuItem,     StaticText<TEXT_APSETTINGS>,  SwitchScreenAction<WifiApSettingsMenu>>>();
+    constructMenuItem<makeComponent<MenuItem,     WifiDefaultMacText,           DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem,     WifiBaseMacText,              DummyAction>>();
+    constructMenuItem<makeComponentArgs<MenuItem, DnsText,                      DummyAction>>(uint8_t{0});
+    constructMenuItem<makeComponentArgs<MenuItem, DnsText,                      DummyAction>>(uint8_t{1});
+    constructMenuItem<makeComponentArgs<MenuItem, DnsText,                      DummyAction>>(uint8_t{2});
+    constructMenuItem<makeComponent<MenuItem,     StaticText<TEXT_BACK>,        SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+}
+
+std::string NetworkSettingsMenu::text() const
+{
+    return "Network settings";
+}
+
+void NetworkSettingsMenu::back()
+{
+    switchScreen<SettingsMenu>();
+}

main/displays/menus/networksettingsmenu.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// local includes
+#include "displays/bobbymenudisplay.h"
+
+class NetworkSettingsMenu : public BobbyMenuDisplay
+{
+public:
+    NetworkSettingsMenu();
+
+    std::string text() const override;
+    void back() override;
+};

main/displays/menus/settingsmenu.cpp

@@ -24,7 +24,7 @@
 #include "globals.h"
 #include "accessors/settingsaccessors.h"
 #include "displays/menus/limitssettingsmenu.h"
-#include "displays/menus/wifisettingsmenu.h"
+#include "displays/menus/networksettingsmenu.h"
 #include "displays/menus/bluetoothsettingsmenu.h"
 #include "displays/menus/blesettingsmenu.h"
 #ifdef FEATURE_CLOUD
@@ -66,7 +66,7 @@ SettingsMenu::SettingsMenu()
     if (!simplified)
         constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LIMITSSETTINGS>,            SwitchScreenAction<LimitsSettingsMenu>>>();
 
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISETTINGS>,                  SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&bobbyicons::wifi>>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_NETWORKSETTINGS>,               SwitchScreenAction<NetworkSettingsMenu>, StaticMenuItemIcon<&bobbyicons::wifi>>>();
 #ifdef FEATURE_ESPNOW
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW>,                        SwitchScreenAction<EspNowMenu>, StaticMenuItemIcon<&bobbyicons::wifi>>>();
 #endif

main/displays/menus/stationwifisettingsmenu.cpp

@@ -1,52 +0,0 @@
-#include "stationwifisettingsmenu.h"
-
-// 3rdparty lib includes
-#include "menuitem.h"
-#include "actions/dummyaction.h"
-#include "actions/switchscreenaction.h"
-#include "actions/toggleboolaction.h"
-#include "checkboxicon.h"
-#include "icons/back.h"
-
-// local includes
-#include "utils.h"
-#include "actions/wifiscanaction.h"
-#include "icons/scan.h"
-#include "wifitexthelpers.h"
-#include "accessors/wifiaccessors.h"
-#include "accessors/settingsaccessors.h"
-#include "displays/menus/wifiscanmenu.h"
-#include "displays/menus/wifisettingsmenu.h"
-
-using namespace espgui;
-
-StationWifiSettingsMenu::StationWifiSettingsMenu()
-{
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISTAENABLED>,  ToggleBoolAction, CheckboxIcon, WifiStaEnabledAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFITRIGGERSCAN>, WifiScanAction>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISCANRESULTS>, SwitchScreenAction<WifiScanMenu>, StaticMenuItemIcon<&bobbyicons::scan>>>();
-    constructMenuItem<makeComponent<MenuItem, WifiStatusText,                   StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiScanStatusText,               StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiHostnameText,                 StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiMacText,                      StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiSsidText,                     StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiBssidText,                    StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiRssiText,                     StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiEncryptionTypeText,           StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiPairwiseCipherText,           StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiGroupCipherText,              StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiIpText,                       StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiNetmaskText,                  StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiGatewayText,                  StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiIpv6LinklocalText,            StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiIpv6GlobalText,               StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiDns0Text,                     StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiDns1Text,                     StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, WifiDns2Text,                     StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,            SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
-}
-
-void StationWifiSettingsMenu::back()
-{
-    switchScreen<WifiSettingsMenu>();
-}

main/displays/menus/stationwifisettingsmenu.h

@@ -1,15 +0,0 @@
-#pragma once
-
-// local includes
-#include "displays/bobbymenudisplay.h"
-#include "texts.h"
-
-class StationWifiSettingsMenu :
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_STATIONWIFISETTINGS>
-{
-public:
-    StationWifiSettingsMenu();
-
-    void back() override;
-};

main/displays/menus/wifiapclientsmenu.cpp

@@ -0,0 +1,153 @@
+#include "wifiapclientsmenu.h"
+
+// esp-idf includes
+#include <esp_log.h>
+#include <esp_wifi.h>
+#include <dhcpserver/dhcpserver.h>
+
+// 3rdparty lib includes
+#include <menuitem.h>
+#include <actions/dummyaction.h>
+#include <actions/switchscreenaction.h>
+#include <icons/back.h>
+#include <screenmanager.h>
+#include <fmt/format.h>
+#include <espwifiutils.h>
+
+// local includes
+#include "wifiapsettingsmenu.h"
+#include "wifiguiutils.h"
+
+using namespace std::chrono_literals;
+using namespace std::string_literals;
+using namespace espgui;
+
+namespace {
+constexpr const char * const TAG = "GOE";
+
+constexpr char TEXT_BACK[] = "Back";
+
+class WifiApClientMenuItem : public MenuItem
+{
+public:
+    WifiApClientMenuItem(const wifi_sta_info_t &info) : m_info{info} { updateIp(); }
+
+    void setInfo(const wifi_sta_info_t &info) { m_info = info; updateIp(); }
+
+    void triggered() override;
+    std::string text() const override;
+
+private:
+    void updateIp();
+
+private:
+    wifi_sta_info_t m_info;
+    ip4_addr_t m_ip;
+};
+} // namespace
+
+WifiApClientsMenu::WifiApClientsMenu() :
+    espgui::ChangeableText{"AP Clients"s}
+{
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiApSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+}
+
+void WifiApClientsMenu::back()
+{
+    switchScreen<WifiApSettingsMenu>();
+}
+
+void WifiApClientsMenu::start()
+{
+    Base::start();
+
+    m_lastSync = espchrono::millis_clock::now();
+    doSyncItems();
+}
+
+void WifiApClientsMenu::update()
+{
+    const auto now = espchrono::millis_clock::now();
+    if (now - m_lastSync >= 100ms)
+    {
+        m_lastSync = now;
+        doSyncItems();
+    }
+
+    Base::update();
+}
+
+void WifiApClientsMenu::doSyncItems()
+{
+    wifi_sta_list_t clients;
+    if (const auto result = esp_wifi_ap_get_sta_list(&clients); result != ESP_OK)
+    {
+        ESP_LOGE(TAG, "esp_wifi_ap_get_sta_list() failed with %s", esp_err_to_name(result));
+        setTitle(fmt::format("AP Clients (&1{}&c)", esp_err_to_name(result)));
+        clients.num = 0;
+    }
+    else
+        setTitle(fmt::format("AP Clients ({})", clients.num));
+
+    auto backButton = takeLastMenuItem();
+
+    for (std::size_t i = 0; i < clients.num; i++)
+    {
+        if (menuItemCount() <= i)
+            constructMenuItem<WifiApClientMenuItem>(clients.sta[i]);
+        else
+            ((WifiApClientMenuItem*)(&getMenuItem(i)))->setInfo(clients.sta[i]);
+    }
+
+    while (menuItemCount() > clients.num)
+        takeLastMenuItem();
+
+    emplaceMenuItem(std::move(backButton));
+}
+
+namespace {
+
+void WifiApClientMenuItem::triggered()
+{
+    uint16_t aid{};
+    if (const auto result = esp_wifi_ap_get_sta_aid(m_info.mac, &aid); result != ESP_OK)
+    {
+        ESP_LOGE(TAG, "esp_wifi_ap_get_sta_aid() failed with %s", esp_err_to_name(result));
+        return;
+    }
+
+    if (!aid)
+    {
+        ESP_LOGE(TAG, "aid is invalid");
+        return;
+    }
+
+    if (const auto result = esp_wifi_deauth_sta(aid); result != ESP_OK)
+    {
+        ESP_LOGE(TAG, "esp_wifi_deauth_sta() failed with %s", esp_err_to_name(result));
+        return;
+    }
+}
+
+std::string WifiApClientMenuItem::text() const
+{
+    return fmt::format("{}{}&c {}",
+                       rssiToColor(m_info.rssi),
+                       m_info.rssi,
+                       (std::chrono::milliseconds{espchrono::millis_clock::now().time_since_epoch()} % 4000ms) < 2000ms ?
+                           wifi_stack::toString(wifi_stack::mac_t{m_info.mac}) :
+                           wifi_stack::toString(m_ip)
+                       );
+}
+
+void WifiApClientMenuItem::updateIp()
+{
+    if (!dhcp_search_ip_on_mac(m_info.mac, &m_ip))
+    {
+        ESP_LOGE(TAG, "dhcp_search_ip_on_mac() failed");
+        m_ip = { .addr = {} };
+        return;
+    }
+}
+
+} // namespace

main/displays/menus/wifiapclientsmenu.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// 3rdparty lib includes
+#include <espchrono.h>
+
+// local includes
+#include "displays/bobbymenudisplay.h"
+
+class WifiApClientsMenu :
+    public BobbyMenuDisplay,
+    public virtual espgui::ChangeableText
+{
+    using Base = BobbyMenuDisplay;
+
+public:
+    WifiApClientsMenu();
+
+    void back() override;
+
+    void start() override;
+    void update() override;
+
+private:
+    void doSyncItems();
+
+private:
+    espchrono::millis_clock::time_point m_lastSync;
+};

main/displays/menus/wifiapsettingsmenu.cpp

@@ -0,0 +1,71 @@
+#include "wifiapsettingsmenu.h"
+
+// esp-idf includes
+#include <esp_log.h>
+
+// 3rdparty lib includes
+#include <menuitem.h>
+#include <actions/dummyaction.h>
+#include <actions/switchscreenaction.h>
+#include <checkboxicon.h>
+#include <actions/toggleboolaction.h>
+#include <icons/back.h>
+#include <screenmanager.h>
+#include <espwifistack.h>
+
+// local includes
+#include "wifiapclientsmenu.h"
+#include "networksettingsmenu.h"
+#include "accessors/wifiapconfigaccessors.h"
+#include "texthelpers/wifiaptexthelpers.h"
+
+using namespace espgui;
+
+namespace {
+constexpr const char * const TAG = "GOE";
+
+constexpr char TEXT_ENABLED[] = "Enabled";
+constexpr char TEXT_DISABLEWHENONLINE[] = "Disable when online";
+constexpr char TEXT_BACK[] = "Back";
+
+class WifiApClientsAction : public virtual ActionInterface
+{
+public:
+    void triggered() override;
+};
+} // namespace
+
+WifiApSettingsMenu::WifiApSettingsMenu()
+{
+    constructMenuItem<makeComponent<MenuItem, WifiApNameText,                      DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiApKeyText,                       DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiApMacText,                       DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiApIpText,                        DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiApMaskText,                      DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiApHostnameText,                  DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLED>,            ToggleBoolAction, CheckboxIcon, WifiApEnabledAccessor>>();
+    //constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISABLEWHENONLINE>,  ToggleBoolAction, CheckboxIcon, WifiApDisableWhenOnlineAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, WifiApClientsText,                   WifiApClientsAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,               SwitchScreenAction<NetworkSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+}
+
+std::string WifiApSettingsMenu::text() const
+{
+    return "AP Settings";
+}
+
+void WifiApSettingsMenu::back()
+{
+    switchScreen<NetworkSettingsMenu>();
+}
+
+namespace {
+void WifiApClientsAction::triggered()
+{
+    wifi_sta_list_t clients;
+    if (const auto result = esp_wifi_ap_get_sta_list(&clients); result == ESP_OK)
+        switchScreen<WifiApClientsMenu>();
+    else
+        ESP_LOGW(TAG, "esp_wifi_ap_get_sta_list() failed with %s", esp_err_to_name(result));
+}
+} // namespace

main/displays/menus/wifiapsettingsmenu.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// local includes
+#include "displays/bobbymenudisplay.h"
+
+class WifiApSettingsMenu : public BobbyMenuDisplay
+{
+public:
+    WifiApSettingsMenu();
+
+    std::string text() const override;
+    void back() override;
+};

main/displays/menus/wifiscanmenu.cpp

@@ -1,125 +0,0 @@
-#include "wifiscanmenu.h"
-
-// system includes
-#include <optional>
-
-// esp-idf includes
-#include <esp_log.h>
-
-// 3rdparty lib includes
-#include <espchrono.h>
-#include <espwifistack.h>
-#include <fmt/core.h>
-
-// local includes
-#include "menudisplay.h"
-#include "utils.h"
-#include "actions/multiaction.h"
-#include "actions/switchscreenaction.h"
-#include "actions/dummyaction.h"
-#include "icons/back.h"
-#include "texts.h"
-#include "wifi_bobbycar.h"
-
-using namespace std::chrono_literals;
-using namespace espgui;
-
-WifiScanMenu::WifiScanMenu()
-{
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<StationWifiSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
-}
-
-std::string WifiScanMenu::text() const
-{
-    const auto scanStatus = wifi_stack::get_scan_status();
-    auto text = wifi_stack::toString(scanStatus);
-
-    if (scanStatus != wifi_stack::WiFiScanStatus::Scanning)
-        if (const auto &result = wifi_stack::get_scan_result())
-            text += fmt::format(" ({} found)", result->entries.size());
-
-    return text;
-}
-
-void WifiScanMenu::start()
-{
-    Base::start();
-
-    m_lastScanComplete = {};
-
-    if (wifi_stack::get_scan_status() != wifi_stack::WiFiScanStatus::Scanning)
-        if (const auto result = wifi_scan(); result != ESP_OK)
-            ESP_LOGE("BOBBY", "wifi_scan() failed with %s", esp_err_to_name(result));
-}
-
-void WifiScanMenu::update()
-{
-    if (wifi_stack::get_scan_status() == wifi_stack::WiFiScanStatus::Scanning)
-    {
-        // TODO
-    }
-    else
-    {
-        const auto now = espchrono::millis_clock::now();
-
-        if (!m_lastScanComplete)
-        {
-            const auto &result = wifi_stack::get_scan_result();
-
-            auto backButton = takeLastMenuItem();
-
-            for (std::size_t i = 0; i < (result ? result->entries.size() : 0); i++)
-            {
-                std::string ssid{reinterpret_cast<const char*>(result->entries[i].ssid)};
-                if (menuItemCount() <= i)
-                {
-                    if (m_reusableItems.empty())
-                    {
-                        auto &item = constructMenuItem<menu_item_t>();
-                        item.setTitle(std::move(ssid));
-                    }
-                    else
-                    {
-                        std::unique_ptr<menu_item_t> ptr = std::move(m_reusableItems.back());
-                        m_reusableItems.pop_back();
-                        ptr->setTitle(std::move(ssid));
-                        emplaceMenuItem(std::move(ptr));
-                    }
-                }
-                else
-                {
-                    auto &item = *(menu_item_t*)(&getMenuItem(i));
-                    item.setTitle(std::move(ssid));
-                }
-            }
-
-            while (menuItemCount() > (result ? result->entries.size() : 0))
-                m_reusableItems.emplace_back((menu_item_t*)takeLastMenuItem().release());
-
-            emplaceMenuItem(std::move(backButton));
-
-            m_lastScanComplete = now;
-        }
-        else if (espchrono::ago(*m_lastScanComplete) >= 10s)
-        {
-            m_lastScanComplete = {};
-
-            if (const auto result = wifi_scan(); result != ESP_OK)
-                ESP_LOGE("BOBBY", "wifi_scan() failed with %s", esp_err_to_name(result));
-        }
-    }
-
-    Base::update();
-}
-
-void WifiScanMenu::stop()
-{
-    Base::stop();
-
-    wifi_stack::delete_scan_result();
-}
-
-void WifiScanMenu::back()
-{
-    switchScreen<StationWifiSettingsMenu>();
-}

main/displays/menus/wifiscanmenu.h

@@ -1,34 +0,0 @@
-#pragma once
-
-// 3rdparty lib includes
-#include "actions/dummyaction.h"
-#include "actions/switchscreenaction.h"
-
-// local includes
-#include "displays/bobbymenudisplay.h"
-#include "displays/menus/stationwifisettingsmenu.h"
-#include "texts.h"
-#include "utils.h"
-
-class WifiScanMenu :
-    public BobbyMenuDisplay,
-    public espgui::BackActionInterface<espgui::SwitchScreenAction<StationWifiSettingsMenu>>
-{
-    using Base = BobbyMenuDisplay;
-
-public:
-    WifiScanMenu();
-
-    std::string text() const override;
-
-    void start() override;
-    void update() override;
-    void stop() override;
-    void back() override;
-
-private:
-    std::optional<espchrono::millis_clock::time_point> m_lastScanComplete;
-
-    using menu_item_t = espgui::makeComponent<espgui::MenuItem, espgui::ChangeableText, espgui::DummyAction>;
-    std::vector<std::unique_ptr<menu_item_t>> m_reusableItems;
-};

main/displays/menus/wifisettingsmenu.cpp

@@ -1,39 +0,0 @@
-#include "wifisettingsmenu.h"
-
-// 3rdparty lib includes
-#include "actions/switchscreenaction.h"
-#include "icons/back.h"
-
-// local includes
-#include "utils.h"
-#include "displays/menus/genericwifisettingsmenu.h"
-#include "displays/menus/stationwifisettingsmenu.h"
-#include "displays/menus/accesspointwifisettingsmenu.h"
-#include "displays/menus/settingsmenu.h"
-#include "globals.h"
-
-using namespace espgui;
-
-#ifdef FEATURE_DNS_NS
-class ResendDNSRequest : public virtual ActionInterface
-{
-public:
-    void triggered() override { dns_lastIpAddress_v4 = "---"; dns_lastIpAddress_v6 = "---"; dns_lastIpAddress_v6_global = "---"; }
-};
-#endif
-
-WifiSettingsMenu::WifiSettingsMenu()
-{
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GENERICWIFISETTINGS>,     SwitchScreenAction<GenericWifiSettingsMenu>>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATIONWIFISETTINGS>,     SwitchScreenAction<StationWifiSettingsMenu>>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ACCESSPOINTWIFISETTINGS>, SwitchScreenAction<AccessPointWifiSettingsMenu>>>();
-#ifdef FEATURE_DNS_NS
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_RESEND_DNS>,              ResendDNSRequest>>();
-#endif
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                    SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
-}
-
-void WifiSettingsMenu::back()
-{
-    switchScreen<SettingsMenu>();
-}

main/displays/menus/wifisettingsmenu.h

@@ -1,15 +0,0 @@
-#pragma once
-
-// local includes
-#include "displays/bobbymenudisplay.h"
-#include "texts.h"
-
-class WifiSettingsMenu :
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_WIFISETTINGS>
-{
-public:
-    WifiSettingsMenu();
-
-    void back() override;
-};

main/displays/menus/wifistaconfigentrymenu.cpp

@@ -0,0 +1,49 @@
+#include "wifistaconfigentrymenu.h"
+
+// 3rdparty lib includes
+#include <menuitem.h>
+#include <actions/dummyaction.h>
+#include <actions/switchscreenaction.h>
+#include <icons/back.h>
+#include <screenmanager.h>
+#include <actions/toggleboolaction.h>
+#include <checkboxicon.h>
+
+// local includes
+#include "texthelpers/wifistaconfigtexthelpers.h"
+#include "accessors/wifistaconfigaccessors.h"
+#include "wifistaconfigsmenu.h"
+
+using namespace espgui;
+
+namespace {
+constexpr char TEXT_USESTATICIP[] = "Use Static Ip";
+constexpr char TEXT_USESTATICDNS[] = "Use Static Dns";
+constexpr char TEXT_BACK[] = "Back";
+} // namespace
+
+WifiStaConfigEntryMenu::WifiStaConfigEntryMenu(int index) :
+    m_index{index}
+{
+    constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigSsidText,             DummyAction>>(index);
+    constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigKeyText,              DummyAction>>(index);
+    constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigUseStaticIpAccessor,  StaticText<TEXT_USESTATICIP>, ToggleBoolAction, CheckboxIcon>>(index);
+    constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticIpText,         DummyAction>>(index);
+    constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticSubnetText,     DummyAction>>(index);
+    constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticGatewayText,    DummyAction>>(index);
+    constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigUseStaticDnsAccessor, StaticText<TEXT_USESTATICDNS>, ToggleBoolAction, CheckboxIcon>>(index);
+    constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticDns0Text,       DummyAction>>(index);
+    constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticDns1Text,       DummyAction>>(index);
+    constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticDns2Text,       DummyAction>>(index);
+    constructMenuItem<makeComponent<MenuItem,     StaticText<TEXT_BACK>,             SwitchScreenAction<WifiStaConfigsMenu>, StaticMenuItemIcon<&icons::back>>>();
+}
+
+std::string WifiStaConfigEntryMenu::text() const
+{
+    return fmt::format("Wifi Config {}", m_index + 1);
+}
+
+void WifiStaConfigEntryMenu::back()
+{
+    switchScreen<WifiStaConfigsMenu>();
+}

main/displays/menus/wifistaconfigentrymenu.h

@@ -0,0 +1,16 @@
+#pragma once
+
+// local includes
+#include "displays/bobbymenudisplay.h"
+
+class WifiStaConfigEntryMenu : public BobbyMenuDisplay
+{
+public:
+    WifiStaConfigEntryMenu(int index);
+
+    std::string text() const override;
+    void back() override;
+
+private:
+    const int m_index;
+};

main/displays/menus/wifistaconfigsmenu.cpp

@@ -0,0 +1,77 @@
+#include "wifistaconfigsmenu.h"
+
+// 3rdparty lib includes
+#include <menuitem.h>
+#include <actions/dummyaction.h>
+#include <actions/switchscreenaction.h>
+#include <icons/back.h>
+#include <screenmanager.h>
+#include <fmt/core.h>
+#include <strutils.h>
+#include <espwifistack.h>
+
+// local includes
+#include "wifistasettingsmenu.h"
+#include "wifistaconfigentrymenu.h"
+#include "newsettings.h"
+
+using namespace espgui;
+
+namespace {
+constexpr char TEXT_BACK[] = "Back";
+
+class WifiStaConfigurationMenuItem : public MenuItem
+{
+public:
+    WifiStaConfigurationMenuItem(int index) : m_index{index} {}
+
+    void triggered() override;
+    std::string text() const override;
+
+private:
+    const int m_index;
+};
+} // namespace
+
+WifiStaConfigsMenu::WifiStaConfigsMenu()
+{
+    for (int i = 0; i < configs.wifi_configs.size(); i++)
+        constructMenuItem<WifiStaConfigurationMenuItem>(i);
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,           SwitchScreenAction<WifiStaSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+}
+
+std::string WifiStaConfigsMenu::text() const
+{
+    return "Configurations";
+}
+
+void WifiStaConfigsMenu::back()
+{
+    switchScreen<WifiStaSettingsMenu>();
+}
+
+namespace {
+
+void WifiStaConfigurationMenuItem::triggered()
+{
+    switchScreen<WifiStaConfigEntryMenu>(m_index);
+}
+
+std::string WifiStaConfigurationMenuItem::text() const
+{
+    const auto &config = configs.wifi_configs[m_index];
+    const auto &ssid = config.ssid.value;
+
+    bool connected{};
+    if (!ssid.empty() && wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
+        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
+            if (cpputils::stringEqualsIgnoreCase(std::string_view{reinterpret_cast<const char*>(result->ssid)}, ssid))
+                connected = true;
+
+    return fmt::format("&s{}: &f{}{}",
+                       m_index + 1,
+                       ssid.empty() ? "&1" : (connected ? "&2" : ""),
+                       ssid.empty() ? "<empty>" : ssid);
+}
+
+} // namespace

main/displays/menus/wifistaconfigsmenu.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// local includes
+#include "displays/bobbymenudisplay.h"
+
+class WifiStaConfigsMenu : public BobbyMenuDisplay
+{
+public:
+    WifiStaConfigsMenu();
+
+    std::string text() const override;
+    void back() override;
+};

main/displays/menus/wifistascanentrymenu.cpp

@@ -0,0 +1,134 @@
+#include "wifistascanentrymenu.h"
+
+// system includes
+#include <algorithm>
+
+// esp-idf includes
+#include <esp_log.h>
+
+// 3rdparty lib includes
+#include <menuitem.h>
+#include <actions/dummyaction.h>
+#include <actions/switchscreenaction.h>
+#include <icons/back.h>
+#include <screenmanager.h>
+#include <fmt/format.h>
+#include <espwifiutils.h>
+#include <richtextrenderer.h>
+#include <strutils.h>
+
+// local includes
+#include "wifistascanmenu.h"
+#include "wifistaconfigentrymenu.h"
+#include "wifiguiutils.h"
+#include "newsettings.h"
+
+using namespace std::string_literals;
+using namespace espgui;
+
+namespace {
+constexpr const char * const TAG = "BOBBY";
+
+constexpr char TEXT_SAVEASNEW[] = "Save as new wifi config";
+constexpr char TEXT_BACK[] = "Back";
+
+class SaveNewWifiConfigAction : public virtual ActionInterface
+{
+public:
+    SaveNewWifiConfigAction(std::string &&ssid) : m_ssid{std::move(ssid)} {}
+    SaveNewWifiConfigAction(std::string_view ssid) : m_ssid{ssid} {}
+
+    void triggered() override;
+
+private:
+    const std::string m_ssid;
+};
+} // namespace
+
+WifiStaScanEntryMenu::WifiStaScanEntryMenu(const wifi_ap_record_t &info) :
+    m_info{info}
+{
+    const std::string_view ssid{reinterpret_cast<const char*>(m_info.ssid)};
+    const bool configured = std::any_of(std::begin(configs.wifi_configs), std::end(configs.wifi_configs),
+                                        [&ssid](const WiFiConfig &config){ return cpputils::stringEqualsIgnoreCase(config.ssid.value, ssid); });
+
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sssid: &f{}{}", configured?"&4":"", richTextEscape(ssid)));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sconfigured: &f{}{}", configured?"&2":"&1", configured?"yes":"no"));
+    if (!configured && !ssid.empty())
+        constructMenuItem<makeComponentArgs<MenuItem, SaveNewWifiConfigAction, StaticText<TEXT_SAVEASNEW>>>(ssid);
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sbssid: &f{}", wifi_stack::toString(wifi_stack::mac_t{m_info.bssid})));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&schannel: &f{}", m_info.primary));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&ssecond: &f{}", [&](){
+        switch (m_info.second)
+        {
+        case WIFI_SECOND_CHAN_NONE:  return "NONE"s;
+        case WIFI_SECOND_CHAN_ABOVE: return "ABOVE"s;
+        case WIFI_SECOND_CHAN_BELOW: return "BELOW"s;
+        default: return std::to_string(m_info.second);
+        }
+    }()));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&srssi: &f{}{}dB", rssiToColor(m_info.rssi), m_info.rssi));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sauthmode: &f{}", wifi_stack::toString(m_info.authmode)));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&spairwise cipher: &f{}", wifi_stack::toString(m_info.pairwise_cipher)));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sgroup cipher: &f{}", wifi_stack::toString(m_info.group_cipher)));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sant: &f{}", [&](){
+        switch (m_info.ant)
+        {
+        case WIFI_ANT_ANT0: return "ANT0"s;
+        case WIFI_ANT_ANT1: return "ANT1"s;
+        default: return std::to_string(m_info.ant);
+        }
+    }()));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&smodes:&f{}{}{}", m_info.phy_11b?" b":"", m_info.phy_11g?" g":"", m_info.phy_11n?" n":""));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&slong range: &f{}{}", m_info.phy_lr?"&2":"&1", m_info.phy_lr?"yes":"no"));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&swps: &f{}{}", m_info.wps?"&2":"&1", m_info.wps?"yes":"no"));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sftm responder: &f{}{}", m_info.ftm_responder?"&2":"&1", m_info.ftm_responder?"yes":"no"));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sftm initiator: &f{}{}", m_info.ftm_initiator?"&2":"&1", m_info.ftm_initiator?"yes":"no"));
+    constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&scountry: &f{} ({}-{}, {}dB, {})",
+                                                                                            std::string_view(m_info.country.cc, m_info.country.cc[0]=='\0' ? 0 : (m_info.country.cc[1]=='\0' ? 1 : (m_info.country.cc[2]=='\0' ? 2 : 3))),
+                                                                                            m_info.country.schan,
+                                                                                            m_info.country.nchan,
+                                                                                            m_info.country.max_tx_power,
+                                                                                            [&](){
+                                                                                                switch (m_info.country.policy)
+                                                                                                {
+                                                                                                case WIFI_COUNTRY_POLICY_AUTO:   return "AUTO"s;
+                                                                                                case WIFI_COUNTRY_POLICY_MANUAL: return "MANUAL"s;
+                                                                                                default: return std::to_string(m_info.country.policy);
+                                                                                                }
+                                                                                            }()));
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiStaScanMenu>, StaticMenuItemIcon<&icons::back>>>();
+}
+
+std::string WifiStaScanEntryMenu::text() const
+{
+    return fmt::format("Scan entry {}", richTextEscape(std::string_view{reinterpret_cast<const char*>(m_info.ssid)}));
+}
+
+void WifiStaScanEntryMenu::back()
+{
+    switchScreen<WifiStaScanMenu>();
+}
+
+namespace {
+
+void SaveNewWifiConfigAction::triggered()
+{
+    const auto iter = std::find_if(std::begin(configs.wifi_configs), std::end(configs.wifi_configs),
+                                   [](const WiFiConfig &config){ return config.ssid.value.empty() && config.key.value.empty(); });
+    if (iter == std::end(configs.wifi_configs))
+    {
+        ESP_LOGE(TAG, "no free wifi config slot found!");
+        return;
+    }
+
+    if (const auto result = configs.write_config(iter->ssid, m_ssid); !result)
+    {
+        ESP_LOGE(TAG, "Could not save ssid: %.*s", result.error().size(), result.error().data());
+        return;
+    }
+
+    switchScreen<WifiStaConfigEntryMenu>(std::distance(std::begin(configs.wifi_configs), iter));
+}
+
+} // namespace

main/displays/menus/wifistascanentrymenu.h

@@ -0,0 +1,19 @@
+#pragma once
+
+// esp-idf includes
+#include <esp_wifi_types.h>
+
+// local includes
+#include "displays/bobbymenudisplay.h"
+
+class WifiStaScanEntryMenu : public BobbyMenuDisplay
+{
+public:
+    WifiStaScanEntryMenu(const wifi_ap_record_t &info);
+
+    std::string text() const override;
+    void back() override;
+
+private:
+    const wifi_ap_record_t m_info;
+};

main/displays/menus/wifistascanmenu.cpp

@@ -0,0 +1,150 @@
+#include "wifistascanmenu.h"
+
+// system includes
+#include <algorithm>
+
+// 3rdparty lib includes
+#include <menuitem.h>
+#include <actions/switchscreenaction.h>
+#include <icons/back.h>
+#include <screenmanager.h>
+#include <fmt/format.h>
+#include <espwifistack.h>
+#include <espwifiutils.h>
+#include <richtextrenderer.h>
+#include <strutils.h>
+
+// local includes
+#include "actions/wifistascanaction.h"
+#include "actions/wifistascanclearaction.h"
+#include "wifistasettingsmenu.h"
+#include "wifiguiutils.h"
+#include "wifistascanentrymenu.h"
+#include "newsettings.h"
+
+using namespace espgui;
+
+namespace {
+constexpr char TEXT_STARTSCAN[] = "Start scan";
+constexpr char TEXT_CLEARRESULTS[] = "Clear results";
+constexpr char TEXT_BACK[] = "Back";
+
+class WifiStaScanMenuItem : public MenuItem
+{
+public:
+    WifiStaScanMenuItem(const wifi_ap_record_t &info) : m_info{info} {}
+
+    void setInfo(const wifi_ap_record_t &info) { m_info = info; }
+
+    void triggered() override;
+    std::string text() const override;
+
+private:
+    wifi_ap_record_t m_info;
+};
+
+constexpr const size_t extraItemsAtBeginning = 2; // Scan and clear
+} // namespace
+
+WifiStaScanMenu::WifiStaScanMenu()
+{
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STARTSCAN>, WifiStaScanAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CLEARRESULTS>, WifiStaScanClearAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiStaSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+}
+
+std::string WifiStaScanMenu::text() const
+{
+    const auto scanStatus = wifi_stack::get_scan_status();
+    auto text = fmt::format("Scan {}{}",
+        [&](){
+            switch (scanStatus)
+            {
+            case wifi_stack::WiFiScanStatus::Scanning: return "&4";
+            case wifi_stack::WiFiScanStatus::Finished: return "&2";
+            case wifi_stack::WiFiScanStatus::Failed: return "&1";
+            default: return "";
+            }
+        }(),
+        wifi_stack::toString(scanStatus));
+
+    //if (scanStatus != wifi_stack::WiFiScanStatus::Scanning)
+    if (const auto &result = wifi_stack::get_scan_result())
+        text += fmt::format("&c ({} found)", result->entries.size());
+
+    return text;
+}
+
+void WifiStaScanMenu::back()
+{
+    switchScreen<WifiStaSettingsMenu>();
+}
+
+void WifiStaScanMenu::start()
+{
+    Base::start();
+
+    m_wasScanning = true;
+}
+
+void WifiStaScanMenu::update()
+{
+    const auto scanStatus = wifi_stack::get_scan_status();
+
+    if (scanStatus == wifi_stack::WiFiScanStatus::Scanning && !m_wasScanning)
+    {
+        m_wasScanning = true;
+    }
+    else if (scanStatus != wifi_stack::WiFiScanStatus::Scanning && m_wasScanning)
+    {
+        m_wasScanning = false;
+
+        auto backButton = takeLastMenuItem();
+
+        const auto &result = wifi_stack::get_scan_result();
+
+        for (std::size_t i = 0; i < (result ? result->entries.size() : 0); i++)
+        {
+            if (menuItemCount() - extraItemsAtBeginning <= i)
+                constructMenuItem<WifiStaScanMenuItem>(result->entries[i]);
+            else
+                ((WifiStaScanMenuItem*)(&getMenuItem(i + extraItemsAtBeginning)))->setInfo(result->entries[i]);
+        }
+
+        while (menuItemCount() - extraItemsAtBeginning > (result ? result->entries.size() : 0))
+            takeLastMenuItem();
+
+        emplaceMenuItem(std::move(backButton));
+    }
+
+    Base::update();
+}
+
+namespace {
+
+void WifiStaScanMenuItem::triggered()
+{
+    switchScreen<WifiStaScanEntryMenu>(m_info);
+}
+
+std::string WifiStaScanMenuItem::text() const
+{
+    const std::string_view ssid{reinterpret_cast<const char*>(m_info.ssid)};
+
+    bool connected{};
+    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
+        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
+            if (wifi_stack::mac_t{result->bssid} == wifi_stack::mac_t{m_info.bssid})
+                connected = true;
+
+    const bool configured = std::any_of(std::begin(configs.wifi_configs), std::end(configs.wifi_configs),
+                                        [&ssid](const WiFiConfig &config){ return cpputils::stringEqualsIgnoreCase(config.ssid.value, ssid); });
+
+    return fmt::format("&s{}{} {}&f{}",
+                       rssiToColor(m_info.rssi),
+                       m_info.rssi,
+                       connected ? "&2" : (configured ? "&4" : "&c"),
+                       richTextEscape(ssid));
+}
+
+} // namespace

main/displays/menus/wifistascanmenu.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// local includes
+#include "displays/bobbymenudisplay.h"
+
+class WifiStaScanMenu : public BobbyMenuDisplay
+{
+    using Base = BobbyMenuDisplay;
+
+public:
+    WifiStaScanMenu();
+
+    std::string text() const override;
+    void back() override;
+
+    void start() override;
+    void update() override;
+
+private:
+    bool m_wasScanning;
+};

main/displays/menus/wifistasettingsmenu.cpp

@@ -0,0 +1,57 @@
+#include "wifistasettingsmenu.h"
+
+// 3rdparty lib includes
+#include <menuitem.h>
+#include <actions/dummyaction.h>
+#include <actions/switchscreenaction.h>
+#include <checkboxicon.h>
+#include <actions/toggleboolaction.h>
+#include <icons/back.h>
+#include <screenmanager.h>
+
+// local includes
+#include "wifistascanmenu.h"
+#include "wifistaconfigsmenu.h"
+#include "accessors/wifistaconfigaccessors.h"
+#include "networksettingsmenu.h"
+#include "texthelpers/wifistatexthelpers.h"
+
+using namespace espgui;
+
+namespace {
+constexpr char TEXT_ENABLED[] = "Enabled";
+constexpr char TEXT_CONFIGURATIONS[] = "Configurations";
+constexpr char TEXT_BACK[] = "Back";
+} // namespace
+
+WifiStaSettingsMenu::WifiStaSettingsMenu()
+{
+    constructMenuItem<makeComponent<MenuItem, WifiStaStatusText,               DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiStaMacText,                  DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiStaScanStatusText,           SwitchScreenAction<WifiStaScanMenu>>>();
+    constructMenuItem<makeComponent<MenuItem, WifiSsidText,                    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiBssidText,                   DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiRssiText,                    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiAuthmodeText,                DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiPairwiseCipherText,          DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiGroupCipherText,             DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiStaIpText,                   DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiStaNetmaskText,              DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiStaGatewayText,              DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiStaHostnameText,             DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiStaIpv6LinklocalText,        DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, WifiStaIpv6GlobalText,           DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLED>,        ToggleBoolAction, CheckboxIcon, WifiStaEnabledAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CONFIGURATIONS>, SwitchScreenAction<WifiStaConfigsMenu>>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,           SwitchScreenAction<NetworkSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+}
+
+std::string WifiStaSettingsMenu::text() const
+{
+    return "Sta Settings";
+}
+
+void WifiStaSettingsMenu::back()
+{
+    switchScreen<NetworkSettingsMenu>();
+}

main/displays/menus/wifistasettingsmenu.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// local includes
+#include "displays/bobbymenudisplay.h"
+
+class WifiStaSettingsMenu : public BobbyMenuDisplay
+{
+public:
+    WifiStaSettingsMenu();
+
+    std::string text() const override;
+    void back() override;
+};

main/newsettings.h

@@ -57,7 +57,7 @@ public:
     //                                            default                                 allowReset constraints                 nvsName
     ConfigWrapper<std::optional<mac_t>> baseMacAddressOverride{std::nullopt,              NoReset,   {},                         "baseMacAddrOver"     };
     ConfigWrapper<std::string> hostname           {defaultHostname,                       DoReset,   StringMinMaxSize<4, 32>,    "hostname"            };
-    ConfigWrapper<bool>        wifiStaEnabled     {true,                                  DoReset,   {},                         "wifi_enabled"        };
+    ConfigWrapper<bool>        wifiStaEnabled     {true,                                  DoReset,   {},                         "wifiStaEnabled"      };
     std::array<WiFiConfig, 10> wifi_configs {
         WiFiConfig {"wifi_ssid0", "wifi_key0", "wifi_usestatic0", "wifi_static_ip0", "wifi_stati_sub0", "wifi_stat_gate0", "wifi_usestadns0", "wifi_stat_dnsA0", "wifi_stat_dnsB0", "wifi_stat_dnsC0"},
         WiFiConfig {"wifi_ssid1", "wifi_key1", "wifi_usestatic1", "wifi_static_ip1", "wifi_stati_sub1", "wifi_stat_gate1", "wifi_usestadns1", "wifi_stat_dnsA1", "wifi_stat_dnsB1", "wifi_stat_dnsC1"},
@@ -73,7 +73,7 @@ public:
     ConfigWrapper<int8_t>      wifiStaMinRssi     {-90,                                    DoReset,   {},                         "wifiStaMinRssi"      };
 
     ConfigWrapper<bool>        wifiApEnabled      {true,                                   DoReset,   {},                         "wifiApEnabled"       };
-    ConfigWrapper<std::string> wifiApName         {defaultHostname,                        DoReset, StringMinMaxSize<4, 32>,      "wifiApName"          };
+    ConfigWrapper<std::string> wifiApName         {defaultHostname,                        DoReset,   StringMinMaxSize<4, 32>,    "wifiApName"          };
     ConfigWrapper<std::string> wifiApKey          {"Passwort_123",                         DoReset,   StringOr<StringEmpty, StringMinMaxSize<8, 64>>, "wifiApKey"     };
     ConfigWrapper<uint8_t>     wifiApChannel      {1,                                      DoReset,   {},                         "wifiApChannel"       };
     ConfigWrapper<wifi_auth_mode_t> wifiApAuthmode{WIFI_AUTH_WPA2_PSK,                     DoReset,   {},                         "wifiApAuthmode"      };

main/texthelpers/networktexthelpers.cpp

@@ -0,0 +1,42 @@
+#include "networktexthelpers.h"
+
+// esp-idf
+#include <esp_system.h>
+#include <lwip/dns.h>
+
+// 3rdparty lib includes
+#include <espwifistack.h>
+#include <espwifiutils.h>
+#include <fmt/format.h>
+
+using namespace espgui;
+
+std::string WifiDefaultMacText::text() const
+{
+    std::string text = "&sdefault-mac: &f";
+    wifi_stack::mac_t mac;
+    if (const auto result = esp_efuse_mac_get_default(std::begin(mac)); result == ESP_OK)
+        text += wifi_stack::toString(mac);
+    else
+        text += fmt::format("&1{}", esp_err_to_name(result));
+    return text;
+}
+
+std::string WifiBaseMacText::text() const
+{
+    std::string text = "&sbase-mac: &f";
+    wifi_stack::mac_t mac;
+    if (const auto result = esp_base_mac_addr_get(std::begin(mac)); result == ESP_OK)
+        text += wifi_stack::toString(mac);
+    else
+        text += fmt::format("&1{}", esp_err_to_name(result));
+    return text;
+}
+
+std::string DnsText::text() const
+{
+    std::string text = fmt::format("&sdns{}: &f", m_index);
+    if (const ip_addr_t *dns_ip = dns_getserver(m_index))
+        text += wifi_stack::toString(*dns_ip);
+    return text;
+}

main/texthelpers/networktexthelpers.h

@@ -0,0 +1,27 @@
+#pragma once
+
+// 3rdparty lib includes
+#include <textinterface.h>
+
+class WifiDefaultMacText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiBaseMacText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class DnsText : public virtual espgui::TextInterface
+{
+public:
+    DnsText(uint8_t index) : m_index{index} {}
+
+    std::string text() const override;
+
+private:
+    const uint8_t m_index;
+};

main/texthelpers/wifiaptexthelpers.cpp

@@ -0,0 +1,63 @@
+#include "wifiaptexthelpers.h"
+
+// esp-idf includes
+#include <esp_wifi.h>
+
+// 3rdparty lib includes
+#include <fmt/core.h>
+#include <espwifistack.h>
+#include <richtextrenderer.h>
+
+// local includes
+#include "newsettings.h"
+#include "wifi_bobbycar.h"
+
+using namespace espgui;
+
+std::string WifiApNameText::text() const
+{
+    return fmt::format("&sssid: &f{}", richTextEscape(configs.wifiApName.value));
+}
+
+std::string WifiApKeyText::text() const
+{
+    return fmt::format("&skey: &f{}", richTextEscape(configs.wifiApKey.value));
+}
+
+std::string WifiApMacText::text() const
+{
+    std::string text = "&smac: &f";
+    wifi_stack::mac_t mac;
+    if (const auto result = esp_wifi_get_mac(WIFI_IF_AP, std::begin(mac)); result == ESP_OK)
+        text += wifi_stack::toString(mac);
+    else
+        text += fmt::format("&1{}", esp_err_to_name(result));
+    return text;
+}
+
+std::string WifiApIpText::text() const
+{
+    return fmt::format("&sip: &f{}", wifi_stack::toString(apIP));
+}
+
+std::string WifiApMaskText::text() const
+{
+    return fmt::format("&smask: &f{}", wifi_stack::toString(netMsk));
+}
+
+std::string WifiApHostnameText::text() const
+{
+    if (auto hostname = wifi_stack::get_hostname_for_interface(ESP_IF_WIFI_AP))
+        return fmt::format("&shostname: &f{}", espgui::richTextEscape(*hostname));
+    else
+        return fmt::format("&shostname: &1{}", espgui::richTextEscape(std::move(hostname).error()));
+}
+
+std::string WifiApClientsText::text() const
+{
+    wifi_sta_list_t clients;
+    if (const auto result = esp_wifi_ap_get_sta_list(&clients); result == ESP_OK)
+        return fmt::format("Clients ({})", clients.num);
+    else
+        return fmt::format("&7Clients &1{}", esp_err_to_name(result));
+}

main/texthelpers/wifiaptexthelpers.h

@@ -0,0 +1,46 @@
+#pragma once
+
+// 3rdparty lib includes
+#include <textinterface.h>
+
+class WifiApNameText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiApKeyText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiApMacText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiApIpText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiApMaskText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiApHostnameText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiApClientsText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};

main/texthelpers/wifistaconfigtexthelpers.cpp

@@ -0,0 +1,51 @@
+#include "wifistaconfigtexthelpers.h"
+
+// 3rdparty lib includes
+#include <fmt/core.h>
+#include <richtextrenderer.h>
+#include <espwifiutils.h>
+
+// local includes
+#include "newsettings.h"
+
+using namespace espgui;
+
+std::string WifiStaConfigSsidText::text() const
+{
+    return fmt::format("&sssid: &f{}", richTextEscape(configs.wifi_configs[m_index].ssid.value));
+}
+
+std::string WifiStaConfigKeyText::text() const
+{
+    return fmt::format("&skey: &f{}", richTextEscape(configs.wifi_configs[m_index].key.value));
+}
+
+std::string WifiStaConfigStaticIpText::text() const
+{
+    return fmt::format("&sStatic Ip: &f{}", wifi_stack::toString(configs.wifi_configs[m_index].staticIp.value));
+}
+
+std::string WifiStaConfigStaticSubnetText::text() const
+{
+    return fmt::format("&sStatic Mask: &f{}", wifi_stack::toString(configs.wifi_configs[m_index].staticSubnet.value));
+}
+
+std::string WifiStaConfigStaticGatewayText::text() const
+{
+    return fmt::format("&sStatic Gw: &f{}", wifi_stack::toString(configs.wifi_configs[m_index].staticGateway.value));
+}
+
+std::string WifiStaConfigStaticDns0Text::text() const
+{
+    return fmt::format("&sStatic Dns0: &f{}", wifi_stack::toString(configs.wifi_configs[m_index].staticDns0.value));
+}
+
+std::string WifiStaConfigStaticDns1Text::text() const
+{
+    return fmt::format("&sStatic Dns1: &f{}", wifi_stack::toString(configs.wifi_configs[m_index].staticDns1.value));
+}
+
+std::string WifiStaConfigStaticDns2Text::text() const
+{
+    return fmt::format("&sStatic Dns2: &f{}", wifi_stack::toString(configs.wifi_configs[m_index].staticDns2.value));
+}

main/texthelpers/wifistaconfigtexthelpers.h

@@ -0,0 +1,92 @@
+#pragma once
+
+// 3rdparty lib includes
+#include <textinterface.h>
+
+class WifiStaConfigSsidText : public virtual espgui::TextInterface
+{
+public:
+    WifiStaConfigSsidText(int index) : m_index{index} {}
+
+    std::string text() const override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigKeyText : public virtual espgui::TextInterface
+{
+public:
+    WifiStaConfigKeyText(int index) : m_index{index} {}
+
+    std::string text() const override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigStaticIpText : public virtual espgui::TextInterface
+{
+public:
+    WifiStaConfigStaticIpText(int index) : m_index{index} {}
+
+    std::string text() const override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigStaticSubnetText : public virtual espgui::TextInterface
+{
+public:
+    WifiStaConfigStaticSubnetText(int index) : m_index{index} {}
+
+    std::string text() const override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigStaticGatewayText : public virtual espgui::TextInterface
+{
+public:
+    WifiStaConfigStaticGatewayText(int index) : m_index{index} {}
+
+    std::string text() const override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigStaticDns0Text : public virtual espgui::TextInterface
+{
+public:
+    WifiStaConfigStaticDns0Text(int index) : m_index{index} {}
+
+    std::string text() const override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigStaticDns1Text : public virtual espgui::TextInterface
+{
+public:
+    WifiStaConfigStaticDns1Text(int index) : m_index{index} {}
+
+    std::string text() const override;
+
+private:
+    const int m_index;
+};
+
+class WifiStaConfigStaticDns2Text : public virtual espgui::TextInterface
+{
+public:
+    WifiStaConfigStaticDns2Text(int index) : m_index{index} {}
+
+    std::string text() const override;
+
+private:
+    const int m_index;
+};

main/texthelpers/wifistatexthelpers.cpp

@@ -0,0 +1,149 @@
+#include "wifistatexthelpers.h"
+
+// 3rdparty lib includes
+#include <fmt/core.h>
+#include <espwifistack.h>
+#include <richtextrenderer.h>
+
+// local includes
+#include "wifiguiutils.h"
+
+using namespace espgui;
+
+std::string WifiStaStatusText::text() const
+{
+    const auto staStatus = wifi_stack::get_sta_status();
+    return fmt::format("&sstatus: &f{}{}",
+                       staStatus == wifi_stack::WiFiStaStatus::CONNECTED ? "&2" : "",
+                       wifi_stack::toString(staStatus));
+}
+
+std::string WifiStaMacText::text() const
+{
+    std::string text = "&smac: &f";
+    wifi_stack::mac_t mac;
+    if (const auto result = esp_wifi_get_mac(WIFI_IF_STA, std::begin(mac)); result == ESP_OK)
+        text += wifi_stack::toString(mac);
+    else
+        text += fmt::format("&1{}", esp_err_to_name(result));
+    return text;
+}
+
+std::string WifiStaScanStatusText::text() const
+{
+    const auto status = wifi_stack::get_scan_status();
+    return fmt::format("Scan {}{}",
+                       status == wifi_stack::WiFiScanStatus::Finished ? "&2" : "",
+                       wifi_stack::toString(status));
+}
+
+std::string WifiSsidText::text() const
+{
+    std::string text = "&sssid: &f";
+    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
+        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
+            text += richTextEscape(std::string_view{reinterpret_cast<const char*>(result->ssid)});
+    return text;
+}
+
+std::string WifiBssidText::text() const
+{
+    std::string text = "&sbssid: &f";
+    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
+        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
+            text += wifi_stack::toString(wifi_stack::mac_t{result->bssid});
+    return text;
+}
+
+std::string WifiRssiText::text() const
+{
+    std::string text = "&srssi: &f";
+    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
+        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
+            text += fmt::format("{}{}dB", rssiToColor(result->rssi), result->rssi);
+    return text;
+}
+
+std::string WifiAuthmodeText::text() const
+{
+    std::string text = "&sauthmode: &f";
+    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
+        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
+            text += wifi_stack::toString(result->authmode);
+    return text;
+}
+
+std::string WifiPairwiseCipherText::text() const
+{
+    std::string text = "&spairwCiph: &f";
+    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
+        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
+            text += wifi_stack::toString(result->pairwise_cipher);
+    return text;
+}
+
+std::string WifiGroupCipherText::text() const
+{
+    std::string text = "&sgroupCiph: &f";
+    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
+        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
+            text += wifi_stack::toString(result->group_cipher);
+    return text;
+}
+
+std::string WifiStaIpText::text() const
+{
+    std::string text = "&sip: &f";
+    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
+        if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
+            text += wifi_stack::toString(result->ip);
+    return text;
+}
+
+std::string WifiStaNetmaskText::text() const
+{
+    std::string text = "&smask: &f";
+    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
+        if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
+            text += wifi_stack::toString(result->netmask);
+    return text;
+}
+
+std::string WifiStaGatewayText::text() const
+{
+    std::string text = "&sgw: &f";
+    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
+        if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
+            text += wifi_stack::toString(result->gw);
+    return text;
+}
+
+std::string WifiStaHostnameText::text() const
+{
+    if (auto hostname = wifi_stack::get_hostname_for_interface(ESP_IF_WIFI_STA))
+        return fmt::format("&shostname: &f{}", espgui::richTextEscape(*hostname));
+    else
+        return fmt::format("&shostname: &1{}", espgui::richTextEscape(std::move(hostname).error()));
+}
+
+std::string WifiStaIpv6LinklocalText::text() const
+{
+    std::string text = "&sipv6-loc: &f";
+    esp_ip6_addr_t addr;
+    if (const auto result = esp_netif_get_ip6_linklocal(wifi_stack::esp_netifs[ESP_IF_WIFI_STA], &addr); result == ESP_OK)
+        text += wifi_stack::toString(addr);
+    else
+        text += fmt::format("&1{}", esp_err_to_name(result));
+    return text;
+}
+
+std::string WifiStaIpv6GlobalText::text() const
+{
+    std::string text = "&sipv6-glo: &f";
+    esp_ip6_addr_t addr;
+    if (const auto result = esp_netif_get_ip6_global(wifi_stack::esp_netifs[ESP_IF_WIFI_STA], &addr); result == ESP_OK)
+        text += wifi_stack::toString(addr);
+    else
+        text += fmt::format("&1{}", esp_err_to_name(result));
+    return text;
+}

main/texthelpers/wifistatexthelpers.h

@@ -0,0 +1,94 @@
+#pragma once
+
+// 3rdparty lib includes
+#include <textinterface.h>
+
+class WifiStaStatusText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiStaMacText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiStaScanStatusText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiSsidText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiBssidText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiRssiText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiAuthmodeText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiPairwiseCipherText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiGroupCipherText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiStaIpText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiStaNetmaskText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiStaGatewayText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiStaHostnameText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiStaIpv6LinklocalText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};
+
+class WifiStaIpv6GlobalText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override;
+};

main/texts.cpp

@@ -131,7 +131,7 @@ char TEXT_VOLTAGECALIBRATION_VALUE_50_BACK[] = "50V Back";
 //char TEXT_SETTINGS[] = "Settings";
 char TEXT_BACKLIGHT[] = "Backlight";
 char TEXT_LIMITSSETTINGS[] = "Limits settings";
-char TEXT_WIFISETTINGS[] = "WiFi settings";
+char TEXT_NETWORKSETTINGS[] = "Network settings";
 //char TEXT_BLUETOOTHSETTINGS[] = "Bluetooth settings";
 //char TEXT_BLESETTINGS[] = "BLE settings";
 //char TEXT_CLOUDSETTINGS[] = "Cloud settings";

main/texts.h

@@ -130,7 +130,7 @@ extern char TEXT_VOLTAGECALIBRATION_VALUE_50_BACK[];
 //extern char TEXT_SETTINGS[];
 extern char TEXT_BACKLIGHT[];
 extern char TEXT_LIMITSSETTINGS[];
-extern char TEXT_WIFISETTINGS[];
+extern char TEXT_NETWORKSETTINGS[];
 //extern char TEXT_BLUETOOTHSETTINGS[];
 //extern char TEXT_BLESETTINGS[];
 //extern char TEXT_CLOUDSETTINGS[];

main/webserver_displaycontrol.cpp

@@ -35,7 +35,6 @@ constexpr const char * const TAG = "BOBBYWEB";
 esp_err_t webserver_root_handler(httpd_req_t *req)
 {
 #ifndef FEATURE_IS_MIR_EGAL_OB_DER_WEBSERVER_KORREKT_ARBEITET
-    ESP_LOGI(TAG, "locking...");
     espcpputils::LockHelper helper{webserver_lock->handle, std::chrono::ceil<espcpputils::ticks>(5s).count()};
     if (!helper.locked())
     {
@@ -43,7 +42,6 @@ esp_err_t webserver_root_handler(httpd_req_t *req)
         ESP_LOGE(TAG, "%.*s", msg.size(), msg.data());
         CALL_AND_EXIT(esphttpdutils::webserver_resp_send, req, esphttpdutils::ResponseStatus::BadRequest, "text/plain", msg);
     }
-    ESP_LOGI(TAG, "succeeded");
 #endif
 
     std::string body;

main/webserver_newsettings.cpp

@@ -207,6 +207,16 @@ esp_err_t webserver_newSettings_handler(httpd_req_t *req)
                     HtmlTag buttonTag{"button", "type=\"submit\"", body};
                     body += "Save";
                 }
+
+                {
+                    HtmlTag divTag{"div", "class=\"form-table-cell\"", body};
+
+                    if (config.touched())
+                    {
+                        HtmlTag buttonTag{"span", "style=\"color: red;\"", body};
+                        body += "Touched";
+                    }
+                }
             });
         }
     }

main/wifiguiutils.cpp

@@ -0,0 +1,9 @@
+#include "wifiguiutils.h"
+
+std::string rssiToColor(int8_t rssi)
+{
+         if (rssi < -80) return "&1"; // red
+    else if (rssi < -60) return "&4"; // yellow
+    else if (rssi > -40) return "&2"; // green
+    return {};
+}

main/wifiguiutils.h

@@ -0,0 +1,6 @@
+#pragma once
+
+// system includes
+#include <string>
+
+std::string rssiToColor(int8_t rssi);

main/wifitexthelpers.cpp

@@ -1,167 +0,0 @@
-#include "wifitexthelpers.h"
-
-// 3rdparty lib includes
-#include <fmt/core.h>
-#include <espwifistack.h>
-#include <esp_netif.h>
-#include <lwip/dns.h>
-
-std::string WifiStatusText::text() const
-{
-    return fmt::format("Status: {}", wifi_stack::toString(wifi_stack::get_sta_status()));
-}
-
-std::string WifiScanStatusText::text() const
-{
-    return fmt::format("ScanStatus: {}", wifi_stack::toString(wifi_stack::get_scan_status()));
-}
-
-std::string WifiHostnameText::text() const
-{
-    std::string text = "Hostname: ";
-    const char *hostname{};
-    if (const auto result = esp_netif_get_hostname(wifi_stack::esp_netifs[ESP_IF_WIFI_STA], &hostname); result == ESP_OK)
-        if (hostname)
-            text += hostname;
-    return text;
-}
-
-std::string WifiMacText::text() const
-{
-    std::string text = "MAC: ";
-    if (const auto result = wifi_stack::get_base_mac_addr())
-        text += wifi_stack::toString(*result);
-    return text;
-}
-
-std::string WifiSsidText::text() const
-{
-    std::string text = "SSID: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
-            text += std::string_view{reinterpret_cast<const char*>(result->ssid)};
-    return text;
-}
-
-std::string WifiBssidText::text() const
-{
-    std::string text = "BSSID: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
-            text += wifi_stack::toString(wifi_stack::mac_t{result->bssid});
-    return text;
-}
-
-std::string WifiRssiText::text() const
-{
-    std::string text = "RSSI: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
-            text += fmt::format("{}dB", result->rssi);
-    return text;
-}
-
-std::string WifiEncryptionTypeText::text() const
-{
-    std::string text = "encryptionType: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
-            text += wifi_stack::toString(result->authmode);
-    return text;
-}
-
-std::string WifiPairwiseCipherText::text() const
-{
-    std::string text = "pairwiseCipher: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
-            text += wifi_stack::toString(result->pairwise_cipher);
-    return text;
-}
-
-std::string WifiGroupCipherText::text() const
-{
-    std::string text = "groupCipher: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-        if (const auto &result = wifi_stack::get_sta_ap_info(); result)
-            text += wifi_stack::toString(result->group_cipher);
-    return text;
-}
-
-std::string WifiIpText::text() const
-{
-    std::string text = "ip: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-        if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
-            text += wifi_stack::toString(result->ip);
-    return text;
-}
-
-std::string WifiNetmaskText::text() const
-{
-    std::string text = "netmask: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-        if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
-            text += wifi_stack::toString(result->netmask);
-    return text;
-}
-
-std::string WifiGatewayText::text() const
-{
-    std::string text = "gateway: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-        if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
-            text += wifi_stack::toString(result->gw);
-    return text;
-}
-
-std::string WifiIpv6LinklocalText::text() const
-{
-    std::string text = "ipv6: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-    {
-        esp_ip6_addr_t addr;
-        if (const auto result = esp_netif_get_ip6_linklocal(wifi_stack::esp_netifs[ESP_IF_WIFI_STA], &addr); result == ESP_OK)
-            text += wifi_stack::toString(addr);
-    }
-    return text;
-}
-
-std::string WifiIpv6GlobalText::text() const
-{
-    std::string text = "ipv6: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-    {
-        esp_ip6_addr_t addr;
-        if (const auto result = esp_netif_get_ip6_global(wifi_stack::esp_netifs[ESP_IF_WIFI_STA], &addr); result == ESP_OK)
-            text += wifi_stack::toString(addr);
-    }
-    return text;
-}
-
-std::string WifiDns0Text::text() const
-{
-    std::string text = "dns0: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-        if (const ip_addr_t *dns_ip = dns_getserver(0))
-            text += wifi_stack::toString(*dns_ip);
-    return text;
-}
-
-std::string WifiDns1Text::text() const
-{
-    std::string text = "dns1: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-        if (const ip_addr_t *dns_ip = dns_getserver(1))
-            text += wifi_stack::toString(*dns_ip);
-    return text;
-}
-
-std::string WifiDns2Text::text() const
-{
-    std::string text = "dns2: ";
-    if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
-        if (const ip_addr_t *dns_ip = dns_getserver(2))
-            text += wifi_stack::toString(*dns_ip);
-    return text;
-}

main/wifitexthelpers.h

@@ -1,129 +0,0 @@
-#pragma once
-
-// local includes
-#include "textinterface.h"
-
-class WifiStatusText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiScanStatusText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiHostnameText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiMacText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiSsidText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiBssidText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiRssiText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiEncryptionTypeText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiPairwiseCipherText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiGroupCipherText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiIpText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiNetmaskText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiGatewayText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiIpv6LinklocalText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiIpv6GlobalText : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiDns0Text : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiDns1Text : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-class WifiDns2Text : public virtual espgui::TextInterface
-{
-public:
-    std::string text() const override;
-};
-
-constexpr char TEXT_SOFTAPGETSTATIONNUM[] = "softAPgetStationNum: ";
-using WifiSoftApGetStationNumText = espgui::StaticText<TEXT_SOFTAPGETSTATIONNUM>; //StatusTextHelper<TEXT_SOFTAPGETSTATIONNUM, &WiFi.softAPgetStationNum>
-constexpr char TEXT_SOFTAPIP[] = "softAPIP: ";
-using WifiSoftApIpText = espgui::StaticText<TEXT_SOFTAPIP>; //StatusTextHelper<TEXT_SOFTAPIP, &WiFi.softAPIP>
-constexpr char TEXT_SOFTAPBROADCASTIP[] = "softAPBroadcastIP: ";
-using WifiSoftApBroadcastIpText = espgui::StaticText<TEXT_SOFTAPBROADCASTIP>; //StatusTextHelper<TEXT_SOFTAPBROADCASTIP, &WiFi.softAPBroadcastIP>
-constexpr char TEXT_SOFTAPNETWORKID[] = "softAPNetworkID: ";
-using WifiSoftApNetworkIdText = espgui::StaticText<TEXT_SOFTAPNETWORKID>; //StatusTextHelper<TEXT_SOFTAPNETWORKID, &WiFi.softAPNetworkID>
-constexpr char TEXT_SOFTAPSUBNETCIDR[] = "softAPSubnetCIDR: ";
-using WifiSoftApSubnetCidrText = espgui::StaticText<TEXT_SOFTAPSUBNETCIDR>; //StatusTextHelper<TEXT_SOFTAPSUBNETCIDR, &WiFi.softAPSubnetCIDR>
-constexpr char TEXT_SOFTAPIPV6[] = "softAPIPv6: ";
-using WifiSoftApIpV6Text = espgui::StaticText<TEXT_SOFTAPIPV6>; //StatusTextHelper<TEXT_SOFTAPIPV6, &WiFi.softAPIPv6>
-constexpr char TEXT_SOFTAPGETHOSTNAME[] = "softAPgetHostname: ";
-using WifiSoftApHostnameText = espgui::StaticText<TEXT_SOFTAPGETHOSTNAME>; //StatusTextHelper<TEXT_SOFTAPGETHOSTNAME, &WiFi.softAPgetHostname>
-constexpr char TEXT_SOFTAPMACADDRESS[] = "softAPmacAddress: ";
-using WifiSoftApMacAddressText = espgui::StaticText<TEXT_SOFTAPMACADDRESS>; //StatusTextHelper<TEXT_SOFTAPMACADDRESS, &WiFi.softAPmacAddress>