Merge pull request #204 from bobbycar-graz/new-changevaluedisplays

New changevaluedisplays

config_feedc0de.cmake

@@ -80,7 +80,7 @@ set(BOBBYCAR_BUILDFLAGS
   -DFEATURE_LEDBACKLIGHT
   -DPINS_LEDBACKLIGHT=23
   -DLEDBACKLIGHT_INVERTED
-  -DFEATURE_GARAGE
+#  -DFEATURE_GARAGE
   -DFEATURE_NTP
   -DFEATURE_WIRELESS_CONFIG
   -DFEATURE_LEDSTRIP
@@ -93,5 +93,6 @@ set(BOBBYCAR_BUILDFLAGS
   -DOLD_NVS
   -DFEATURE_DNS_NS
 #  -DSWITCH_BLINK
-#  -DFEATURE_ESPNOW
+#  -DFEATURE_IS_MIR_EGAL_OB_DER_WEBSERVER_KORREKT_ARBEITET
+  -DFEATURE_ESPNOW
 )

main/CMakeLists.txt

@@ -8,6 +8,7 @@ set(headers
     bluetoothtexthelpers.h
     bmsutils.h
     bobbybuttons.h
+    bobbycheckbox.h
     bobbyerrorhandler.h
     buildserver.h
     buttons.h
@@ -56,7 +57,6 @@ set(headers
     statistics.h
     statustexthelper.h
     taskmanager.h
-    texts.h
     time_bobbycar.h
     types.h
     udpcloud.h
@@ -291,7 +291,6 @@ set(sources
     statistics.cpp
     statustexthelper.cpp
     taskmanager.cpp
-    texts.cpp
     time_bobbycar.cpp
     types.cpp
     udpcloud.cpp

main/accessors/settingsaccessors.h

@@ -182,7 +182,19 @@ struct LedsCountAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &ge
 struct CenterOffsetAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.ledstrip.centerOffset; } };
 struct SmallOffsetAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.ledstrip.smallOffset; } };
 struct BigOffsetAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.ledstrip.bigOffset; } };
-struct DeziampereAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.ledstrip.deziampere; } };
+struct LedStripMaxMilliampsAccessor : public NewSettingsAccessor<uint32_t> { ConfigWrapper<uint32_t> &getConfig() const override { return configs.ledStripMaxMilliamps; } };
+struct LedStripMaxAmpereAccessor : public virtual espgui::AccessorInterface<float>
+{
+    float getValue() const override
+    {
+        return configs.ledStripMaxMilliamps.value / 1000.f;
+    }
+
+    espgui::AccessorInterface<float>::setter_result_t setValue(float value) override
+    {
+        return configs.write_config(configs.ledStripMaxMilliamps, value * 1000);
+    }
+};
 struct EnableBeepWhenBlinkAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.ledstrip.enableBeepWhenBlink; } };
 struct EnableFullBlinkAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.ledstrip.enableFullBlink; } };
 struct EnableLedstripStVOAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.ledstrip.enableStVO; } };

main/accessors/wifiapconfigaccessors.h

@@ -6,7 +6,7 @@
 
 struct WifiApEnabledAccessor : public NewSettingsAccessor<bool> { ConfigWrapper<bool> &getConfig() const override { return configs.wifiApEnabled; } };
 //struct WifiApDisableWhenOnlineAccessor : public NewSettingsAccessor<bool> { ConfigWrapper<bool> &getConfig() const override { return configs.wifiDisableApWhenOnline; } };
-struct WifiApNameAccessor : public NewSettingsAccessor<std::string> { ConfigWrapper<std::string> &getConfig() const override { return configs.wifiApName; } };
+struct WifiApSsidAccessor : public NewSettingsAccessor<std::string> { ConfigWrapper<std::string> &getConfig() const override { return configs.wifiApName; } };
 struct WifiApKeyAccessor : public NewSettingsAccessor<std::string> { ConfigWrapper<std::string> &getConfig() const override { return configs.wifiApKey; } };
 struct WifiApIpAccessor : public NewSettingsAccessor<wifi_stack::ip_address_t> { ConfigWrapper<wifi_stack::ip_address_t> &getConfig() const override { return configs.wifiApIp; } };
 struct WifiApMaskAccessor : public NewSettingsAccessor<wifi_stack::ip_address_t> { ConfigWrapper<wifi_stack::ip_address_t> &getConfig() const override { return configs.wifiApMask; } };

main/accessors/wifistaconfigaccessors.h

@@ -14,6 +14,7 @@
 #include "accessorhelpers.h"
 
 struct WifiStaEnabledAccessor : public NewSettingsAccessor<bool> { ConfigWrapper<bool> &getConfig() const override { return configs.wifiStaEnabled; } };
+struct WifiStaMinRssiAccessor : public NewSettingsAccessor<int8_t> { ConfigWrapper<int8_t> &getConfig() const override { return configs.wifiStaMinRssi; } };
 
 class WifiStaConfigSsidAccessor : public virtual NewSettingsAccessor<std::string>
 {

main/actions/rebootaction.cpp

@@ -6,16 +6,12 @@
 // 3rdparty lib includes
 #include <tftinstance.h>
 
-// local includes
-#include "globals.h"
-#include "texts.h"
-
 void RebootAction::triggered()
 {
     espgui::tft.fillScreen(TFT_BLACK);
     espgui::tft.setTextColor(TFT_YELLOW);
 
-    espgui::tft.drawString(TEXT_REBOOT, 5, 5, 4);
+    espgui::tft.drawString("Reboot", 5, 5, 4);
 
     espgui::tft.fillRect(0, 34, espgui::tft.width(), 3, TFT_WHITE);
 

main/actions/rebootaction.h

@@ -1,9 +1,7 @@
 #pragma once
 
 // 3rdparty lib includes
-#include "actioninterface.h"
+#include <actioninterface.h>
-
-using namespace espgui;
 
 class RebootAction : public virtual espgui::ActionInterface
 {

main/bobbybuttons.cpp

@@ -1,23 +1,39 @@
 #include "bobbybuttons.h"
 
+// local includes
+#include "newsettings.h"
+
 [[nodiscard]] std::optional<espgui::Button> translateRawButton(uint8_t button)
 {
-    switch (button)
+    // Invalid
-    {
+    if (button == INPUT_MAPPING_NONE)
+        return std::nullopt;
+
     using espgui::Button;
-    case 0: return Button::Left;
+    if (configs.dpadMappingLeft.value == button)
-    case 1: return Button::Right;
+        return Button::Left;
-    case 2: return Button::Up;
+    if (configs.dpadMappingRight.value == button)
-    case 3: return Button::Down;
+        return Button::Right;
-    case 4: return Button(BobbyButton::Profile0);
+    if (configs.dpadMappingUp.value == button)
-    case 5: return Button(BobbyButton::Profile1);
+        return Button::Up;
-    case 6: return Button(BobbyButton::Profile2);
+    if (configs.dpadMappingDown.value == button)
-    case 7: return Button(BobbyButton::Profile3);
+        return Button::Down;
-    case 8: return Button(BobbyButton::Left2);
+    if (configs.dpadMappingProfile0.value == button)
-    case 9: return Button(BobbyButton::Right2);
+        return Button(BobbyButton::Profile0);
-    case 10: return Button(BobbyButton::Up2);
+    if (configs.dpadMappingProfile1.value == button)
-    case 11: return Button(BobbyButton::Down2);
+        return Button(BobbyButton::Profile1);
-    }
+    if (configs.dpadMappingProfile2.value == button)
+        return Button(BobbyButton::Profile2);
+    if (configs.dpadMappingProfile3.value == button)
+        return Button(BobbyButton::Profile3);
+    if (configs.dpadMappingLeft2.value == button)
+        return Button(BobbyButton::Left2);
+    if (configs.dpadMappingRight2.value == button)
+        return Button(BobbyButton::Right2);
+    if (configs.dpadMappingUp2.value == button)
+        return Button(BobbyButton::Up2);
+    if (configs.dpadMappingDown2.value == button)
+        return Button(BobbyButton::Down2);
 
     return std::nullopt;
 }

main/bobbycheckbox.h

@@ -0,0 +1,15 @@
+#pragma once
+
+// 3rdparty lib includes
+#include <actions/toggleboolaction.h>
+#include <checkboxicon.h>
+
+// local includes
+#include "bobbyerrorhandler.h"
+
+class BobbyCheckbox :
+    public virtual espgui::ToggleBoolAction,
+    public virtual espgui::CheckboxIcon,
+    public virtual BobbyErrorHandler
+{
+};

main/can.cpp

@@ -13,12 +13,13 @@
 // 3rdparty lib includes
 #include <espchrono.h>
 #include <tickchrono.h>
+#include <screenmanager.h>
 
 // local includes
 #include "bobbycar-can.h"
 #include "globals.h"
-#include "buttons.h"
 #include "newsettings.h"
+#include "bobbybuttons.h"
 
 using namespace std::chrono_literals;
 
@@ -29,7 +30,6 @@ constexpr const char * const TAG = "BOBBYCAN";
 
 std::optional<int16_t> can_gas, can_brems;
 espchrono::millis_clock::time_point last_can_gas{}, last_can_brems{};
-CanButtonsState lastButtonsState;
 
 void initCan()
 {
@@ -160,47 +160,22 @@ bool parseBoardcomputerCanMessage(const twai_message_t &message)
     switch (message.identifier)
     {
     using namespace bobbycar::protocol::can;
-    case Boardcomputer::Command::ButtonPress:
+    case Boardcomputer::Command::RawButtonPressed:
-    {
+        if (espgui::currentDisplay)
-        const auto canButtonBits = *((uint16_t*)message.data);
+            espgui::currentDisplay->rawButtonPressed(*((const uint8_t*)message.data));
-        CanButtonsState newState {
+        break;
-            .up =       bool(canButtonBits & Boardcomputer::ButtonUp),
+    case Boardcomputer::Command::RawButtonReleased:
-            .down =     bool(canButtonBits & Boardcomputer::ButtonDown),
+        if (espgui::currentDisplay)
-            .confirm =  bool(canButtonBits & Boardcomputer::ButtonConfirm),
+            espgui::currentDisplay->rawButtonReleased(*((const uint8_t*)message.data));
-            .back =     bool(canButtonBits & Boardcomputer::ButtonBack),
+        break;
-            .profile0 = bool(canButtonBits & Boardcomputer::ButtonProfile0),
+    case Boardcomputer::Command::ButtonPressed:
-            .profile1 = bool(canButtonBits & Boardcomputer::ButtonProfile1),
+        if (espgui::currentDisplay)
-            .profile2 = bool(canButtonBits & Boardcomputer::ButtonProfile2),
+            espgui::currentDisplay->rawButtonPressed(espgui::Button(*((const uint8_t*)message.data)));
-            .profile3 = bool(canButtonBits & Boardcomputer::ButtonProfile3),
+        break;
-        };
+    case Boardcomputer::Command::ButtonReleased:
-
+        if (espgui::currentDisplay)
-        if (lastButtonsState.up != newState.up)
+            espgui::currentDisplay->rawButtonPressed(espgui::Button(*((const uint8_t*)message.data)));
-            InputDispatcher::upButton(newState.up);
-
-        if (lastButtonsState.down != newState.down)
-            InputDispatcher::downButton(newState.down);
-
-        if (lastButtonsState.confirm != newState.confirm)
-            InputDispatcher::confirmButton(newState.confirm);
-
-        if (lastButtonsState.back != newState.back)
-            InputDispatcher::backButton(newState.back);
-
-        if (lastButtonsState.profile0 != newState.profile0)
-            InputDispatcher::profileButton(0, newState.profile0);
-
-        if (lastButtonsState.profile1 != newState.profile1)
-            InputDispatcher::profileButton(1, newState.profile1);
-
-        if (lastButtonsState.profile2 != newState.profile2)
-            InputDispatcher::profileButton(2, newState.profile2);
-
-        if (lastButtonsState.profile3 != newState.profile3)
-            InputDispatcher::profileButton(3, newState.profile3);
-
-        lastButtonsState = newState;
         break;
-    }
     case Boardcomputer::Command::RawGas:
         can_gas = *((int16_t*)message.data);
         last_can_gas = espchrono::millis_clock::now();

main/changevaluedisplay_bluetoothmode.h

@@ -7,7 +7,6 @@
 #include "actions/setvalueaction.h"
 #include "actions/backproxyaction.h"
 #include "icons/back.h"
-#include "texts.h"
 #ifdef FEATURE_BLUETOOTH
 #include "bluetoothmode.h"
 #endif

main/debuginputhandler.cpp

@@ -10,12 +10,12 @@
 // 3rdparty lib includes
 #include <tftinstance.h>
 #include <esp32-hal-gpio.h>
+#include <screenmanager.h>
 
 // local includes
 #include "globals.h"
 #include "utils.h"
-#include "screens.h"
+#include "bobbybuttons.h"
-#include "buttons.h"
 
 namespace {
 constexpr const char * const TAG = "DEBUG";
@@ -54,83 +54,127 @@ void handleDebugInput()
 
         for (char c : std::string_view{data, length})
         {
-            switch (c)
+            if (consoleControlCharsReceived < 2)
             {
-            case 'i':
+                switch (c)
-            case 'I':
+                {
-                espgui::tft.init();
+                case '\x1b':
-                break;
+                    if (consoleControlCharsReceived == 0)
-            case 'p':
+                        consoleControlCharsReceived = 1;
-            case 'P':
+                    else
-            {
+                        consoleControlCharsReceived = 0;
-                const auto firstPower = controllers.front.command.poweroff;
+                    break;
-                for (Controller &controller : controllers)
+                case '\x5b':
-                    controller.command.poweroff = !firstPower;
+                    if (consoleControlCharsReceived == 1)
-                break;
+                        consoleControlCharsReceived = 2;
+                    else
+                        consoleControlCharsReceived = 0;
+                    break;
+                case 'i':
+                case 'I':
+                    consoleControlCharsReceived = 0;
+                    espgui::tft.init();
+                    break;
+                case 'p':
+                case 'P':
+                {
+                    consoleControlCharsReceived = 0;
+                    const auto firstPower = controllers.front.command.poweroff;
+                    for (Controller &controller : controllers)
+                        controller.command.poweroff = !firstPower;
+                    break;
+                }
+                case 'l':
+                case 'L':
+                {
+                    consoleControlCharsReceived = 0;
+                    const auto firstLed = controllers.front.command.led;
+                    for (Controller &controller : controllers)
+                        controller.command.led = !firstLed;
+                    break;
+                }
+                case 'r':
+                case 'R':
+                    consoleControlCharsReceived = 0;
+                    loadSettings();
+                    break;
+                case 's':
+                case 'S':
+                    consoleControlCharsReceived = 0;
+                    saveSettings();
+                    break;
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                    consoleControlCharsReceived = 0;
+                    for (Controller &controller : controllers)
+                        controller.command.buzzer.freq = c-'0';
+                    break;
+                case 'z':
+                case 'Z':
+                    consoleControlCharsReceived = 0;
+                    if (espgui::currentDisplay)
+                    {
+                        espgui::currentDisplay->buttonPressed(espgui::Button(BobbyButton::Left2));
+                        espgui::currentDisplay->buttonReleased(espgui::Button(BobbyButton::Left2));
+                    }
+                    break;
+                case 'u':
+                case 'U':
+                    consoleControlCharsReceived = 0;
+                    if (espgui::currentDisplay)
+                    {
+                        espgui::currentDisplay->buttonPressed(espgui::Button(BobbyButton::Right2));
+                        espgui::currentDisplay->buttonReleased(espgui::Button(BobbyButton::Right2));
+                    }
+                    break;
+                default:
+                    consoleControlCharsReceived = 0;
+                }
             }
-            case 'l':
+            else
-            case 'L':
             {
-                const auto firstLed = controllers.front.command.led;
+                consoleControlCharsReceived = 0;
-                for (Controller &controller : controllers)
+                switch (c)
-                    controller.command.led = !firstLed;
+                {
-                break;
+                case 'A': // Up arrow pressed
-            }
+                    if (espgui::currentDisplay)
-            case 'r':
+                    {
-            case 'R':
+                        espgui::currentDisplay->buttonPressed(espgui::Button::Up);
-                loadSettings();
+                        espgui::currentDisplay->buttonReleased(espgui::Button::Up);
-                break;
+                    }
-            case 's':
+                    break;
-            case 'S':
+                case 'B': // Down arrow pressed
-                saveSettings();
+                    if (espgui::currentDisplay)
-                break;
+                    {
-            case '0':
+                        espgui::currentDisplay->buttonPressed(espgui::Button::Down);
-            case '1':
+                        espgui::currentDisplay->buttonReleased(espgui::Button::Down);
-            case '2':
+                    }
-            case '3':
+                    break;
-            case '4':
+                case 'C': // Right arrow pressed
-            case '5':
+                    if (espgui::currentDisplay)
-            case '6':
+                    {
-            case '7':
+                        espgui::currentDisplay->buttonPressed(espgui::Button::Right);
-            case '8':
+                        espgui::currentDisplay->buttonReleased(espgui::Button::Right);
-            case '9':
+                    }
-                for (Controller &controller : controllers)
+                    break;
-                    controller.command.buzzer.freq = c-'0';
+                case 'D': // Left arrow pressed
-                break;
+                    if (espgui::currentDisplay)
-            case 'A':
+                    {
-                InputDispatcher::rotate(-1);
+                        espgui::currentDisplay->buttonPressed(espgui::Button::Left);
-                break;
+                        espgui::currentDisplay->buttonReleased(espgui::Button::Left);
-            case 'B':
+                    }
-                InputDispatcher::rotate(1);
+                    break;
-                break;
+                default:
-            case 'C':
+                    ESP_LOGI(TAG, "unknown control char received: %hhx", c);
-                InputDispatcher::confirmButton(true);
+                }
-                InputDispatcher::confirmButton(false);
-                break;
-            case 'D':
-                InputDispatcher::backButton(true);
-                InputDispatcher::backButton(false);
-                break;
-            case 'z':
-            case 'Z':
-#ifndef LEDSTRIP_WRONG_DIRECTION
-                InputDispatcher::blinkLeftButton(true);
-                InputDispatcher::blinkLeftButton(false);
-#else
-                InputDispatcher::blinkRightButton(true);
-                InputDispatcher::blinkRightButton(false);
-#endif
-                break;
-            case 'u':
-            case 'U':
-#ifndef LEDSTRIP_WRONG_DIRECTION
-                InputDispatcher::blinkRightButton(true);
-                InputDispatcher::blinkRightButton(false);
-#else
-                InputDispatcher::blinkLeftButton(true);
-                InputDispatcher::blinkLeftButton(false);
-#endif
-                break;
             }
         }
     }

main/displays/calibratedisplay.cpp

@@ -10,6 +10,10 @@
 #include "displays/menus/boardcomputerhardwaresettingsmenu.h"
 #include "newsettings.h"
 
+namespace {
+constexpr char TEXT_CALIBRATE[] = "Calibrate";
+} // namespace
+
 CalibrateDisplay::CalibrateDisplay(bool bootup) :
     m_bootup{bootup}
 {

main/displays/calibratedisplay.h

@@ -15,7 +15,6 @@
 #include "bobbydisplaywithtitle.h"
 #include "globals.h"
 #include "utils.h"
-#include "texts.h"
 #include "modes/ignoreinputmode.h"
 
 class CalibrateDisplay : public BobbyDisplayWithTitle

main/displays/calibratevoltagedisplay.cpp

@@ -1,15 +1,35 @@
 #include "calibratevoltagedisplay.h"
 
 // 3rdparty lib includes
+#include <menuitem.h>
+#include <icons/back.h>
+#include <actions/dummyaction.h>
+#include <actions/switchscreenaction.h>
+#include <widgets/label.h>
 #include <fmt/core.h>
-#include <actions/toggleboolaction.h>
-#include <checkboxicon.h>
 
-// local includes
+// Local includes
+#include "utils.h"
+#include "icons/settings.h"
+#include "battery.h"
+#include "menus/batterymenu.h"
+#include "globals.h"
 #include "displays/menus/batterymenu.h"
 #include "accessors/settingsaccessors.h"
+#include "bobbycheckbox.h"
 
 namespace {
+constexpr char TEXT_BATTERY_CALIBRATE[] = "Calibrate Voltages";
+constexpr char TEXT_VOLTAGECALIBRATION_30V[] = "Calibrate 30.0V";
+constexpr char TEXT_VOLTAGECALIBRATION_50V[] = "Calibrate 50.0V";
+constexpr char TEXT_VOLTAGECALIBRATION_VALUE_30_FRONT[] = "30V Front";
+constexpr char TEXT_VOLTAGECALIBRATION_VALUE_30_BACK[] = "30V Back";
+constexpr char TEXT_VOLTAGECALIBRATION_VALUE_50_FRONT[] = "50V Front";
+constexpr char TEXT_VOLTAGECALIBRATION_VALUE_50_BACK[] = "50V Back";
+constexpr char TEXT_BATTERY_APPLYCALIB[] = "Apply calibration";
+constexpr char TEXT_VOLTAGECALIBRATION_RESET[] = "Reset calibration";
+constexpr char TEXT_BACK[] = "Back";
+
 class Save30VCalibrationAction : public virtual espgui::ActionInterface
 {
 public:
@@ -50,20 +70,61 @@ float convertToFloat(int16_t value)
     return value/100.;
 }
 
-class BatteryVoltageCalibrationFront30VText : public virtual espgui::TextInterface { public: std::string text() const override { return fmt::format("30V Front: {}", convertToFloat(settings.battery.front30VoltCalibration)); } };
+class BatteryVoltageCalibrationFront30VText : public virtual espgui::TextInterface
-class BatteryVoltageCalibrationBack30VText : public virtual espgui::TextInterface { public: std::string text() const override { return fmt::format("30V Back: {}", convertToFloat(settings.battery.back30VoltCalibration)); } };
+{
-class BatteryVoltageCalibrationFront50VText : public virtual espgui::TextInterface { public: std::string text() const override { return fmt::format("50V Front: {}", convertToFloat(settings.battery.front50VoltCalibration)); } };
+public:
-class BatteryVoltageCalibrationBack50VText : public virtual espgui::TextInterface { public: std::string text() const override { return fmt::format("50V Back: {}", convertToFloat(settings.battery.back50VoltCalibration)); } };
+    std::string text() const override
-class BatteryVoltageCalibratedText : public virtual espgui::TextInterface { public: std::string text() const override { if (settings.battery.applyCalibration) return fmt::format("F{:.2f}V B{:.2f}", controllers.front.getCalibratedVoltage(), controllers.back.getCalibratedVoltage()); else return "Not activated"; } };
+    {
-} // namespace
+        return fmt::format("30V Front: {}", convertToFloat(settings.battery.front30VoltCalibration));
+    }
+};
 
-using namespace espgui;
+class BatteryVoltageCalibrationBack30VText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override
+    {
+        return fmt::format("30V Back: {}", convertToFloat(settings.battery.back30VoltCalibration));
+    }
+};
+
+class BatteryVoltageCalibrationFront50VText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override
+    {
+        return fmt::format("50V Front: {}", convertToFloat(settings.battery.front50VoltCalibration));
+    }
+};
+
+class BatteryVoltageCalibrationBack50VText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override
+    {
+        return fmt::format("50V Back: {}", convertToFloat(settings.battery.back50VoltCalibration));
+    }
+};
+
+class BatteryVoltageCalibratedText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override
+    {
+        if (settings.battery.applyCalibration)
+            return fmt::format("F{:.2f}V B{:.2f}", controllers.front.getCalibratedVoltage(), controllers.back.getCalibratedVoltage());
+        else
+            return "Not activated";
+    }
+};
+} // namespace
 
 CalibrateVoltageDisplay::CalibrateVoltageDisplay()
 {
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGECALIBRATION_30V>,          Save30VCalibrationAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGECALIBRATION_50V>,          Save50VCalibrationAction>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_APPLYCALIB>,              ToggleBoolAction, CheckboxIcon, BatteryApplyCalibrationAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_APPLYCALIB>,              BobbyCheckbox, BatteryApplyCalibrationAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                            SwitchScreenAction<BatteryMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 
     constructMenuItem<makeComponent<MenuItem, EmptyText,                                        DummyAction>>();
@@ -76,7 +137,12 @@ CalibrateVoltageDisplay::CalibrateVoltageDisplay()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGECALIBRATION_RESET>,        ResetCalibrationAction>>();
 }
 
+std::string CalibrateVoltageDisplay::text() const
+{
+    return TEXT_BATTERY_CALIBRATE;
+}
+
 void CalibrateVoltageDisplay::back()
 {
-    switchScreen<BatteryMenu>();
+    espgui::switchScreen<BatteryMenu>();
 }

main/displays/calibratevoltagedisplay.h

@@ -1,27 +1,14 @@
 #pragma once
 
-// 3rdparty lib includes
+// local includes
-#include <menuitem.h>
-#include <icons/back.h>
-#include <actions/dummyaction.h>
-#include <actions/switchscreenaction.h>
-#include <widgets/label.h>
-
-// Local includes
 #include "bobbymenudisplay.h"
-#include "utils.h"
-#include "icons/settings.h"
-#include "texts.h"
-#include "battery.h"
-#include "menus/batterymenu.h"
-#include "globals.h"
 
-class CalibrateVoltageDisplay :
+class CalibrateVoltageDisplay : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_BATTERY_CALIBRATE>
 {
 public:
     CalibrateVoltageDisplay();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/gametrakcalibratedisplay.h

@@ -12,7 +12,6 @@
 // local includes
 #include "bobbydisplay.h"
 #include "globals.h"
-#include "texts.h"
 #include "modes/ignoreinputmode.h"
 
 namespace {

main/displays/ledstripcolorsdisplay.cpp

@@ -17,13 +17,14 @@
 #include "utils.h"
 #include "icons/back.h"
 #include "icons/bobbycar.h"
-#include "texts.h"
 #include "actions/dummyaction.h"
 #include "globals.h"
 #include "displays/menus/ledstripmenu.h"
 
 #ifdef FEATURE_LEDSTRIP
 namespace {
+constexpr char TEXT_LEDSTRIPCOLORMENU[] = "Customize Ledstrip";
+
 int8_t selected_side = 7;
 int8_t selected_color;
 bool state_select_color{false};

main/displays/lockscreen.cpp

@@ -7,10 +7,12 @@
 // local includes
 #include "globals.h"
 #include "utils.h"
-#include "texts.h"
-#include "buttons.h"
 #include "displays/menus/mainmenu.h"
 #include "displays/calibratedisplay.h"
+#include "bobbybuttons.h"
+#ifdef LOCKSCREEN_PLUGIN
+#include "ledstripdefines.h"
+#endif
 
 void Lockscreen::start()
 {
@@ -24,7 +26,6 @@ void Lockscreen::start()
     m_oldMode = currentMode;
     currentMode = &m_mode;
 
-    profileButtonDisabled = !settings.lockscreen.allowPresetSwitch;
     isLocked = true;
     if (settings.lockscreen.keepLockedAfterReboot && !settings.lockscreen.locked)
     {
@@ -41,7 +42,7 @@ void Lockscreen::initScreen()
     espgui::tft.setTextFont(4);
     espgui::tft.setTextColor(TFT_YELLOW);
 
-    espgui::tft.drawString(TEXT_LOCKVEHICLE, 5, 5);
+    espgui::tft.drawString("Lock vehicle", 5, 5);
 
     espgui::tft.fillRect(0, 34, espgui::tft.width(), 3, TFT_WHITE);
 
@@ -71,9 +72,6 @@ void Lockscreen::initScreen()
 void Lockscreen::update()
 {
     Base::update();
-
-    // just in case someone changes that settings somehow
-    profileButtonDisabled = !settings.lockscreen.allowPresetSwitch;
 }
 
 void Lockscreen::redraw()
@@ -147,7 +145,6 @@ void Lockscreen::stop()
         currentMode = m_oldMode;
     }
 
-    profileButtonDisabled = false;
     isLocked = false;
     if (!(!gas || !brems || *gas > 200.f || *brems > 200.f))
     {
@@ -161,6 +158,8 @@ void Lockscreen::stop()
 
 void Lockscreen::buttonPressed(espgui::Button button)
 {
+    if (settings.lockscreen.allowPresetSwitch ||
+        !cpputils::is_in(button, BobbyButton::Profile0, BobbyButton::Profile1, BobbyButton::Profile2, BobbyButton::Profile3))
     Base::buttonPressed(button);
 
     switch (button)

main/displays/menus/aboutmenu.cpp

@@ -15,6 +15,9 @@
 #endif
 
 namespace {
+constexpr char TEXT_ABOUT[] = "About";
+constexpr char TEXT_BACK[] = "Back";
+
 class CurrentVersionText : public virtual espgui::TextInterface
 {
 public:
@@ -33,10 +36,9 @@ public:
 constexpr char TEXT_VERSION[] = "Version: 1.0";
 } // namespace
 
-using namespace espgui;
-
 AboutMenu::AboutMenu()
 {
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, CurrentVersionText,                                         DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, HeapTotal8Text,               StaticFont<2>, DisabledColor, DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, HeapFree8Text,                StaticFont<2>, DisabledColor, DummyAction>>();
@@ -63,7 +65,12 @@ AboutMenu::AboutMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,        SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string AboutMenu::text() const
+{
+    return TEXT_ABOUT;
+}
+
 void AboutMenu::back()
 {
-    switchScreen<SettingsMenu>();
+    espgui::switchScreen<SettingsMenu>();
 }

main/displays/menus/aboutmenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class AboutMenu :
+class AboutMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_ABOUT>
 {
 public:
     AboutMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/batterydebugmenu.cpp

@@ -1,16 +1,55 @@
 #include "batterydebugmenu.h"
 
+// 3rdparty lib includes
+#include <menuitem.h>
+#include <icons/back.h>
+#include <actions/dummyaction.h>
+#include <actions/switchscreenaction.h>
+#include <fmt/core.h>
+
 // local includes
 #include "debugmenu.h"
 #include "accessors/settingsaccessors.h"
-#include "fmt/core.h"
+#include "utils.h"
+#include "icons/settings.h"
+#include "battery.h"
 
-class CurrentBatteryStatusText : public virtual espgui::TextInterface { public: std::string text() const override { return getBatteryPercentageString(); } };
+namespace {
-class CurrentAdvancedBatteryPercentageText : public virtual espgui::TextInterface { public: std::string text() const override { return getBatteryAdvancedPercentageString(); } };
+constexpr char TEXT_BATTERYDEBUG[] = "Bat Debug Menu";
+constexpr char TEXT_BACK[] = "Back";
 
-class BatteryDebugText : public virtual espgui::TextInterface { public: std::string text() const override { return getBatteryDebugString(); } };
+class CurrentBatteryStatusText : public virtual espgui::TextInterface
-class BatteryDebug2Text : public virtual espgui::TextInterface {
+{
-    public: std::string text() const override {
+public:
+    std::string text() const override
+    {
+        return getBatteryPercentageString();
+    }
+};
+
+class CurrentAdvancedBatteryPercentageText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override
+    {
+        return getBatteryAdvancedPercentageString();
+    }
+};
+
+class BatteryDebugText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override
+    {
+        return getBatteryDebugString();
+    }
+};
+
+class BatteryDebug2Text : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override
+    {
         float avgVoltage = 0;
         for (auto &controller : controllers)
         {
@@ -23,12 +62,22 @@ class BatteryDebug2Text : public virtual espgui::TextInterface {
         return fmt::format("{:.0f} {:.0f}W/kmh", avgSpeedKmh, w_per_kmh);
     }
 };
-class BatteryDebug3Text : public virtual espgui::TextInterface { public: std::string text() const override { return fmt::format("{}fA {}bA", fixCurrent(controllers.front.feedback.left.dcLink + controllers.front.feedback.right.dcLink), fixCurrent(controllers.back.feedback.left.dcLink + controllers.back.feedback.right.dcLink)); } };
 
-using namespace espgui;
+class BatteryDebug3Text : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override
+    {
+        return fmt::format("{}fA {}bA",
+                           fixCurrent(controllers.front.feedback.left.dcLink + controllers.front.feedback.right.dcLink),
+                           fixCurrent(controllers.back.feedback.left.dcLink + controllers.back.feedback.right.dcLink));
+    }
+};
+} // namespace
 
 BatteryDebugMenu::BatteryDebugMenu()
 {
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, CurrentBatteryStatusText,                                                 DisabledColor, DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, EmptyText,                                                                DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, BatteryDebugText,                                                         DisabledColor, DummyAction>>();
@@ -38,7 +87,12 @@ BatteryDebugMenu::BatteryDebugMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                                                    SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string BatteryDebugMenu::text() const
+{
+    return TEXT_BATTERYDEBUG;
+}
+
 void BatteryDebugMenu::back()
 {
-    switchScreen<DebugMenu>();
+    espgui::switchScreen<DebugMenu>();
 }

main/displays/menus/batterydebugmenu.h

@@ -1,24 +1,14 @@
 #pragma once
 
-// 3rdparty lib includes
-#include <menuitem.h>
-#include <icons/back.h>
-#include <actions/dummyaction.h>
-#include <actions/switchscreenaction.h>
-
 // Local includes
 #include "displays/bobbymenudisplay.h"
-#include "utils.h"
-#include "icons/settings.h"
-#include "texts.h"
-#include "battery.h"
 
-class BatteryDebugMenu :
+class BatteryDebugMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_BATTERYDEBUG>
 {
 public:
     BatteryDebugMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/batterymenu.cpp

@@ -1,17 +1,42 @@
 #include "batterymenu.h"
 
 // 3rdparty lib includes
+#include <menuitem.h>
+#include <icons/back.h>
+#include <actions/dummyaction.h>
+#include <actions/switchscreenaction.h>
 #include <changevaluedisplay.h>
 #include <textwithvaluehelper.h>
 #include <fmt/core.h>
 
-// local includes
+// Local includes
+#include "utils.h"
+#include "icons/settings.h"
+#include "battery.h"
+#include "selectbatterytypemenu.h"
 #include "displays/bobbychangevaluedisplay.h"
 #include "mainmenu.h"
 #include "displays/calibratevoltagedisplay.h"
 #include "accessors/settingsaccessors.h"
 #include "battery.h"
 
+namespace {
+constexpr char TEXT_BATTERY[] = "Battery";
+constexpr char TEXT_CELL_SERIES[] = "Cells (Series)";
+constexpr char TEXT_CELL_PARALLEL[] = "Cells (Parallel)";
+constexpr char TEXT_SELECT_CELL_TYPE[] = "Select Cell Type";
+constexpr char TEXT_CELL_TYPE[] = "Cell Type";
+constexpr char TEXT_BATTERY_CALIBRATE[] = "Calibrate Voltages";
+constexpr char TEXT_BATTERY_TYPE_22P[] = "22P cells";
+constexpr char TEXT_BATTERY_TYPE_HG2[] = "HG2 cells";
+constexpr char TEXT_BATTERY_TYPE_MH1[] = "MH1 cells";
+constexpr char TEXT_BATTERY_TYPE_VTC5[] = "VTC5 cells";
+constexpr char TEXT_BATTERY_TYPE_BAK_25R[] = "BAK / 25R cells";
+constexpr char TEXT_BATTERY_WHKM[] = "Wh per km";
+constexpr char TEXT_BATTERY_APPLYCALIB[] = "Apply calibration";
+constexpr char TEXT_VOLTAGECALIBRATION_RESET[] = "Reset calibration";
+constexpr char TEXT_BACK[] = "Back";
+
 class CurrentBatteryStatusText : public virtual espgui::TextInterface { public: std::string text() const override { return getBatteryPercentageString(); } };
 
 using BatteryCellSeriesChangeScreen = espgui::makeComponent<
@@ -37,8 +62,27 @@ using BatteryWHperKMChangeScreen = espgui::makeComponent<
     espgui::ConfirmActionInterface<espgui::SwitchScreenAction<BatteryMenu>>,
     espgui::BackActionInterface<espgui::SwitchScreenAction<BatteryMenu>>
 >;
+} // namespace
 
-using namespace espgui;
+BatteryMenu::BatteryMenu()
+{
+    using namespace espgui;
+
+    constructMenuItem<makeComponent<MenuItem, CurrentBatteryStatusText,                                                 DisabledColor, DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, EmptyText,                                                                DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_CELL_SERIES, BatterySeriesCellsAccessor>,        SwitchScreenAction<BatteryCellSeriesChangeScreen>>>();
+    constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_CELL_PARALLEL, BatteryParallelCellsAccessor>,    SwitchScreenAction<BatteryCellParallelChangeScreen>>>();
+    constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_BATTERY_WHKM, BatteryWHperKMAccessor>,           SwitchScreenAction<BatteryWHperKMChangeScreen>>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SELECT_CELL_TYPE>,                                        SwitchScreenAction<BatteryTypeMenu>>>();
+    constructMenuItem<makeComponent<MenuItem, EmptyText,                                                                DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_CALIBRATE>,                                       SwitchScreenAction<CalibrateVoltageDisplay>, StaticMenuItemIcon<&bobbyicons::settings>>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                                                    SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
+}
+
+std::string BatteryMenu::text() const
+{
+    return TEXT_BATTERY;
+}
 
 void BatteryMenu::start()
 {
@@ -61,20 +105,7 @@ void BatteryMenu::redraw()
     m_doubleProgressBarBatPercentage.redraw(batPercent, battery::bootBatPercentage);
 }
 
-BatteryMenu::BatteryMenu()
-{
-    constructMenuItem<makeComponent<MenuItem, CurrentBatteryStatusText,                                                 DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, EmptyText,                                                                DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_CELL_SERIES, BatterySeriesCellsAccessor>,        SwitchScreenAction<BatteryCellSeriesChangeScreen>>>();
-    constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_CELL_PARALLEL, BatteryParallelCellsAccessor>,    SwitchScreenAction<BatteryCellParallelChangeScreen>>>();
-    constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_BATTERY_WHKM, BatteryWHperKMAccessor>,           SwitchScreenAction<BatteryWHperKMChangeScreen>>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SELECT_CELL_TYPE>,                                        SwitchScreenAction<BatteryTypeMenu>>>();
-    constructMenuItem<makeComponent<MenuItem, EmptyText,                                                                DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_CALIBRATE>,                                       SwitchScreenAction<CalibrateVoltageDisplay>, StaticMenuItemIcon<&bobbyicons::settings>>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                                                    SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
-}
-
 void BatteryMenu::back()
 {
-    switchScreen<MainMenu>();
+    espgui::switchScreen<MainMenu>();
 }

main/displays/menus/batterymenu.h

@@ -1,32 +1,22 @@
 #pragma once
 
-// 3rdparty lib includes
+// local includes
-#include <menuitem.h>
-#include <icons/back.h>
-#include <actions/dummyaction.h>
-#include <actions/switchscreenaction.h>
-
-// Local includes
 #include "displays/bobbymenudisplay.h"
-#include "utils.h"
-#include "icons/settings.h"
-#include "texts.h"
-#include "battery.h"
-#include "selectbatterytypemenu.h"
 #include "widgets/doubleprogressbar.h"
 
-class BatteryMenu :
+class BatteryMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_BATTERY>
 {
     using Base = BobbyMenuDisplay;
 
 public:
     BatteryMenu();
 
+    std::string text() const override;
+
     void start() override;
     void redraw() override;
     void back() override;
+
 private:
     bobbygui::DoubleProgressBar m_doubleProgressBarBatPercentage{75, 68, 90, 24, 0, 100, TFT_RED, TFT_GREEN};
 };

main/displays/menus/blesettingsmenu.cpp

@@ -1,30 +1,39 @@
 #include "blesettingsmenu.h"
 
+// 3rdparty lib includes
+#include "actions/dummyaction.h"
+#include "actions/switchscreenaction.h"
+#include "icons/back.h"
+
 // local includes
 #include "accessors/settingsaccessors.h"
-#include "actions/dummyaction.h"
-#include "actions/switchscreenaction.h"
-#include "actions/toggleboolaction.h"
 #include "bletexthelpers.h"
-#include "checkboxicon.h"
 #include "displays/menus/settingsmenu.h"
-#include "icons/back.h"
+#include "bobbycheckbox.h"
-#include "texts.h"
 
 #ifdef FEATURE_BLE
-
+namespace {
-using namespace espgui;
+constexpr char TEXT_BLESETTINGS[] = "BLE settings";
+constexpr char TEXT_BLEENABLED[] = "BLE enabled";
+constexpr char TEXT_BACK[] = "Back";
+} // namespace
 
 BleSettingsMenu::BleSettingsMenu()
 {
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLEENABLED>, ToggleBoolAction, CheckboxIcon, BleEnabledAccessor>>();
+    using namespace espgui;
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLEENABLED>, BobbyCheckbox, BleEnabledAccessor>>();
     constructMenuItem<makeComponent<MenuItem, BleServerPeerDevicesText,    DisabledColor, DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, BleCharacSubscribedText,     DisabledColor, DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,       SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string BleSettingsMenu::text() const
+{
+    return TEXT_BLESETTINGS;
+}
+
 void BleSettingsMenu::back()
 {
-    switchScreen<SettingsMenu>();
+    espgui::switchScreen<SettingsMenu>();
 }
 #endif

main/displays/menus/blesettingsmenu.h

@@ -2,16 +2,16 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
 #ifdef FEATURE_BLE
 
-class BleSettingsMenu :
+class BleSettingsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_BLESETTINGS>
 {
 public:
     BleSettingsMenu();
+
+    std::string text() const override;
+
     void back() override;
 };
 #endif

main/displays/menus/bluetoothsettingsmenu.h

@@ -19,7 +19,6 @@
 #include "bluetoothtexthelpers.h"
 #include "accessors/settingsaccessors.h"
 #include "icons/back.h"
-#include "texts.h"
 
 using namespace espgui;
 using namespace bluetoothtexthelpers;

main/displays/menus/bmsmenu.cpp

@@ -13,7 +13,6 @@
 #include "actions/switchscreenaction.h"
 #include "bluetoothtexthelpers.h"
 #include "icons/back.h"
-#include "texts.h"
 #include "displays/menus/mainmenu.h"
 
 using namespace espgui;

main/displays/menus/bmsmenu.h

@@ -3,14 +3,13 @@
 #if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class BmsMenu :
+class BmsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_BMS>
 {
 public:
     BmsMenu();
+
+    std::string text() const override { return TEXT_BMS; }
     void back() override;
 };
 #endif

main/displays/menus/boardcomputerhardwaresettingsmenu.cpp

@@ -5,9 +5,7 @@
 #include <changevaluedisplay.h>
 #include <actions/dummyaction.h>
 #include <actions/switchscreenaction.h>
-#include <actions/toggleboolaction.h>
 #include <icons/back.h>
-#include <checkboxicon.h>
 #include <textwithvaluehelper.h>
 
 // local includes
@@ -21,6 +19,25 @@
 #include "displays/menus/settingsmenu.h"
 
 namespace {
+constexpr char TEXT_BOARDCOMPUTERHARDWARESETTINGS[] = "Boardcomputer H/W settings";
+constexpr char TEXT_LOCKSCREENSETTINGS[] = "Lockscreen Settings";
+constexpr char TEXT_CALIBRATE[] = "Calibrate";
+constexpr char TEXT_SAMPLECOUNT[] = "sampleCount";
+constexpr char TEXT_GASMIN[] = "gasMin";
+constexpr char TEXT_GASMAX[] = "gasMax";
+constexpr char TEXT_BREMSMIN[] = "bremsMin";
+constexpr char TEXT_BREMSMAX[] = "bremsMax";
+constexpr char TEXT_DPADDEBOUNCE[] = "dpadDebounce";
+constexpr char TEXT_GAMETRAKCALIBRATE[] = "Gametrak calibrate";
+constexpr char TEXT_SETGAMETRAKXMIN[] = "Set gametrakXMin";
+constexpr char TEXT_SETGAMETRAKXMAX[] = "Set gametrakXMax";
+constexpr char TEXT_SETGAMETRAKYMIN[] = "Set gametrakYMin";
+constexpr char TEXT_SETGAMETRAKYMAX[] = "Set gametrakYMax";
+constexpr char TEXT_SETGAMETRAKDISTMIN[] = "Set gametrakDistMin";
+constexpr char TEXT_SETGAMETRAKDISTMAX[] = "Set gametrakDistMax";
+constexpr char TEXT_TIMERS[] = "Timers";
+constexpr char TEXT_BACK[] = "Back";
+
 struct GasText : public virtual espgui::TextInterface
 {
 public:
@@ -183,6 +200,11 @@ BoardcomputerHardwareSettingsMenu::BoardcomputerHardwareSettingsMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                                        SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
 }
 
+std::string BoardcomputerHardwareSettingsMenu::text() const
+{
+    return TEXT_BOARDCOMPUTERHARDWARESETTINGS;
+}
+
 void BoardcomputerHardwareSettingsMenu::back()
 {
     switchScreen<SettingsMenu>();

main/displays/menus/boardcomputerhardwaresettingsmenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class BoardcomputerHardwareSettingsMenu :
+class BoardcomputerHardwareSettingsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_BOARDCOMPUTERHARDWARESETTINGS>
 {
 public:
     BoardcomputerHardwareSettingsMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/buzzermenu.cpp

@@ -4,8 +4,6 @@
 #include "changevaluedisplay.h"
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
-#include "actions/toggleboolaction.h"
-#include "checkboxicon.h"
 #include "icons/back.h"
 
 // local includes
@@ -14,8 +12,21 @@
 #include "globals.h"
 #include "accessors/settingsaccessors.h"
 #include "displays/menus/settingsmenu.h"
+#include "bobbycheckbox.h"
 
 namespace {
+constexpr char TEXT_BUZZER[] = "Buzzer";
+constexpr char TEXT_FRONTFREQ[] = "Front freq";
+constexpr char TEXT_FRONTPATTERN[] = "Front pattern";
+constexpr char TEXT_BACKFREQ[] = "Back freq";
+constexpr char TEXT_BACKPATTERN[] = "Back pattern";
+constexpr char TEXT_REVERSEBEEP[] = "Reverse beep";
+constexpr char TEXT_REVERSEBEEPFREQ0[] = "Reverse beep freq0";
+constexpr char TEXT_REVERSEBEEPFREQ1[] = "Reverse beep freq1";
+constexpr char TEXT_REVERSEBEEPDURATION0[] = "Reverse beep duration0";
+constexpr char TEXT_REVERSEBEEPDURATION1[] = "Reverse beep duration1";
+constexpr char TEXT_BACK[] = "Back";
+
 struct FrontFreqAccessor : public espgui::RefAccessor<uint8_t> { uint8_t &getRef() const override { return controllers.front.command.buzzer.freq; } };
 using FrontFreqChangeScreen = espgui::makeComponent<
     BobbyChangeValueDisplay<uint8_t>,
@@ -90,7 +101,7 @@ BuzzerMenu::BuzzerMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTPATTERN>,         SwitchScreenAction<FrontPatternChangeScreen>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKFREQ>,             SwitchScreenAction<BackFreqChangeScreen>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKPATTERN>,          SwitchScreenAction<BackPatternChangeScreen>>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEP>,          ToggleBoolAction, CheckboxIcon, ReverseBeepAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEP>,          BobbyCheckbox, ReverseBeepAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ0>,     SwitchScreenAction<ReverseBeepFreq0ChangeScreen>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ1>,     SwitchScreenAction<ReverseBeepFreq1ChangeScreen>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPDURATION0>, SwitchScreenAction<ReverseBeepDuration0ChangeScreen>>>();
@@ -98,6 +109,11 @@ BuzzerMenu::BuzzerMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string BuzzerMenu::text() const
+{
+    return TEXT_BUZZER;
+}
+
 void BuzzerMenu::back()
 {
     switchScreen<SettingsMenu>();

main/displays/menus/buzzermenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class BuzzerMenu :
+class BuzzerMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_BUZZER>
 {
 public:
     BuzzerMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/cloudsettingsmenu.cpp

@@ -5,9 +5,7 @@
 #include "menuitem.h"
 #include "changevaluedisplay.h"
 #include "actions/switchscreenaction.h"
-#include "actions/toggleboolaction.h"
 #include "actions/dummyaction.h"
-#include "checkboxicon.h"
 #include "icons/back.h"
 
 // local includes
@@ -16,9 +14,16 @@
 #include "accessors/settingsaccessors.h"
 #include "cloud.h"
 #include "displays/menus/settingsmenu.h"
+#include "bobbycheckbox.h"
 
 #ifdef FEATURE_CLOUD
 namespace {
+constexpr char TEXT_CLOUDSETTINGS[] = "Cloud settings";
+constexpr char TEXT_CLOUDENABLED[] = "Cloud enabled";
+constexpr char TEXT_CLOUDTRANSMITTIMEOUT[] = "Transmit timeout";
+constexpr char TEXT_CLOUDCOLLECTRATE[] = "Cloud collect rate";
+constexpr char TEXT_CLOUDSENDRATE[] = "Cloud send rate";
+constexpr char TEXT_BACK[] = "Back";
 
 using CloudTransmitTimeoutChangeScreen = espgui::makeComponent<
     BobbyChangeValueDisplay<int16_t>,
@@ -58,7 +63,7 @@ using namespace espgui;
 
 CloudSettingsMenu::CloudSettingsMenu()
 {
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CLOUDENABLED>,         ToggleBoolAction, CheckboxIcon, CloudEnabledAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CLOUDENABLED>,         BobbyCheckbox, CloudEnabledAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CLOUDTRANSMITTIMEOUT>, SwitchScreenAction<CloudTransmitTimeoutChangeScreen>>>();
     constructMenuItem<makeComponent<MenuItem, CloudCreatedText,                      DisabledColor, DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, CloudStartedText,                      DisabledColor, DummyAction>>();
@@ -69,6 +74,11 @@ CloudSettingsMenu::CloudSettingsMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string CloudSettingsMenu::text() const
+{
+    return TEXT_CLOUDSETTINGS;
+}
+
 void CloudSettingsMenu::back()
 {
     switchScreen<SettingsMenu>();

main/displays/menus/cloudsettingsmenu.h

@@ -2,16 +2,15 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
 #ifdef FEATURE_CLOUD
-class CloudSettingsMenu :
+class CloudSettingsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_CLOUDSETTINGS>
 {
 public:
     CloudSettingsMenu();
 
+    std::string text() const override;
+
     void back() override;
 };
 #endif

main/displays/menus/commanddebugmenu.h

@@ -8,30 +8,30 @@
 #include "actions/dummyaction.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
-#include "texts.h"
 #include "debugtexthelpers.h"
 
-using namespace espgui;
-
-namespace {
 template<const char *Ttext, typename Ttexts>
 class CommandDebugMenu :
     public BobbyMenuDisplay,
-    public StaticText<Ttext>,
+    public espgui::StaticText<Ttext>,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>
+    public espgui::BackActionInterface<espgui::SwitchScreenAction<DebugMenu>>
 {
 public:
     CommandDebugMenu()
     {
+        using namespace espgui;
         constructMenuItem<makeComponent<MenuItem, typename Ttexts::BuzzerFreqText,    DisabledColor, DummyAction>>();
         constructMenuItem<makeComponent<MenuItem, typename Ttexts::BuzzerPatternText, DisabledColor, DummyAction>>();
         constructMenuItem<makeComponent<MenuItem, typename Ttexts::PoweroffText,      DisabledColor, DummyAction>>();
         constructMenuItem<makeComponent<MenuItem, typename Ttexts::LedText,           DisabledColor, DummyAction>>();
         constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
     }
+
+private:
+    static constexpr char TEXT_BACK[] = "Back";
 };
 
+constexpr char TEXT_FRONTCOMMAND[] = "Front command";
+constexpr char TEXT_BACKCOMMAND[] = "Back command";
 using FrontCommandDebugMenu = CommandDebugMenu<TEXT_FRONTCOMMAND, FrontTexts>;
 using BackCommandDebugMenu = CommandDebugMenu<TEXT_BACKCOMMAND, BackTexts>;
-
-} // namespace

main/displays/menus/controllerhardwaresettingsmenu.cpp

@@ -5,9 +5,7 @@
 
 // 3rdparty lib includes
 #include "changevaluedisplay.h"
-#include "actions/toggleboolaction.h"
 #include "actions/switchscreenaction.h"
-#include "checkboxicon.h"
 #include "icons/back.h"
 
 // local includes
@@ -18,8 +16,24 @@
 #include "displays/menus/enablemenu.h"
 #include "displays/menus/invertmenu.h"
 #include "displays/menus/settingsmenu.h"
+#include "bobbycheckbox.h"
 
 namespace {
+constexpr char TEXT_CONTROLLERHARDWARESETTINGS[] = "Controller H/W settings";
+constexpr char TEXT_WHEELDIAMETERMM[] = "Wheel diameter (mm)";
+constexpr char TEXT_WHEELDIAMETERINCH[] = "Wheel diameter (inch)";
+constexpr char TEXT_NUMMAGNETPOLES[] = "Num magnet poles";
+constexpr char TEXT_SETENABLED[] = "Set enabled";
+constexpr char TEXT_SETINVERTED[] = "Set inverted";
+constexpr char TEXT_SWAPFRONTBACK[] = "Swap front/back";
+#ifdef FEATURE_CAN
+constexpr char TEXT_FRONTSENDCAN[] = "Front send CAN";
+constexpr char TEXT_BACKSENDCAN[] = "Back send CAN";
+constexpr char TEXT_CANTRANSMITTIMEOUT[] = "CanTransmitTimeout";
+constexpr char TEXT_CANRECEIVETIMEOUT[] = "CanReceiveTimeout";
+#endif
+constexpr char TEXT_BACK[] = "Back";
+
 using WheelDiameterMmChangeScreen = espgui::makeComponent<
     BobbyChangeValueDisplay<int16_t>,
     espgui::StaticText<TEXT_WHEELDIAMETERMM>,
@@ -60,26 +74,30 @@ using CanReceiveTimeoutChangeScreen = espgui::makeComponent<
 #endif
 } // namespace
 
-using namespace espgui;
-
 ControllerHardwareSettingsMenu::ControllerHardwareSettingsMenu()
 {
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETENABLED>,        SwitchScreenAction<EnableMenu>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETINVERTED>,       SwitchScreenAction<InvertMenu>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERMM>,   SwitchScreenAction<WheelDiameterMmChangeScreen>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERINCH>, SwitchScreenAction<WheelDiameterInchChangeScreen>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_NUMMAGNETPOLES>,    SwitchScreenAction<NumMagnetPolesChangeScreen>>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SWAPFRONTBACK>,     ToggleBoolAction, CheckboxIcon, SwapFrontBackAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SWAPFRONTBACK>,     BobbyCheckbox, SwapFrontBackAccessor>>();
 #ifdef FEATURE_CAN
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTSENDCAN>,       ToggleBoolAction, CheckboxIcon, SendFrontCanCmdAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTSENDCAN>,       BobbyCheckbox, SendFrontCanCmdAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKSENDCAN>,        ToggleBoolAction, CheckboxIcon, SendBackCanCmdAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKSENDCAN>,        BobbyCheckbox, SendBackCanCmdAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CANTRANSMITTIMEOUT>, SwitchScreenAction<CanTransmitTimeoutChangeScreen>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CANRECEIVETIMEOUT>,  SwitchScreenAction<CanReceiveTimeoutChangeScreen>>>();
 #endif
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string ControllerHardwareSettingsMenu::text() const
+{
+    return TEXT_CONTROLLERHARDWARESETTINGS;
+}
+
 void ControllerHardwareSettingsMenu::back()
 {
-    switchScreen<SettingsMenu>();
+    espgui::switchScreen<SettingsMenu>();
 }

main/displays/menus/controllerhardwaresettingsmenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class ControllerHardwareSettingsMenu :
+class ControllerHardwareSettingsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_CONTROLLERHARDWARESETTINGS>
 {
 public:
     ControllerHardwareSettingsMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/crashmenu.cpp

@@ -1,20 +1,35 @@
 #include "crashmenu.h"
 
+// 3rdparty lib includes
+#include "actions/switchscreenaction.h"
+#include "icons/back.h"
+
 // local includes
 #include "actions/assertaction.h"
 #include "actions/dividebyzeroaction.h"
-#include "actions/switchscreenaction.h"
 #include "displays/menus/settingsmenu.h"
-#include "icons/back.h"
+
+namespace {
+constexpr char TEXT_CRASHMENU[] = "Crash Menu";
+constexpr char TEXT_CRASH_ASSERT[] = "assert(0)";
+constexpr char TEXT_CRASH_DIVZERO[] = "42 / 0";
+constexpr char TEXT_BACK[] = "Back";
+} // namespace
 
 CrashMenu::CrashMenu()
 {
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CRASH_ASSERT>,    AssertAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CRASH_DIVZERO>,   DivideByZeroAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,            SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string CrashMenu::text() const
+{
+    return TEXT_CRASHMENU;
+}
+
 void CrashMenu::back()
 {
-    switchScreen<SettingsMenu>();
+    espgui::switchScreen<SettingsMenu>();
 }

main/displays/menus/crashmenu.h

@@ -2,15 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-using namespace espgui;
+class CrashMenu : public BobbyMenuDisplay
-
-class CrashMenu :
-    public BobbyMenuDisplay,
-    public StaticText<TEXT_CRASHMENU>
 {
 public:
     CrashMenu();
+
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/debugmenu.cpp

@@ -4,8 +4,6 @@
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
 #include "actions/dummyaction.h"
-#include "actions/toggleboolaction.h"
-#include "checkboxicon.h"
 #include "icons/back.h"
 #include "accessors/settingsaccessors.h"
 #include <screenmanager.h>
@@ -28,30 +26,43 @@
 #include "displays/menus/dynamicdebugmenu.h"
 #include "displays/menus/mainmenu.h"
 #include "displays/menus/batterydebugmenu.h"
-#include "bobbyerrorhandler.h"
+#include "bobbycheckbox.h"
 
 namespace {
-class AlertAction : public espgui::MenuItem
+constexpr char TEXT_DEBUG[] = "Debug";
-{
+constexpr char TEXT_TASKMANAGER[] = "Taskmanager";
-public:
+constexpr char TEXT_QRCODE_DEBUG[] = "QR Debug";
-    std::string text() const override { return "Open popup"; }
+constexpr char TEXT_BATTERYDEBUG[] = "Bat Debug Menu";
-    void triggered() override
+constexpr char TEXT_TOGGLECLOUDDEBUG[] = "Cloud Debug";
-    {
+//constexpr char TEXT_FRONTCOMMAND[] = "Front command";
-        BobbyErrorHandler{}.errorOccured("Das\nist\nein sehr langer text, der nicht in eine zeile passt");
+//constexpr char TEXT_BACKCOMMAND[] = "Back command";
-    }
+//constexpr char TEXT_FRONTLEFTCOMMAND[] = "Front left command";
-};
+//constexpr char TEXT_FRONTRIGHTCOMMAND[] = "Front right command";
+//constexpr char TEXT_BACKLEFTCOMMAND[] = "Back left command";
+//constexpr char TEXT_BACKRIGHTCOMMAND[] = "Back right command";
+//constexpr char TEXT_FRONTFEEDBACK[] = "Front feedback";
+//constexpr char TEXT_BACKFEEDBACK[] = "Back feedback";
+//constexpr char TEXT_FRONTLEFTFEEDBACK[] = "Front left feedback";
+//constexpr char TEXT_FRONTRIGHTFEEDBACK[] = "Front right feedback";
+//constexpr char TEXT_BACKLEFTFEEDBACK[] = "Back left feedback";
+//constexpr char TEXT_BACKRIGHTFEEDBACK[] = "Back right feedback";
+constexpr char TEXT_LOADSETTINGS[] = "Load settings (old)";
+constexpr char TEXT_SAVESETTINGS[] = "Save settings (old)";
+constexpr char TEXT_ERASENVS[] = "Erase NVS (old)";
+constexpr char TEXT_DYNAMICMENU[] = "GUI experiments";
+constexpr char TEXT_BACK[] = "Back";
 } // namespace
 
-using namespace espgui;
-
 DebugMenu::DebugMenu()
 {
-    constructMenuItem<AlertAction>();
+    using namespace espgui;
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TASKMANAGER>,         SwitchScreenAction<TaskmanagerMenu>>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TASKMANAGER>,          SwitchScreenAction<TaskmanagerMenu>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_QRCODE_DEBUG>,         SwitchScreenAction<QrCodeDebugDisplay>>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LOADSETTINGS>,         LoadSettingsAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERYDEBUG>,         SwitchScreenAction<BatteryDebugMenu>, StaticMenuItemIcon<&bobbyicons::battery>>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SAVESETTINGS>,         SaveSettingsAction>>();
+#ifdef FEATURE_UDPCLOUD
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ERASENVS>,             EraseNvsAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TOGGLECLOUDDEBUG>,     BobbyCheckbox, CloudDebugEnableAccessor>>();
+#endif
+    constructMenuItem<makeComponent<MenuItem, LastRebootReasonText,                  StaticFont<2>, DisabledColor, DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, EmptyText,                             DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTCOMMAND>,         SwitchScreenAction<FrontCommandDebugMenu>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKCOMMAND>,          SwitchScreenAction<BackCommandDebugMenu>>>();
@@ -64,22 +75,23 @@ DebugMenu::DebugMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTFEEDBACK>,        SwitchScreenAction<FrontFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKFEEDBACK>,         SwitchScreenAction<BackFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>();
     constructMenuItem<makeComponent<MenuItem, EmptyText,                             DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, LastRebootReasonText,                  StaticFont<2>, DisabledColor, DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, EmptyText,                             DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLEFTFEEDBACK>,    SwitchScreenAction<FrontLeftMotorFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTRIGHTFEEDBACK>,   SwitchScreenAction<FrontRightMotorFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKLEFTFEEDBACK>,     SwitchScreenAction<BackLeftMotorFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKRIGHTFEEDBACK>,    SwitchScreenAction<BackRightMotorFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>();
     constructMenuItem<makeComponent<MenuItem, EmptyText,                             DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LOADSETTINGS>,         LoadSettingsAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SAVESETTINGS>,         SaveSettingsAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ERASENVS>,             EraseNvsAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICMENU>,          SwitchScreenAction<DynamicDebugMenu>>>();
-    constructMenuItem<makeComponent<MenuItem, EmptyText,                             DummyAction>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERYDEBUG>,         SwitchScreenAction<BatteryDebugMenu>, StaticMenuItemIcon<&bobbyicons::battery>>>();
-#ifdef FEATURE_UDPCLOUD
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TOGGLECLOUDDEBUG>,     ToggleBoolAction, CheckboxIcon, CloudDebugEnableAccessor>>();
-#endif
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string DebugMenu::text() const
+{
+    return TEXT_DEBUG;
+}
+
 void DebugMenu::back()
 {
     switchScreen<MainMenu>();

main/displays/menus/debugmenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class DebugMenu :
+class DebugMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_DEBUG>
 {
 public:
     DebugMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/defaultmodesettingsmenu.cpp

@@ -3,10 +3,8 @@
 // 3rdparty lib includes
 #include <changevaluedisplay.h>
 #include <menuitem.h>
-#include <actions/toggleboolaction.h>
 #include <actions/switchscreenaction.h>
 #include <actions/dummyaction.h>
-#include <checkboxicon.h>
 #include <icons/back.h>
 #include <textwithvaluehelper.h>
 
@@ -17,8 +15,40 @@
 #include "accessors/settingsaccessors.h"
 #include "displays/menus/handbremssettingsmenu.h"
 #include "displays/menus/modessettingsmenu.h"
+#include "bobbycheckbox.h"
 
 namespace {
+constexpr char TEXT_DEFAULTMODESETTIGNS[] = "Default mode settings";
+constexpr char TEXT_DEFAULTMODESETTINGS[] = "Default mode settings";
+constexpr char TEXT_MODELMODE[] = "Model mode";
+constexpr char TEXT_HYBRIDMODE[] = "Hybrid mode";
+constexpr char TEXT_SQUAREGAS[] = "Square gas";
+constexpr char TEXT_SQUAREBREMS[] = "Square brems";
+constexpr char TEXT_ENABLESMOOTHINGUP[] = "Enable up smoothing";
+constexpr char TEXT_ENABLESMOOTHINGDOWN[] = "Enable down smoothing";
+constexpr char TEXT_ENABLEFWSMOOTHINGUP[] = "Enable fw up smoothing";
+constexpr char TEXT_ENABLEFWSMOOTHINGDOWN[] = "Enable fw down smoothing";
+constexpr char TEXT_FWSMOOTHING_LIMIT[] = "Fw smooth lower limit";
+constexpr char TEXT_SMOOTHINGVAL[] = "Smoothing";
+constexpr char TEXT_FRONTPERCENTAGE[] = "Front %";
+constexpr char TEXT_BACKPERCENTAGE[] = "Back %";
+constexpr char TEXT_ADDSCHWELLE[] = "Add/Sub Lim";
+constexpr char TEXT_SUBGASVAL[] = "Add Gas";
+constexpr char TEXT_SUBBRAKEVAL[] = "Add Brake";
+constexpr char TEXT_ADDGASVAL[] = "Sub Gas";
+constexpr char TEXT_ADDBRAKEVAL[] = "Sub Brake";
+constexpr char TEXT_HYBRIDENABLE[] = "Enable Hybrid mode";
+constexpr char TEXT_HYBRIDACTIVATIONLIMIT[] = "Hybrid activation-limit";
+constexpr char TEXT_HYBRIDDEACTIVATIONLIMIT[] = "Hybrid deactivation-limit";
+constexpr char TEXT_LIMITS_TO_NEAR[] = "Hybrid limits too near (>20)";
+constexpr char TEXT_HANDBREMSE_ENABLE[] = "Enable Handbremse";
+constexpr char TEXT_HANDBREMSE_AUTOMATIC[] = "Automatic Handbremse";
+constexpr char TEXT_HANDBREMSE_VISUALIZE[] = "Visualize Handbremse";
+constexpr char TEXT_HANDBREMSE_MODE[] = "Handbrems Mode";
+constexpr char TEXT_HANDBREMSE_TRIGGERTIMEOUT[] = "Handbrems Timeout";
+constexpr char TEXT_HANDBREMSE[] = "Handbremse";
+constexpr char TEXT_BACK[] = "Back";
+
 using DefaultModeModelModeChangeDisplay = espgui::makeComponent<
     BobbyChangeValueDisplay<UnifiedModelMode>,
     espgui::StaticText<TEXT_MODELMODE>,
@@ -120,13 +150,13 @@ DefaultModeSettingsMenu::DefaultModeSettingsMenu()
     if (diff < 20) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LIMITS_TO_NEAR>, StaticFont<2>, StaticColor<TFT_RED>, DummyAction>>(); }
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MODELMODE>,          SwitchScreenAction<DefaultModeModelModeChangeDisplay>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HYBRIDMODE>,         SwitchScreenAction<DefaultModeHybridModelModeChangeDisplay>>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREGAS>,          ToggleBoolAction, CheckboxIcon,  DefaultModeSquareGasAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREGAS>,          BobbyCheckbox,  DefaultModeSquareGasAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREBREMS>,        ToggleBoolAction, CheckboxIcon,  DefaultModeSquareBremsAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREBREMS>,        BobbyCheckbox,  DefaultModeSquareBremsAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHINGUP>,    ToggleBoolAction, CheckboxIcon,  DefaultModeEnableSmoothingUpAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHINGUP>,    BobbyCheckbox,  DefaultModeEnableSmoothingUpAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHINGDOWN>,    ToggleBoolAction, CheckboxIcon,  DefaultModeEnableSmoothingDownAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHINGDOWN>,    BobbyCheckbox,  DefaultModeEnableSmoothingDownAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFWSMOOTHINGUP>,  ToggleBoolAction, CheckboxIcon,  DefaultModeEnableFieldWeakSmoothingUpAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFWSMOOTHINGUP>,  BobbyCheckbox,  DefaultModeEnableFieldWeakSmoothingUpAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFWSMOOTHINGDOWN>,  ToggleBoolAction, CheckboxIcon,  DefaultModeEnableFieldWeakSmoothingDownAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFWSMOOTHINGDOWN>,  BobbyCheckbox,  DefaultModeEnableFieldWeakSmoothingDownAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HYBRIDENABLE>,          ToggleBoolAction, CheckboxIcon,  DefaultModeEnableHybridAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HYBRIDENABLE>,          BobbyCheckbox,  DefaultModeEnableHybridAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE>,            SwitchScreenAction<HandbremsSettingsMenu>>>();
     constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_FWSMOOTHING_LIMIT, DefaultModeEnableFieldWeakSmoothingLowerLimitAccessor>, SwitchScreenAction<DefaultModeFwSmoothingLowerLimitChangeDisplay>>>();
     constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_SMOOTHINGVAL, DefaultModeSmoothingAccessor>,                     SwitchScreenAction<DefaultModeSmoothingChangeDisplay>>>();
@@ -142,6 +172,11 @@ DefaultModeSettingsMenu::DefaultModeSettingsMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                                                                    SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string DefaultModeSettingsMenu::text() const
+{
+    return TEXT_DEFAULTMODESETTIGNS;
+}
+
 void DefaultModeSettingsMenu::back()
 {
     switchScreen<ModesSettingsMenu>();

main/displays/menus/defaultmodesettingsmenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class DefaultModeSettingsMenu :
+class DefaultModeSettingsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_DEFAULTMODESETTIGNS>
 {
 public:
     DefaultModeSettingsMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/demosmenu.cpp

@@ -13,10 +13,18 @@
 // local includes
 #include "utils.h"
 
-using namespace espgui;
+namespace {
+constexpr char TEXT_DEMOS[] = "Demos";
+constexpr char TEXT_STARFIELD[] = "Starfield";
+constexpr char TEXT_PINGPONG[] = "PingPong";
+constexpr char TEXT_SPIRO[] = "Spiro";
+constexpr char TEXT_GAMEOFLIFE[] = "GameOfLife";
+constexpr char TEXT_BACK[] = "Back";
+} // namespace
 
 DemosMenu::DemosMenu()
 {
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STARFIELD>,  SwitchScreenAction<StarfieldDisplay>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PINGPONG>,   SwitchScreenAction<PingPongDisplay>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SPIRO>,      SwitchScreenAction<SpiroDisplay>>>();
@@ -24,7 +32,12 @@ DemosMenu::DemosMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,       SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string DemosMenu::text() const
+{
+    return TEXT_DEMOS;
+}
+
 void DemosMenu::back()
 {
-    switchScreen<MainMenu>();
+    espgui::switchScreen<MainMenu>();
 }

main/displays/menus/demosmenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class DemosMenu :
+class DemosMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_DEMOS>
 {
 public:
     DemosMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/dynamicdebugmenu.cpp

@@ -0,0 +1,203 @@
+#include "dynamicdebugmenu.h"
+
+// system includes
+#include <string>
+#include <optional>
+
+// 3rdparty lib includes
+#include <espchrono.h>
+#include <fmt/core.h>
+#include <randomutils.h>
+#include <esprandom.h>
+#include <menuitem.h>
+#include <actions/dummyaction.h>
+#include <icons/back.h>
+#include <changevaluedisplay.h>
+#include <changevaluedisplay_bool.h>
+
+// local includes
+#include "displays/bobbychangevaluedisplay.h"
+#include "utils.h"
+#include "icons/lock.h"
+#include "bobbycheckbox.h"
+#include "bobbyerrorhandler.h"
+
+using namespace espgui;
+
+namespace {
+constexpr char TEXT_FONTTEST0[] = "Rich&1Text&2Renderer";
+constexpr char TEXT_FONTTEST1[] = "Test&ssmall&mmedium";
+constexpr char TEXT_FONTTEST2[] = "Test&ssmall&frestored";
+constexpr char TEXT_FONTTEST3[] = "Test&s&3small&4with&6color&7grey";
+constexpr char TEXT_DUMMYITEM[] = "Dummy item";
+constexpr char TEXT_DYNAMICCOLOR[] = "Dynamic color";
+constexpr char TEXT_DYNAMICFONT[] = "Dynamic font";
+constexpr char TEXT_DYNAMICICON[] = "Dynamic icon";
+constexpr char TEXT_STATICICON[] = "Static icon";
+constexpr char TEXT_LOCKTOGGLE[] = "Lock toggle";
+constexpr char TEXT_DEBUGTOGGLE[] = "Toggle";
+constexpr char TEXT_DEBUGTOGGLEMENU[] = "Toggle (with menu)";
+constexpr char TEXT_OPENPOPUP[] = "Open popup";
+constexpr char TEXT_BACK[] = "Back";
+
+bool toggleLocked{};
+bool toggle{};
+
+class RandomColor : public virtual ColorInterface
+{
+public:
+    int color() const override;
+
+private:
+    mutable std::optional<espchrono::millis_clock::time_point> m_nextUpdate;
+    mutable int m_color;
+};
+
+class RandomFont : public virtual FontInterface
+{
+public:
+    int font() const override;
+
+private:
+    mutable std::optional<espchrono::millis_clock::time_point> m_nextUpdate;
+    mutable int m_font;
+};
+
+class RandomIcon : public virtual MenuItemIconInterface
+{
+public:
+    const MenuItemIcon *icon() const override;
+
+private:
+    mutable std::optional<espchrono::millis_clock::time_point> m_nextUpdate;
+    mutable const Icon<24, 24> *m_icon;
+};
+
+struct ToggleLockedAccessor : public virtual RefAccessor<bool>
+{
+public:
+    bool &getRef() const override { return toggleLocked; }
+};
+
+struct ToggleAccessor : public virtual AccessorInterface<bool>
+{
+public:
+    bool getValue() const override { return toggle; };
+    tl::expected<void, std::string> setValue(bool value) override;
+};
+
+using ToggleChangeValueDisplay = espgui::makeComponent<
+    BobbyChangeValueDisplay<bool>,
+    espgui::StaticText<TEXT_DEBUGTOGGLEMENU>,
+    ToggleAccessor,
+    espgui::ConfirmActionInterface<espgui::SwitchScreenAction<DynamicDebugMenu>>,
+    espgui::BackActionInterface<espgui::SwitchScreenAction<DynamicDebugMenu>>
+>;
+
+class OpenPopupAction : public virtual espgui::ActionInterface
+{
+public:
+    void triggered() override
+    {
+        BobbyErrorHandler{}.errorOccured("Das\nist\nein sehr langer text, der nicht in eine zeile passt");
+    }
+};
+} // namespace
+
+std::string RandomText::text() const
+{
+    const auto now = espchrono::millis_clock::now();
+    if (!m_nextUpdate || now >= *m_nextUpdate)
+    {
+        m_title = fmt::format("Dynamic text: {}", cpputils::randomNumber<uint8_t>(100, espcpputils::esp_random_device{}));
+        m_nextUpdate = now + std::chrono::milliseconds{cpputils::randomNumber<long>(100, 1000, espcpputils::esp_random_device{})};
+    }
+
+    return m_title;
+}
+
+DynamicDebugMenu::DynamicDebugMenu()
+{
+    // dummy items to allow for scrolling
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FONTTEST0>,    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FONTTEST1>,    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FONTTEST2>,    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FONTTEST3>,    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+
+    // the interesting bits
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_OPENPOPUP>,    OpenPopupAction>>();
+    constructMenuItem<makeComponent<MenuItem, RandomText,                    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICCOLOR>, RandomColor, DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICFONT>,  RandomFont, DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICICON>,  RandomIcon, DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATICICON>,   StaticMenuItemIcon<&bobbyicons::lock>, DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LOCKTOGGLE>,   BobbyCheckbox, ToggleLockedAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEBUGTOGGLE>,  BobbyCheckbox, ToggleAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEBUGTOGGLEMENU>, SwitchScreenAction<ToggleChangeValueDisplay>>>();
+    constructMenuItem<makeComponent<MenuItem, RandomText,                    RandomColor, RandomFont, RandomIcon, DummyAction>>();
+
+    // more scrolling
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,         SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
+}
+
+namespace {
+
+int RandomColor::color() const
+{
+    const auto now = espchrono::millis_clock::now();
+    if (!m_nextUpdate || now >= *m_nextUpdate)
+    {
+        const auto count = std::size(default_4bit_palette);
+        m_color = default_4bit_palette[cpputils::randomNumber<uint32_t>(count-1, espcpputils::esp_random_device{})];
+        m_nextUpdate = now + std::chrono::milliseconds{cpputils::randomNumber<long>(100, 1000, espcpputils::esp_random_device{})};
+    }
+
+    return m_color;
+}
+
+int RandomFont::font() const
+{
+    const auto now = espchrono::millis_clock::now();
+    if (!m_nextUpdate || now >= *m_nextUpdate)
+    {
+        constexpr const int fonts[] = { 2, 4 };
+        m_font = fonts[cpputils::randomNumber<uint32_t>(std::size(fonts)-1, espcpputils::esp_random_device{})];
+        m_nextUpdate = now + std::chrono::milliseconds{cpputils::randomNumber<long>(100, 1000, espcpputils::esp_random_device{})};
+    }
+
+    return m_font;
+}
+
+const MenuItemIcon *RandomIcon::icon() const
+{
+    const auto now = espchrono::millis_clock::now();
+    if (!m_nextUpdate || now >= *m_nextUpdate)
+    {
+        if (m_icon)
+            m_icon = nullptr;
+        else
+            m_icon = &bobbyicons::lock;
+        m_nextUpdate = now + std::chrono::milliseconds{cpputils::randomNumber<long>(100, 1000, espcpputils::esp_random_device{})};
+    }
+
+    return m_icon;
+}
+
+tl::expected<void, std::string> ToggleAccessor::setValue(bool value)
+{
+    if (toggleLocked)
+        return tl::make_unexpected("cannot be changed while is locked!");
+    toggle = value;
+    return {};
+}
+
+} // namespace

main/displays/menus/dynamicdebugmenu.h

@@ -1,163 +1,29 @@
 #pragma once
 
-// system includes
-#include <string>
-#include <optional>
-
 // 3rdparty lib includes
+#include <textinterface.h>
 #include <espchrono.h>
-#include <fmt/core.h>
+#include <actions/switchscreenaction.h>
-#include <randomutils.h>
-#include <esprandom.h>
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "utils.h"
+#include "debugmenu.h"
-#include "menuitem.h"
-#include "actions/switchscreenaction.h"
-#include "actions/dummyaction.h"
-#include "actions/toggleboolaction.h"
-#include "icons/lock.h"
-#include "checkboxicon.h"
-#include "icons/back.h"
-#include "texts.h"
 
-using namespace espgui;
+class RandomText : public virtual espgui::TextInterface
-
-namespace {
-class RandomText : public virtual TextInterface
 {
 public:
-    std::string text() const override
+    std::string text() const override;
-    {
-        const auto now = espchrono::millis_clock::now();
-        if (!m_nextUpdate || now >= *m_nextUpdate)
-        {
-            m_title = fmt::format("Dynamic text: {}", cpputils::randomNumber<uint8_t>(100, espcpputils::esp_random_device{}));
-            m_nextUpdate = now + std::chrono::milliseconds{cpputils::randomNumber<long>(100, 1000, espcpputils::esp_random_device{})};
-        }
-
-        return m_title;
-    }
 
 private:
     mutable std::optional<espchrono::millis_clock::time_point> m_nextUpdate;
     mutable std::string m_title;
 };
 
-class RandomColor : public virtual ColorInterface
-{
-public:
-    int color() const override
-    {
-        const auto now = espchrono::millis_clock::now();
-        if (!m_nextUpdate || now >= *m_nextUpdate)
-        {
-            const auto count = std::size(default_4bit_palette);
-            m_color = default_4bit_palette[cpputils::randomNumber<uint32_t>(count-1, espcpputils::esp_random_device{})];
-            m_nextUpdate = now + std::chrono::milliseconds{cpputils::randomNumber<long>(100, 1000, espcpputils::esp_random_device{})};
-        }
-
-        return m_color;
-    }
-
-private:
-    mutable std::optional<espchrono::millis_clock::time_point> m_nextUpdate;
-    mutable int m_color;
-};
-
-class RandomFont : public virtual FontInterface
-{
-public:
-    int font() const override
-    {
-        const auto now = espchrono::millis_clock::now();
-        if (!m_nextUpdate || now >= *m_nextUpdate)
-        {
-            constexpr const int fonts[] = { 2, 4 };
-            m_font = fonts[cpputils::randomNumber<uint32_t>(std::size(fonts)-1, espcpputils::esp_random_device{})];
-            m_nextUpdate = now + std::chrono::milliseconds{cpputils::randomNumber<long>(100, 1000, espcpputils::esp_random_device{})};
-        }
-
-        return m_font;
-    }
-
-private:
-    mutable std::optional<espchrono::millis_clock::time_point> m_nextUpdate;
-    mutable int m_font;
-};
-
-class RandomIcon : public virtual MenuItemIconInterface
-{
-public:
-    const MenuItemIcon *icon() const override
-    {
-        const auto now = espchrono::millis_clock::now();
-        if (!m_nextUpdate || now >= *m_nextUpdate)
-        {
-            if (m_icon)
-                m_icon = nullptr;
-            else
-                m_icon = &bobbyicons::lock;
-            m_nextUpdate = now + std::chrono::milliseconds{cpputils::randomNumber<long>(100, 1000, espcpputils::esp_random_device{})};
-        }
-
-        return m_icon;
-    }
-
-private:
-    mutable std::optional<espchrono::millis_clock::time_point> m_nextUpdate;
-    mutable const Icon<24, 24> *m_icon;
-};
-
-bool toggle;
-struct ToggleAccessor : public virtual RefAccessor<bool>
-{
-public:
-    bool &getRef() const override { return toggle; }
-};
-
-constexpr char TEXT_DUMMYITEM[] = "Dummy item";
-constexpr char TEXT_DYNAMICCOLOR[] = "Dynamic color";
-constexpr char TEXT_DYNAMICFONT[] = "Dynamic font";
-constexpr char TEXT_DYNAMICICON[] = "Dynamic icon";
-constexpr char TEXT_STATICICON[] = "Static icon";
-constexpr char TEXT_DEBUGTOGGLE[] = "Toggle";
-
 class DynamicDebugMenu :
     public BobbyMenuDisplay,
     public RandomText,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>
+    public espgui::BackActionInterface<espgui::SwitchScreenAction<DebugMenu>>
 {
 public:
-    DynamicDebugMenu()
+    DynamicDebugMenu();
-    {
-        // dummy items to allow for scrolling
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-
-        // the interesting bits
-        constructMenuItem<makeComponent<MenuItem, RandomText,                    DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICCOLOR>, RandomColor, DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICFONT>,  RandomFont, DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICICON>,  RandomIcon, DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATICICON>,   StaticMenuItemIcon<&bobbyicons::lock>, DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEBUGTOGGLE>,  ToggleBoolAction, CheckboxIcon, ToggleAccessor>>();
-        constructMenuItem<makeComponent<MenuItem, RandomText,                    RandomColor, RandomFont, RandomIcon, DummyAction>>();
-
-        // more scrolling
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,         SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
-    }
 };
-} // namespace

main/displays/menus/enablemenu.cpp

@@ -1,23 +1,39 @@
 #include "enablemenu.h"
 
-// local includes
+// 3rdparty lib includes
-#include "accessors/settingsaccessors.h"
 #include "actions/switchscreenaction.h"
-#include "actions/toggleboolaction.h"
-#include "checkboxicon.h"
-#include "displays/menus/controllerhardwaresettingsmenu.h"
 #include "icons/back.h"
 
+// local includes
+#include "displays/menus/controllerhardwaresettingsmenu.h"
+#include "accessors/settingsaccessors.h"
+#include "bobbycheckbox.h"
+
+namespace {
+constexpr char TEXT_SETENABLED[] = "Set enabled";
+constexpr char TEXT_ENABLEFRONTLEFT[] = "Enable front left";
+constexpr char TEXT_ENABLEFRONTRIGHT[] = "Enable front right";
+constexpr char TEXT_ENABLEBACKLEFT[] = "Enable back left";
+constexpr char TEXT_ENABLEBACKRIGHT[] = "Enable back right";
+constexpr char TEXT_BACK[] = "Back";
+} // namespace
+
 EnableMenu::EnableMenu()
 {
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTLEFT>,  ToggleBoolAction, CheckboxIcon, FrontLeftEnabledAccessor>>();
+    using namespace espgui;
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightEnabledAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTLEFT>,  BobbyCheckbox, FrontLeftEnabledAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKLEFT>,   ToggleBoolAction, CheckboxIcon, BackLeftEnabledAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTRIGHT>, BobbyCheckbox, FrontRightEnabledAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKRIGHT>,  ToggleBoolAction, CheckboxIcon, BackRightEnabledAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKLEFT>,   BobbyCheckbox, BackLeftEnabledAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKRIGHT>,  BobbyCheckbox, BackRightEnabledAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,             SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string EnableMenu::text() const
+{
+    return TEXT_SETENABLED;
+}
+
 void EnableMenu::back()
 {
-    switchScreen<ControllerHardwareSettingsMenu>();
+    espgui::switchScreen<ControllerHardwareSettingsMenu>();
 }

main/displays/menus/enablemenu.h

@@ -2,15 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-using namespace espgui;
+class EnableMenu : public BobbyMenuDisplay
-
-class EnableMenu :
-    public BobbyMenuDisplay,
-    public StaticText<TEXT_SETENABLED>
 {
 public:
     EnableMenu();
+
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/espnowmenu.cpp

@@ -1,31 +1,77 @@
 #include "espnowmenu.h"
 
 #ifdef FEATURE_ESPNOW
+// 3rdparty lib includes
 #include "actions/dummyaction.h"
 #include "actions/switchscreenaction.h"
-#include "actions/toggleboolaction.h"
-#include "checkboxicon.h"
 #include "icons/back.h"
+#include <accessorinterface.h>
+#include <actioninterface.h>
+#include <espchrono.h>
+#include <fmt/core.h>
+#include <menudisplay.h>
+#include <textinterface.h>
+
+// local includes
 #include "icons/settings.h"
 #include "icons/time.h"
 #include "displays/menus/espnowsettingsmenu.h"
 #include "displays/menus/settingsmenu.h"
+#include "bobbycheckbox.h"
+#include "espnowfunctions.h"
 
-using namespace espgui;
+namespace {
+constexpr char TEXT_ESPNOW_MENU[] = "ESP-Now Menu";
+constexpr char TEXT_ESPNOW_RECEIVETS[] = "Recv Ts State";
+constexpr char TEXT_ESPNOW_RECEIVETSFROMBOBBY[] = "Recv BobbyTs State";
+constexpr char TEXT_ESPNOW_SENDTSMSG[] = "Broadcast Time";
+constexpr char TEXT_ESPNOW_SETTINGS[] = "ESP-Now settings";
+constexpr char TEXT_BACK[] = "Back";
 
-namespace espnowmenu {
+struct ReceiveTimeStampAccessor : public espgui::RefAccessor<bool>
+{
+    bool &getRef() const override
+    {
+        return espnow::receiveTimeStamp;
+    }
+};
+struct ReceiveTsFromOtherBobbycarsAccessor : public espgui::RefAccessor<bool>
+{
+    bool &getRef() const override
+    {
+        return espnow::receiveTsFromOtherBobbycars;
+    }
+};
+
+class SendBobbycarTimesyncMessageAction : public virtual espgui::ActionInterface
+{
+public:
+    void triggered() override
+    {
+        const auto message = fmt::format("BOBBYT:{}", espchrono::utc_clock::now().time_since_epoch().count());
+        espnow::send_espnow_message(message);
+    }
+};
 } // namespace
 
-EspNowMenu::EspNowMenu() {
+EspNowMenu::EspNowMenu()
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SENDTSMSG>, espnowmenu::SendBobbycarTimesyncMessageAction, StaticMenuItemIcon<&bobbyicons::time>>>();
+{
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETS>, ToggleBoolAction, CheckboxIcon, espnowmenu::ReceiveTimeStampAccessor>>();
+    using namespace espgui;
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETSFROMBOBBY>, ToggleBoolAction, CheckboxIcon, espnowmenu::ReceiveTsFromOtherBobbycarsAccessor>>();
+
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SENDTSMSG>, SendBobbycarTimesyncMessageAction, StaticMenuItemIcon<&bobbyicons::time>>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETS>, BobbyCheckbox, ReceiveTimeStampAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETSFROMBOBBY>, BobbyCheckbox, ReceiveTsFromOtherBobbycarsAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SETTINGS>, SwitchScreenAction<EspNowSettingsMenu>, StaticMenuItemIcon<&bobbyicons::settings>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string EspNowMenu::text() const
+{
+    return TEXT_ESPNOW_MENU;
+}
+
 void EspNowMenu::back()
 {
-    switchScreen<SettingsMenu>();
+    espgui::switchScreen<SettingsMenu>();
 }
 #endif

main/displays/menus/espnowmenu.h

@@ -2,43 +2,16 @@
 
 #ifdef FEATURE_ESPNOW
 
-// 3rdparty lib includes
-#include <accessorinterface.h>
-#include <actioninterface.h>
-#include <espchrono.h>
-#include <fmt/core.h>
-#include <menudisplay.h>
-#include <textinterface.h>
-#include <texts.h>
-
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "espnowfunctions.h"
 
-using namespace espgui;
+class EspNowMenu : public BobbyMenuDisplay
-
-namespace espnowmenu {
-
-struct ReceiveTimeStampAccessor : public RefAccessor<bool> { bool &getRef() const override { return espnow::receiveTimeStamp; } };
-struct ReceiveTsFromOtherBobbycarsAccessor : public RefAccessor<bool> { bool &getRef() const override { return espnow::receiveTsFromOtherBobbycars; } };
-
-class SendBobbycarTimesyncMessageAction : public virtual ActionInterface {
-public:
-    void triggered() override
-    {
-        const auto message = fmt::format("BOBBYT:{}", espchrono::utc_clock::now().time_since_epoch().count());
-        espnow::send_espnow_message(message);
-    }
-};
-
-} // namespace
-
-class EspNowMenu :
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_ESPNOW_MENU>
 {
 public:
     EspNowMenu();
+
+    std::string text() const override;
+
     void back() override;
 };
 

main/displays/menus/espnowsettingsmenu.cpp

@@ -1,29 +1,49 @@
 #include "espnowsettingsmenu.h"
 
 #ifdef FEATURE_ESPNOW
-#include "accessors/settingsaccessors.h"
+
+// 3rdparty lib includes
 #include "actions/dummyaction.h"
 #include "actions/switchscreenaction.h"
-#include "actions/toggleboolaction.h"
-#include "checkboxicon.h"
 #include "icons/back.h"
+#include <accessorinterface.h>
+#include <actioninterface.h>
+#include <espchrono.h>
+#include <fmt/core.h>
+#include <menudisplay.h>
+#include <textinterface.h>
+
+// local includes
+#include "accessors/settingsaccessors.h"
 #include "icons/time.h"
 #include "espnowmenu.h"
+#include "bobbycheckbox.h"
+#include "espnowfunctions.h"
 
-using namespace espgui;
+namespace {
-
+constexpr char TEXT_ESPNOW_SETTINGS[] = "ESP-Now settings";
-namespace espnowsettingsmenu {
+constexpr char TEXT_ESPNOW_SYNCTIME[] = "Sync time (no NTP)";
+constexpr char TEXT_ESPNOW_SYNCWITHOTHERS[] = "Sync time with others";
+constexpr char TEXT_ESPNOW_SYNCBLINK[] = "Sync blink";
+constexpr char TEXT_BACK[] = "Back";
 } // namespace
 
-EspNowSettingsMenu::EspNowSettingsMenu() {
+EspNowSettingsMenu::EspNowSettingsMenu()
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCTIME>, ToggleBoolAction, CheckboxIcon, ESPNowSyncTimeEnabledAccessor>>();
+{
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCWITHOTHERS>, ToggleBoolAction, CheckboxIcon, ESPNowSyncTimeWithOthersEnabledAccessor>>();
+    using namespace espgui;
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCBLINK>, ToggleBoolAction, CheckboxIcon, ESPNowSyncBlinkEnabledAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCTIME>, BobbyCheckbox, ESPNowSyncTimeEnabledAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCWITHOTHERS>, BobbyCheckbox, ESPNowSyncTimeWithOthersEnabledAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCBLINK>, BobbyCheckbox, ESPNowSyncBlinkEnabledAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<EspNowMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string EspNowSettingsMenu::text() const
+{
+    return TEXT_ESPNOW_SETTINGS;
+}
+
 void EspNowSettingsMenu::back()
 {
-    switchScreen<EspNowMenu>();
+    espgui::switchScreen<EspNowMenu>();
 }
 #endif

main/displays/menus/espnowsettingsmenu.h

@@ -2,30 +2,16 @@
 
 #ifdef FEATURE_ESPNOW
 
-// 3rdparty lib includes
-#include <accessorinterface.h>
-#include <actioninterface.h>
-#include <espchrono.h>
-#include <fmt/core.h>
-#include <menudisplay.h>
-#include <textinterface.h>
-#include <texts.h>
-
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "espnowfunctions.h"
 
-using namespace espgui;
+class EspNowSettingsMenu : public BobbyMenuDisplay
-
-namespace espnowsettingsmenu {
-} // namespace
-
-class EspNowSettingsMenu :
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_ESPNOW_SETTINGS>
 {
 public:
     EspNowSettingsMenu();
+
+    std::string text() const override;
+
     void back() override;
 };
 

main/displays/menus/feedbackdebugmenu.h

@@ -8,23 +8,20 @@
 #include "actions/dummyaction.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
-#include "texts.h"
 #include "debugtexthelpers.h"
 #include "debugcolorhelpers.h"
 #include "displays/menus/debugmenu.h"
 
-using namespace espgui;
-
-namespace {
 template<const char *Ttext, typename Ttexts, template<int> class ColorInterface>
 class FeedbackDebugMenu :
     public BobbyMenuDisplay,
-    public StaticText<Ttext>,
+    public espgui::StaticText<Ttext>,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>
+    public espgui::BackActionInterface<espgui::SwitchScreenAction<DebugMenu>>
 {
 public:
     FeedbackDebugMenu()
     {
+        using namespace espgui;
         //constructMenuItem<makeComponent<MenuItem, typename Ttexts::BatVoltageText,       ColorInterface<TFT_DARKGREY>, DummyAction>>();
         constructMenuItem<makeComponent<MenuItem, typename Ttexts::BatVoltageFixedText,  ColorInterface<TFT_DARKGREY>, DummyAction>>();
         //constructMenuItem<makeComponent<MenuItem, typename Ttexts::BoardTempText,        ColorInterface<TFT_DARKGREY>, DummyAction>>();
@@ -32,9 +29,13 @@ public:
         constructMenuItem<makeComponent<MenuItem, typename Ttexts::TimeoutCntSerialText, StaticFont<2>, ColorInterface<TFT_DARKGREY>, DummyAction>>();
         constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
     }
+
+private:
+    static constexpr char TEXT_BACK[] = "Back";
 };
 
+constexpr char TEXT_FRONTFEEDBACK[] = "Front feedback";
 using FrontFeedbackDebugMenu = FeedbackDebugMenu<TEXT_FRONTFEEDBACK, FrontTexts, FrontFeedbackColor>;
-using BackFeedbackDebugMenu = FeedbackDebugMenu<TEXT_BACKFEEDBACK, BackTexts, FrontFeedbackColor>;
 
-} // namespace
+constexpr char TEXT_BACKFEEDBACK[] = "Back feedback";
+using BackFeedbackDebugMenu = FeedbackDebugMenu<TEXT_BACKFEEDBACK, BackTexts, FrontFeedbackColor>;

main/displays/menus/gametrakmodesettingsmenu.h

@@ -6,15 +6,11 @@
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
-#include "texts.h"
-
-using namespace espgui;
 
 namespace {
 #ifdef FEATURE_GAMETRAK
 class ContainerModeSettingsMenu :
     public BobbyMenuDisplay,
-    public StaticText<TEXT_GAMETRAKMODESETTINGS>,
     public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
 {
 public:
@@ -22,6 +18,11 @@ public:
     {
         constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
     }
+
+    std::string text() const override
+    {
+        return TEXT_GAMETRAKMODESETTINGS;
+    }
 };
 #endif
 } // namespace

main/displays/menus/garagenmenu.cpp

@@ -4,29 +4,66 @@
 // 3rd party libs
 #include <icons/back.h>
 #include <menuitem.h>
+#include <actioninterface.h>
+#include <esp_log.h>
+#include <menuitem.h>
 
 // local includes
 #include "actions/switchscreenaction.h"
 #include "displays/menus/mainmenu.h"
+#include "espnowfunctions.h"
+#include "globals.h"
+#include "newsettings.h"
 
-using namespace espgui;
+namespace {
+constexpr char TEXT_GARAGE[] = "Garage";
+constexpr char TEXT_BACK[] = "Back";
+
+class SendEspNowMessageAction : public virtual espgui::ActionInterface
+{
+public:
+    SendEspNowMessageAction(uint8_t index) : m_index{index} {}
+    void triggered() override;
+
+private:
+    uint8_t m_index;
+};
+} // namespace
 
 GarageMenu::GarageMenu()
 {
+    using namespace espgui;
+
     for (uint8_t index = 0; index < configs.wireless_door_configs.size(); index++)
     {
         const auto &wirelessDoor = configs.wireless_door_configs[index];
         if (wirelessDoor.doorId.value.empty() || wirelessDoor.doorToken.value.empty())
             continue;
-        auto &menuitem = constructMenuItem<makeComponentArgs<MenuItem, garagenmenu::SendEspNowMessageAction, ChangeableText>>(index);
+        auto &menuitem = constructMenuItem<makeComponentArgs<MenuItem, SendEspNowMessageAction, ChangeableText>>(index);
         menuitem.setTitle(wirelessDoor.doorId.value);
     }
 
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string GarageMenu::text() const
+{
+    return TEXT_GARAGE;
+}
+
 void GarageMenu::back()
 {
-    switchScreen<MainMenu>();
+    espgui::switchScreen<MainMenu>();
 }
+
+namespace {
+void SendEspNowMessageAction:: triggered()
+{
+    if (const auto error = espnow::send_espnow_message(fmt::format("BOBBYOPEN:{}:{}", configs.wireless_door_configs[m_index].doorId.value, configs.wireless_door_configs[m_index].doorToken.value)); error != ESP_OK)
+    {
+        ESP_LOGE("BOBBY", "send_espnow_message() failed with: %s", esp_err_to_name(error));
+        return;
+    }
+}
+} // namespace
 #endif

main/displays/menus/garagenmenu.h

@@ -1,41 +1,17 @@
 #pragma once
+
 #if defined(FEATURE_GARAGE) && defined (FEATURE_ESPNOW)
-// 3rd party lib
-#include <actioninterface.h>
-#include <esp_log.h>
-#include <menuitem.h>
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "espnowfunctions.h"
-#include "texts.h"
-#include "globals.h"
-#include "newsettings.h"
 
-namespace garagenmenu {
+class GarageMenu : public BobbyMenuDisplay
-class SendEspNowMessageAction : public virtual espgui::ActionInterface
-{
-public:
-    SendEspNowMessageAction(uint8_t index) : m_index{index} {}
-    void triggered() override
-    {
-        if (const auto error = espnow::send_espnow_message(fmt::format("BOBBYOPEN:{}:{}", configs.wireless_door_configs[m_index].doorId.value, configs.wireless_door_configs[m_index].doorToken.value)); error != ESP_OK)
-        {
-            ESP_LOGE("BOBBY", "send_espnow_message() failed with: %s", esp_err_to_name(error));
-            return;
-        }
-    }
-private:
-    uint8_t m_index;
-};
-} // namespace garagenmenu
-
-class GarageMenu :
-        public BobbyMenuDisplay,
-        public espgui::StaticText<TEXT_GARAGE>
 {
 public:
     GarageMenu();
+
+    std::string text() const override;
+
     void back() override;
 };
 #endif

main/displays/menus/graphsmenu.cpp

@@ -14,6 +14,24 @@
 #include "displays/menus/mainmenu.h"
 
 namespace {
+constexpr char TEXT_GRAPHS[] = "Graphs";
+constexpr char TEXT_GAS[] = "Gas";
+constexpr char TEXT_BREMS[] = "Brems";
+constexpr char TEXT_POTIS[] = "Potis";
+constexpr char TEXT_AVGSPEED[] = "Avg. speed";
+constexpr char TEXT_AVGSPEEDKMH[] = "Avg. speed KMH";
+constexpr char TEXT_SUMCURRENT[] = "Sum current";
+constexpr char TEXT_FRONTVOLTAGE[] = "Front voltage";
+constexpr char TEXT_BACKVOLTAGE[] = "Back voltage";
+constexpr char TEXT_VOLTAGES[] = "Voltages";
+constexpr char TEXT_BMSVOLTAGE[] = "BMS voltage";
+constexpr char TEXT_BMSCURRENT[] = "BMS current";
+constexpr char TEXT_BMSPOWER[] = "BMS power";
+constexpr char TEXT_SUMCURRENTSCOMPARISON[] = "Sum currents comparison";
+constexpr char TEXT_MOTORCURRENTS[] = "Motor currents";
+constexpr char TEXT_RSSI[] = "RSSI";
+constexpr char TEXT_BACK[] = "Back";
+
 using GasGraphDisplay = espgui::makeComponent<
     BobbyGraphDisplay<1>,
     espgui::StaticText<TEXT_GAS>,
@@ -152,11 +170,9 @@ using RssiGraphDisplay = espgui::makeComponent<
 >;
 } // namespace
 
-using namespace espgui;
-
-
 GraphsMenu::GraphsMenu()
 {
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GAS>,                   SwitchScreenAction<GasGraphDisplay>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BREMS>,                 SwitchScreenAction<BremsGraphDisplay>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POTIS>,                 SwitchScreenAction<PotisGraphDisplay>>>();
@@ -179,7 +195,12 @@ GraphsMenu::GraphsMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                  SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string GraphsMenu::text() const
+{
+    return TEXT_GRAPHS;
+}
+
 void GraphsMenu::back()
 {
-    switchScreen<MainMenu>();
+    espgui::switchScreen<MainMenu>();
 }

main/displays/menus/graphsmenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class GraphsMenu :
+class GraphsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_GRAPHS>
 {
 public:
     GraphsMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/greenpassmenu.cpp

@@ -6,22 +6,23 @@
 
 // 3rdparty lib includes
 #include <fmt/core.h>
+#include "actions/switchscreenaction.h"
+#include "actions/dummyaction.h"
+#include "icons/back.h"
 
 // local includes
-#include "actions/switchscreenaction.h"
 #include "actions/qraction.h"
-#include "actions/dummyaction.h"
-#include "actions/toggleboolaction.h"
 #include "displays/menus/mainmenu.h"
 #include "displays/qrdisplay.h"
 #include "displays/qrimportdisplay.h"
-#include "icons/back.h"
-#include "checkboxicon.h"
 #include "qrimport.h"
-
+#include "bobbycheckbox.h"
-using namespace espgui;
 
 namespace {
+constexpr char TEXT_GREENPASS[] = "Green Pass";
+constexpr char TEXT_ADDCERT[] = "Add cert";
+constexpr char TEXT_DELCERT[] = "Delete cert mode";
+constexpr char TEXT_BACK[] = "Back";
 
 bool deleteMode;
 struct DeleteModeAccessor : espgui::RefAccessor<bool> { bool &getRef() const override { return deleteMode; } };
@@ -48,11 +49,11 @@ public:
         if (deleteMode)
         {
             qrimport::delete_qr_code(m_qrmenu.text);
-            switchScreen<GreenPassMenu>();
+            espgui::switchScreen<GreenPassMenu>();
         }
         else
         {
-            switchScreen<QrDisplay>(m_qrmenu.message, m_qrmenu.ver);
+            espgui::switchScreen<QrDisplay>(m_qrmenu.message, m_qrmenu.ver);
         }
     }
 private:
@@ -63,6 +64,8 @@ private:
 
 GreenPassMenu::GreenPassMenu()
 {
+    using namespace espgui;
+
     for (uint8_t index = 0; index < 4; index++)
     {
         const std::string nvs_key = fmt::format("covidcert-{}", index);
@@ -84,11 +87,16 @@ GreenPassMenu::GreenPassMenu()
             constructMenuItem<makeComponentArgs<MenuItem, SwitchQrImportDisplayAction, StaticText<TEXT_ADDCERT>>>(nvs_key);
         }
     }
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DELCERT>, ToggleBoolAction, CheckboxIcon, DeleteModeAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DELCERT>, BobbyCheckbox, DeleteModeAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string GreenPassMenu::text() const
+{
+    return TEXT_GREENPASS;
+}
+
 void GreenPassMenu::back()
 {
-    switchScreen<MainMenu>();
+    espgui::switchScreen<MainMenu>();
 }

main/displays/menus/greenpassmenu.h

@@ -1,19 +1,14 @@
 #pragma once
 
-
-// 3rdparty lib includes
-#include <accessorinterface.h>
-#include <qrcode.h>
-
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class GreenPassMenu :
+class GreenPassMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_GREENPASS>
 {
 public:
     GreenPassMenu();
+
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/handbremssettingsmenu.cpp

@@ -3,9 +3,7 @@
 // 3rd party libs
 #include <fmt/core.h>
 #include <actions/switchscreenaction.h>
-#include <actions/toggleboolaction.h>
 #include <changevaluedisplay.h>
-#include <checkboxicon.h>
 #include <icons/back.h>
 #include <textwithvaluehelper.h>
 
@@ -14,9 +12,17 @@
 #include "accessors/settingsaccessors.h"
 #include "changevaluedisplay_handbremsmode.h"
 #include "displays/menus/defaultmodesettingsmenu.h"
-#include "texts.h"
+#include "bobbycheckbox.h"
 
 namespace {
+constexpr char TEXT_HANDBREMSE_ENABLE[] = "Enable Handbremse";
+constexpr char TEXT_HANDBREMSE_AUTOMATIC[] = "Automatic Handbremse";
+constexpr char TEXT_HANDBREMSE_VISUALIZE[] = "Visualize Handbremse";
+constexpr char TEXT_HANDBREMSE_MODE[] = "Handbrems Mode";
+constexpr char TEXT_HANDBREMSE_TRIGGERTIMEOUT[] = "Handbrems Timeout";
+constexpr char TEXT_HANDBREMSE[] = "Handbremse";
+constexpr char TEXT_BACK[] = "Back";
+
 using HandBremsTriggerTimeoutChangeValueDisplay = espgui::makeComponent<
     BobbyChangeValueDisplay<uint16_t>,
     espgui::StaticText<TEXT_HANDBREMSE_TRIGGERTIMEOUT>,
@@ -44,14 +50,19 @@ public:
 HandbremsSettingsMenu::HandbremsSettingsMenu()
 {
     using namespace espgui;
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_ENABLE>, ToggleBoolAction, CheckboxIcon, HandbremsEnabledAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_ENABLE>, BobbyCheckbox, HandbremsEnabledAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_AUTOMATIC>, ToggleBoolAction, CheckboxIcon, HandbremsAutomaticAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_AUTOMATIC>, BobbyCheckbox, HandbremsAutomaticAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_VISUALIZE>, ToggleBoolAction, CheckboxIcon, HandbremsVisualizeAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_VISUALIZE>, BobbyCheckbox, HandbremsVisualizeAccessor>>();
     constructMenuItem<makeComponent<MenuItem, HandBremsModeText,    SwitchScreenAction<HandBremsModeChangeValueDisplay>>>();
     constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_HANDBREMSE_TRIGGERTIMEOUT, HandbremsTimeoutAccessor>, SwitchScreenAction<HandBremsTriggerTimeoutChangeValueDisplay>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DefaultModeSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string HandbremsSettingsMenu::text() const
+{
+    return TEXT_HANDBREMSE;
+}
+
 void HandbremsSettingsMenu::back()
 {
     espgui::switchScreen<DefaultModeSettingsMenu>();

main/displays/menus/handbremssettingsmenu.h

@@ -2,13 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class HandbremsSettingsMenu :
+class HandbremsSettingsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_HANDBREMSE>
 {
 public:
     HandbremsSettingsMenu();
+
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/invertmenu.cpp

@@ -1,23 +1,37 @@
 #include "invertmenu.h"
 
+// 3rdparty lib includes
+#include "actions/switchscreenaction.h"
+#include "icons/back.h"
+
 // local includes
 #include "accessors/settingsaccessors.h"
-#include "actions/switchscreenaction.h"
-#include "actions/toggleboolaction.h"
-#include "checkboxicon.h"
 #include "displays/menus/controllerhardwaresettingsmenu.h"
-#include "icons/back.h"
+#include "bobbycheckbox.h"
+
+namespace {
+constexpr char TEXT_SETINVERTED[] = "Set inverted";
+constexpr char TEXT_INVERTFRONTLEFT[] = "Invert front left";
+constexpr char TEXT_INVERTFRONTRIGHT[] = "Invert front right";
+constexpr char TEXT_INVERTBACKLEFT[] = "Invert back left";
+constexpr char TEXT_INVERTBACKRIGHT[] = "Invert back right";
+constexpr char TEXT_BACK[] = "Back";
+} // namespace
 
 InvertMenu::InvertMenu()
 {
     using namespace espgui;
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTLEFT>,  ToggleBoolAction, CheckboxIcon, FrontLeftInvertedAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTLEFT>,  BobbyCheckbox, FrontLeftInvertedAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightInvertedAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTRIGHT>, BobbyCheckbox, FrontRightInvertedAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKLEFT>,   ToggleBoolAction, CheckboxIcon, BackLeftInvertedAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKLEFT>,   BobbyCheckbox, BackLeftInvertedAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKRIGHT>,  ToggleBoolAction, CheckboxIcon, BackRightInvertedAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKRIGHT>,  BobbyCheckbox, BackRightInvertedAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,             SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string InvertMenu::text() const
+{
+    return TEXT_SETINVERTED;
+}
 
 void InvertMenu::back()
 {

main/displays/menus/invertmenu.h

@@ -2,13 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class InvertMenu :
+class InvertMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_SETINVERTED>
 {
 public:
     InvertMenu();
+
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/larsmmodesettingsmenu.cpp

@@ -15,6 +15,12 @@
 #include "displays/menus/modessettingsmenu.h"
 
 namespace {
+constexpr char TEXT_LARSMMODESETTINGS[] = "Larsm mode settings";
+constexpr char TEXT_MODELMODE[] = "Model mode";
+constexpr char TEXT_SETMODE[] = "Set mode";
+constexpr char TEXT_SETITERATIONS[] = "Set iterations";
+constexpr char TEXT_BACK[] = "Back";
+
 using LarsmModeModelModeChangeDisplay = espgui::makeComponent<
     BobbyChangeValueDisplay<UnifiedModelMode>,
     espgui::StaticText<TEXT_MODELMODE>,
@@ -48,6 +54,11 @@ LarsmModeSettingsMenu::LarsmModeSettingsMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,          SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string LarsmModeSettingsMenu::text() const
+{
+    return TEXT_LARSMMODESETTINGS;
+}
+
 void LarsmModeSettingsMenu::back()
 {
     switchScreen<ModesSettingsMenu>();

main/displays/menus/larsmmodesettingsmenu.h

@@ -1,17 +1,14 @@
 #pragma once
 
-// 3rdparty lib includes
-
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class LarsmModeSettingsMenu :
+class LarsmModeSettingsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_LARSMMODESETTINGS>
 {
 public:
     LarsmModeSettingsMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/ledstripmenu.cpp

@@ -5,9 +5,7 @@
 #include <FastLED.h>
 #include <actioninterface.h>
 #include <actions/switchscreenaction.h>
-#include <actions/toggleboolaction.h>
 #include <changevaluedisplay.h>
-#include <checkboxicon.h>
 #include <icons/back.h>
 #include <menuitem.h>
 #include <textwithvaluehelper.h>
@@ -22,10 +20,35 @@
 #include "ledstrip.h"
 #include "ledstripselectanimationmenu.h"
 #include "ledstripselectblinkmenu.h"
+#include "bobbycheckbox.h"
 
 // clang-format off
 
 namespace {
+constexpr char TEXT_LEDSTRIP[] = "Ledstrip";
+constexpr char TEXT_LEDANIMATION[] = "LED Animation";
+constexpr char TEXT_SELECTANIMATION[] = "Select Animation";
+constexpr char TEXT_BRAKELIGHTS[] = "Brake Lights";
+constexpr char TEXT_LEDSTRIPCOLORMENU[] = "Customize Ledstrip";
+constexpr char TEXT_BLINKANIMATION[] = "Blink animation";
+constexpr char TEXT_ANIMATION_TYPE[] = "Blink animation";
+constexpr char TEXT_LEDSCOUNT[] = "LEDs Count";
+constexpr char TEXT_CENTEROFFSET[] = "Center Offset";
+constexpr char TEXT_SMALLOFFSET[] = "Small Offset";
+constexpr char TEXT_BIGOFFSET[] = "Big Offset";
+constexpr char TEXT_LEDSTRIPCURRENTLIMIT[] = "Ledstrip Currentlimit";
+constexpr char TEXT_BLINKBEEP[] = "Blink Beep";
+constexpr char TEXT_FULLBLINK[] = "Full blink";
+constexpr char TEXT_LEDSTRIP_STVO[] = "Enable StVO";
+constexpr char TEXT_STVO_FRONTOFFSET[] = "StVO Front Offset";
+constexpr char TEXT_STVO_FRONTLENGTH[] = "StVO Front Length";
+constexpr char TEXT_STVO_ENABLEFRONTLIGHT[] = "StVO Front Enable";
+constexpr char TEXT_ANIMATION_MULTIPLIER[] = "Animation Multiplier";
+constexpr char TEXT_LEDSTRIP_BRIGHTNESS[] = "Ledstrip Brightness";
+constexpr char TEXT_LEDSTRIP_ALLCUSTOMOFF[] = "All custom off";
+constexpr char TEXT_LEDSTRIP_CHANGE_OTA_ANIM[] = "Change Ota animation";
+constexpr char TEXT_BACK[] = "Back";
+
 using LedsCountChangeScreen = espgui::makeComponent<
     BobbyChangeValueDisplay<int16_t>,
     espgui::StaticText<TEXT_LEDSCOUNT>,
@@ -58,10 +81,11 @@ using BigOffsetChangeScreen = espgui::makeComponent<
     espgui::BackActionInterface<espgui::SwitchScreenAction<LedstripMenu>>
 >;
 
-using DeziampereChangeScreen = espgui::makeComponent<
+using LedStripMaxAmpereChangeScreen = espgui::makeComponent<
-    BobbyChangeValueDisplay<int16_t>,
+    BobbyChangeValueDisplay<float>,
-    espgui::StaticText<TEXT_LEDSTRIP_MILLIAMP>,
+    espgui::StaticText<TEXT_LEDSTRIPCURRENTLIMIT>,
-    DeziampereAccessor,
+    LedStripMaxAmpereAccessor,
+    espgui::RatioNumberStep<float, std::ratio<1,10>>,
     espgui::ConfirmActionInterface<espgui::SwitchScreenAction<LedstripMenu>>,
     espgui::BackActionInterface<espgui::SwitchScreenAction<LedstripMenu>>
 >;
@@ -82,7 +106,7 @@ using StVOLengthChangeScreen = espgui::makeComponent<
     espgui::BackActionInterface<espgui::SwitchScreenAction<LedstripMenu>>
 >;
 
-using animationMultiplierChangeScreen = espgui::makeComponent<
+using AnimationMultiplierChangeScreen = espgui::makeComponent<
     BobbyChangeValueDisplay<int16_t>,
     espgui::StaticText<TEXT_ANIMATION_MULTIPLIER>,
     AnimationMultiplierAccessor,
@@ -90,7 +114,7 @@ using animationMultiplierChangeScreen = espgui::makeComponent<
     espgui::BackActionInterface<espgui::SwitchScreenAction<LedstripMenu>>
 >;
 
-using ledstripBrightnessChangeScreen = espgui::makeComponent<
+using LedStripBrightnessChangeScreen = espgui::makeComponent<
     BobbyChangeValueDisplay<uint8_t>,
     espgui::StaticText<TEXT_LEDSTRIP_BRIGHTNESS>,
     LedstripBrightnessAccessor,
@@ -103,10 +127,16 @@ class AllCustomLedsOffAction : public virtual espgui::ActionInterface
 public:
     void triggered() override
     {
-        for(int index = 0; index < 8; index++)
+        std::fill(std::begin(ledstrip_custom_colors), std::end(ledstrip_custom_colors), CRGB{0, 0, 0});
-        {
+    }
-            ledstrip_custom_colors[index] = CRGB{0,0,0};
+};
-        }
+
+class LedStripMaxCurrentText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override
+    {
+        return fmt::format("&sLedstrip max current: &f&2{:.02f}A", configs.ledStripMaxMilliamps.value / 1000.f);
     }
 };
 } // namespace
@@ -114,33 +144,43 @@ public:
 LedstripMenu::LedstripMenu()
 {
     using namespace espgui;
-    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIPCOLORMENU>,                               espgui::SwitchScreenAction<LedstripColorsDisplay>>>();
-    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDANIMATION>, ToggleBoolAction, CheckboxIcon,    EnableLedAnimationAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BRAKELIGHTS>,  ToggleBoolAction, CheckboxIcon,    EnableBrakeLightsAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BLINKBEEP>, ToggleBoolAction, CheckboxIcon,       EnableBeepWhenBlinkAccessor>>();
-    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_FULLBLINK>, ToggleBoolAction, CheckboxIcon,       EnableFullBlinkAccessor>>();
 
-    if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_STVO>, ToggleBoolAction, CheckboxIcon,   EnableLedstripStVOAccessor>>(); }
+    if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_STVO>, BobbyCheckbox, EnableLedstripStVOAccessor>>(); }
-    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_STVO_ENABLEFRONTLIGHT>, ToggleBoolAction, CheckboxIcon,   EnableLedstripStVOFrontlight>>();
+    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_STVO_ENABLEFRONTLIGHT>, BobbyCheckbox, EnableLedstripStVOFrontlight>>();
+
+    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDANIMATION>, BobbyCheckbox, EnableLedAnimationAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_SELECTANIMATION>,                                 espgui::SwitchScreenAction<LedstripSelectAnimationMenu>>>();
+
+    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BRAKELIGHTS>,  BobbyCheckbox,    EnableBrakeLightsAccessor>>();
+
+    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIPCOLORMENU>, espgui::SwitchScreenAction<LedstripColorsDisplay>>>();
     constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_ALLCUSTOMOFF>, AllCustomLedsOffAction>>();
+
+    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BLINKBEEP>, BobbyCheckbox,       EnableBeepWhenBlinkAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_FULLBLINK>, BobbyCheckbox,       EnableFullBlinkAccessor>>();
+
     if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_STVO_FRONTOFFSET, LedsStVOFrontOffsetAccessor>,    espgui::SwitchScreenAction<StVOOffsetChangeScreen>>>(); }
     if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_STVO_FRONTLENGTH, LedsStVOFrontLengthAccessor>,    espgui::SwitchScreenAction<StVOLengthChangeScreen>>>(); }
 
-    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_SELECTANIMATION>,                                 espgui::SwitchScreenAction<LedstripSelectAnimationMenu>>>();
     constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BLINKANIMATION>,                                  espgui::SwitchScreenAction<LedstripSelectBlinkMenu>>>();
 #ifdef FEATURE_OTA
-    if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_CHANGE_OTA_ANIM>,     espgui::SwitchScreenAction<ledstripOtaAnimationChangeMenu>>>(); }
+    if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_CHANGE_OTA_ANIM>,     espgui::SwitchScreenAction<LedstripOtaAnimationChangeMenu>>>(); }
 #endif
-    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_ANIMATION_MULTIPLIER>,                            espgui::SwitchScreenAction<animationMultiplierChangeScreen>>>();
+    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_ANIMATION_MULTIPLIER>,                            espgui::SwitchScreenAction<AnimationMultiplierChangeScreen>>>();
     if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_LEDSCOUNT, LedsCountAccessor>,           espgui::SwitchScreenAction<LedsCountChangeScreen>>>(); }
     if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_CENTEROFFSET, CenterOffsetAccessor>,     espgui::SwitchScreenAction<CenterOffsetChangeScreen>>>(); }
     if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_SMALLOFFSET, SmallOffsetAccessor>,       espgui::SwitchScreenAction<SmallOffsetChangeScreen>>>(); }
     if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_BIGOFFSET, BigOffsetAccessor>,           espgui::SwitchScreenAction<BigOffsetChangeScreen>>>(); }
-    if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_BRIGHTNESS>,                             espgui::SwitchScreenAction<ledstripBrightnessChangeScreen>>>(); }
+    if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_BRIGHTNESS>,                             espgui::SwitchScreenAction<LedStripBrightnessChangeScreen>>>(); }
-    if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_LEDSTRIP_MILLIAMP, DeziampereAccessor>,  espgui::SwitchScreenAction<DeziampereChangeScreen>>>(); }
+    if (!simplified) { constructMenuItem<makeComponent<MenuItem, LedStripMaxCurrentText, espgui::SwitchScreenAction<LedStripMaxAmpereChangeScreen>>>(); }
     constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BACK>,                                            espgui::SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string LedstripMenu::text() const
+{
+    return TEXT_LEDSTRIP;
+}
+
 void LedstripMenu::back()
 {
     espgui::switchScreen<MainMenu>();

main/displays/menus/ledstripmenu.h

@@ -2,16 +2,15 @@
 
 // local includes
 #include "displays/menudisplaywithtime.h"
-#include "texts.h"
 
 #ifdef FEATURE_LEDSTRIP
-class LedstripMenu :
+class LedstripMenu : public bobbygui::MenuDisplayWithTime
-    public bobbygui::MenuDisplayWithTime,
-    public espgui::StaticText<TEXT_LEDSTRIP>
 {
 public:
     LedstripMenu();
 
+    std::string text() const override;
+
     void back() override;
 };
 #endif

main/displays/menus/ledstripselectanimationmenu.cpp

@@ -8,10 +8,14 @@
 #include "ledstripdefines.h"
 #include "ledstripmenu.h"
 
-using namespace espgui;
-
 #ifdef FEATURE_LEDSTRIP
 namespace {
+constexpr char TEXT_SELECTANIMATION[] = "Select Animation";
+constexpr char TEXT_ANIMATION_DEFAULTRAINBOW[] = "Default Rainbow";
+constexpr char TEXT_ANIMATION_BETTERRAINBOW[] = "Better Rainbow";
+constexpr char TEXT_ANIMATION_SPEEDSYNCANIMATION[] = "Speed Sync";
+constexpr char TEXT_ANIMATION_CUSTOMCOLOR[] = "Custom Color";
+constexpr char TEXT_BACK[] = "Back";
 
 class CurrentSelectedAnimationText : public virtual espgui::TextInterface
 {
@@ -23,6 +27,8 @@ public:
 
 LedstripSelectAnimationMenu::LedstripSelectAnimationMenu()
 {
+    using namespace espgui;
+
     constructMenuItem<makeComponent<MenuItem, CurrentSelectedAnimationText,                  DisabledColor, DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, EmptyText,                                     DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ANIMATION_DEFAULTRAINBOW>,     LedStripSetAnimationAction<LedstripAnimation::DefaultRainbow>>>();
@@ -32,9 +38,14 @@ LedstripSelectAnimationMenu::LedstripSelectAnimationMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                         SwitchScreenAction<LedstripMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string LedstripSelectAnimationMenu::text() const
+{
+    return TEXT_SELECTANIMATION;
+}
+
 void LedstripSelectAnimationMenu::back()
 {
-    switchScreen<LedstripMenu>();
+    espgui::switchScreen<LedstripMenu>();
 }
 
 namespace {

main/displays/menus/ledstripselectanimationmenu.h

@@ -2,15 +2,15 @@
 
 // Local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
 #ifdef FEATURE_LEDSTRIP
-class LedstripSelectAnimationMenu :
+class LedstripSelectAnimationMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_SELECTANIMATION>
 {
 public:
     LedstripSelectAnimationMenu();
+
+    std::string text() const override;
+
     void back() override;
 };
 #endif

main/displays/menus/ledstripselectblinkmenu.cpp

@@ -1,53 +1,84 @@
 #include "ledstripselectblinkmenu.h"
 
 #ifdef FEATURE_LEDSTRIP
-// Local includes
+
-#include "accessors/settingsaccessors.h"
+// 3rdparty lib includes
 #include "actions/dummyaction.h"
-#include "actions/ledstripblinkactions.h"
 #include "actions/switchscreenaction.h"
-#include "actions/toggleboolaction.h"
-#include "checkboxicon.h"
-#include "displays/menus/ledstripmenu.h"
 #include "icons/back.h"
 
-using namespace espgui;
+// local includes
+#include "accessors/settingsaccessors.h"
+#include "actions/ledstripblinkactions.h"
+#include "displays/menus/ledstripmenu.h"
+#include "ledstrip.h"
+#include "ledstripdefines.h"
+#include "bobbycheckbox.h"
 
-std::string currentSelectedBlinkAnimationText::text() const {
+namespace {
-    switch (blinkAnimation) {
+constexpr char TEXT_BLINKANIMATION[] = "Blink animation";
-        case LEDSTRIP_OVERWRITE_BLINKLEFT:
+constexpr char TEXT_ANIMATION_BLINKNONE[] = "Blink Off";
-#ifndef LEDSTRIP_WRONG_DIRECTION
+constexpr char TEXT_ANIMATION_BLINKLEFT[] = "Blink Left";
-            return TEXT_ANIMATION_BLINKLEFT;
+constexpr char TEXT_ANIMATION_BLINKRIGHT[] = "Blink Right";
-#else
+constexpr char TEXT_ANIMATION_BLINKBOTH[] = "Blink Both";
-            return TEXT_ANIMATION_BLINKRIGHT;
+constexpr char TEXT_LEDSTRIP_EN_BLINK_ANIM[] = "Animated Blink";
-#endif
+constexpr char TEXT_BACK[] = "Back";
-        case LEDSTRIP_OVERWRITE_BLINKRIGHT:
+
-#ifndef LEDSTRIP_WRONG_DIRECTION
+class CurrentSelectedBlinkAnimationText : public virtual espgui::TextInterface
-            return TEXT_ANIMATION_BLINKRIGHT;
+{
-#else
+public:
-            return TEXT_ANIMATION_BLINKLEFT;
+    std::string text() const override;
-#endif
+};
-        case LEDSTRIP_OVERWRITE_BLINKBOTH:
+
-            return TEXT_ANIMATION_BLINKBOTH;
+} // namespace
-        default:
-            return TEXT_ANIMATION_BLINKNONE;
-    }
-}
 
 LedstripSelectBlinkMenu::LedstripSelectBlinkMenu()
 {
-    constructMenuItem<makeComponent<MenuItem, currentSelectedBlinkAnimationText,             DisabledColor, DummyAction>>();
+    using namespace espgui;
+    constructMenuItem<makeComponent<MenuItem, CurrentSelectedBlinkAnimationText,             DisabledColor, DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, EmptyText,                                     DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ANIMATION_BLINKNONE>,          LedstripAnimationBlinkNoneAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ANIMATION_BLINKLEFT>,          LedstripAnimationBlinkLeftAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ANIMATION_BLINKRIGHT>,         LedstripAnimationBlinkRightAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ANIMATION_BLINKBOTH>,          LedstripAnimationBlinkBothAction>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LEDSTRIP_EN_BLINK_ANIM>,       ToggleBoolAction, CheckboxIcon, LedstripEnableBlinkAnimationAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LEDSTRIP_EN_BLINK_ANIM>,       BobbyCheckbox, LedstripEnableBlinkAnimationAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                         SwitchScreenAction<LedstripMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string LedstripSelectBlinkMenu::text() const
+{
+    return TEXT_BLINKANIMATION;
+}
+
 void LedstripSelectBlinkMenu::back()
 {
-    switchScreen<LedstripMenu>();
+    espgui::switchScreen<LedstripMenu>();
 }
+
+namespace {
+
+std::string CurrentSelectedBlinkAnimationText::text() const
+{
+    switch (blinkAnimation)
+    {
+    case LEDSTRIP_OVERWRITE_BLINKLEFT:
+#ifndef LEDSTRIP_WRONG_DIRECTION
+        return TEXT_ANIMATION_BLINKLEFT;
+#else
+        return TEXT_ANIMATION_BLINKRIGHT;
+#endif
+    case LEDSTRIP_OVERWRITE_BLINKRIGHT:
+#ifndef LEDSTRIP_WRONG_DIRECTION
+        return TEXT_ANIMATION_BLINKRIGHT;
+#else
+        return TEXT_ANIMATION_BLINKLEFT;
+#endif
+    case LEDSTRIP_OVERWRITE_BLINKBOTH:
+        return TEXT_ANIMATION_BLINKBOTH;
+    default:
+        return TEXT_ANIMATION_BLINKNONE;
+    }
+}
+
+} // namespace
 #endif

main/displays/menus/ledstripselectblinkmenu.h

@@ -2,22 +2,14 @@
 
 // Local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
-#include "ledstrip.h"
-#include "ledstripdefines.h"
 
 #ifdef FEATURE_LEDSTRIP
-class currentSelectedBlinkAnimationText : public virtual espgui::TextInterface
+class LedstripSelectBlinkMenu : public BobbyMenuDisplay
-{
-public: std::string text() const override;
-};
-
-class LedstripSelectBlinkMenu :
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_BLINKANIMATION>
 {
 public:
     LedstripSelectBlinkMenu();
+
+    std::string text() const override;
     void back() override;
 };
 #endif

main/displays/menus/ledstripselectotamode.cpp

@@ -1,24 +1,51 @@
 #include "ledstripselectotamode.h"
 
+// 3rdparty lib includes
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
+
+// local includes
+#include "ledstrip.h"
+#include "globals.h"
+#include "utils.h"
 #include "ledstripmenu.h"
 
-// Local includes
-
 #if defined(FEATURE_LEDSTRIP) && defined(FEATURE_OTA)
-using namespace espgui;
+namespace {
+constexpr char TEXT_BLINKANIMATION[] = "Blink animation";
+constexpr char TEXT_OTAANIM_NONE[] = "None";
+constexpr char TEXT_OTAANIM_PROGRESS[] = "Progress Bar";
+constexpr char TEXT_OTAANIM_COLOR[] = "Color change";
+constexpr char TEXT_BACK[] = "Back";
 
-ledstripOtaAnimationChangeMenu::ledstripOtaAnimationChangeMenu()
+template <OtaAnimationModes mode>
+class LedstripChangeOtaAnimModeAction : public virtual espgui::ActionInterface
 {
+public:
+    void triggered() override
+    {
+        settings.ledstrip.otaMode = mode;
+        saveSettings();
+    }
+};
+} // namespace
+
+LedstripOtaAnimationChangeMenu::LedstripOtaAnimationChangeMenu()
+{
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_OTAANIM_NONE>,          LedstripChangeOtaAnimModeAction<OtaAnimationModes::None>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_OTAANIM_PROGRESS>,      LedstripChangeOtaAnimModeAction<OtaAnimationModes::GreenProgressBar>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_OTAANIM_COLOR>,         LedstripChangeOtaAnimModeAction<OtaAnimationModes::ColorChangeAll>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                  SwitchScreenAction<LedstripMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
-void ledstripOtaAnimationChangeMenu::back()
+std::string LedstripOtaAnimationChangeMenu::text() const
 {
-    switchScreen<LedstripMenu>();
+    return TEXT_BLINKANIMATION;
+}
+
+void LedstripOtaAnimationChangeMenu::back()
+{
+    espgui::switchScreen<LedstripMenu>();
 }
 #endif

main/displays/menus/ledstripselectotamode.h

@@ -1,31 +1,15 @@
 #pragma once
 
-// Local includes
+// local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
-#include "ledstrip.h"
-#include "globals.h"
-#include "utils.h"
 
 #if defined(FEATURE_LEDSTRIP) && defined(FEATURE_OTA)
-
+class LedstripOtaAnimationChangeMenu : public BobbyMenuDisplay
-template <OtaAnimationModes mode>
-class LedstripChangeOtaAnimModeAction : public virtual espgui::ActionInterface
 {
 public:
-    void triggered() override
+    LedstripOtaAnimationChangeMenu();
-    {
-        settings.ledstrip.otaMode = mode;
-        saveSettings();
-    }
-};
 
-class ledstripOtaAnimationChangeMenu :
+    std::string text() const override;
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_BLINKANIMATION>
-{
-public:
-    ledstripOtaAnimationChangeMenu();
     void back() override;
 };
 #endif

main/displays/menus/limitssettingsmenu.cpp

@@ -14,6 +14,15 @@
 #include "displays/menus/settingsmenu.h"
 
 namespace {
+constexpr char TEXT_LIMITSSETTINGS[] = "Limit settings";
+constexpr char TEXT_IMOTMAX[] = "iMotMax";
+constexpr char TEXT_IDCMAX[] = "iDcMax";
+constexpr char TEXT_NMOTMAXKMH[] = "nMotMaxKmh";
+constexpr char TEXT_NMOTMAX[] = "nMotMax";
+constexpr char TEXT_FIELDWEAKMAX[] = "fldWkMax";
+constexpr char TEXT_PHASEADVMAX[] = "phsAdvMax";
+constexpr char TEXT_BACK[] = "Back";
+
 using IMotMaxChangeScreen = espgui::makeComponent<
     BobbyChangeValueDisplay<int16_t>,
     espgui::StaticText<TEXT_IMOTMAX>,
@@ -71,6 +80,11 @@ LimitsSettingsMenu::LimitsSettingsMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                                        SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string LimitsSettingsMenu::text() const
+{
+    return TEXT_LIMITSSETTINGS;
+}
+
 void LimitsSettingsMenu::back()
 {
     switchScreen<SettingsMenu>();

main/displays/menus/limitssettingsmenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class LimitsSettingsMenu :
+class LimitsSettingsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_LIMITSSETTINGS>
 {
 public:
     LimitsSettingsMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/lockscreensettingsmenu.cpp

@@ -2,10 +2,8 @@
 
 // 3rdparty lib includes
 #include <menuitem.h>
-#include <actions/toggleboolaction.h>
 #include <actions/switchscreenaction.h>
 #include <icons/back.h>
-#include <checkboxicon.h>
 #include <changevaluedisplay.h>
 #include <textwithvaluehelper.h>
 
@@ -14,8 +12,18 @@
 #include "globals.h"
 #include "accessors/settingsaccessors.h"
 #include "displays/menus/boardcomputerhardwaresettingsmenu.h"
+#include "bobbycheckbox.h"
 
 namespace {
+constexpr char TEXT_LOCKSCREENSETTINGS[] = "Lockscreen Settings";
+constexpr char TEXT_ALLOWPRESETSWITCH[] = "Allow preset switch";
+constexpr char TEXT_KEEPLOCKED[] = "Keep locked";
+constexpr char TEXT_PINDIGIT0[] = "PIN digit0";
+constexpr char TEXT_PINDIGIT1[] = "PIN digit1";
+constexpr char TEXT_PINDIGIT2[] = "PIN digit2";
+constexpr char TEXT_PINDIGIT3[] = "PIN digit3";
+constexpr char TEXT_BACK[] = "Back";
+
 using LockscreenPinDigit0ChangeScreen = espgui::makeComponent<
     BobbyChangeValueDisplay<int8_t>,
     espgui::StaticText<TEXT_PINDIGIT0>,
@@ -49,12 +57,11 @@ using LockscreenPinDigit3ChangeScreen = espgui::makeComponent<
 >;
 } // namespace
 
-using namespace espgui;
-
 LockscreenSettingsMenu::LockscreenSettingsMenu()
 {
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ALLOWPRESETSWITCH>, ToggleBoolAction, CheckboxIcon, LockscreenAllowPresetSwitchAccessor>>();
+    using namespace espgui;
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_KEEPLOCKED>, ToggleBoolAction, CheckboxIcon, LockscreenKeepLockedAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ALLOWPRESETSWITCH>, BobbyCheckbox, LockscreenAllowPresetSwitchAccessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_KEEPLOCKED>, BobbyCheckbox, LockscreenKeepLockedAccessor>>();
     constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_PINDIGIT0, LockscreenPinDigitAccessor<0>>, SwitchScreenAction<LockscreenPinDigit0ChangeScreen>>>();
     constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_PINDIGIT1, LockscreenPinDigitAccessor<1>>, SwitchScreenAction<LockscreenPinDigit1ChangeScreen>>>();
     constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_PINDIGIT2, LockscreenPinDigitAccessor<2>>, SwitchScreenAction<LockscreenPinDigit2ChangeScreen>>>();
@@ -62,7 +69,12 @@ LockscreenSettingsMenu::LockscreenSettingsMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                                              SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string LockscreenSettingsMenu::text() const
+{
+    return TEXT_LOCKSCREENSETTINGS;
+}
+
 void LockscreenSettingsMenu::back()
 {
-    switchScreen<BoardcomputerHardwareSettingsMenu>();
+    espgui::switchScreen<BoardcomputerHardwareSettingsMenu>();
 }

main/displays/menus/lockscreensettingsmenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class LockscreenSettingsMenu :
+class LockscreenSettingsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_LOCKSCREENSETTINGS>
 {
 public:
     LockscreenSettingsMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/mainmenu.cpp

@@ -52,23 +52,40 @@
 #include "icons/time.h"
 #include "tftinstance.h"
 
-using namespace espgui;
+namespace {
+constexpr char TAG[] = "BOBBY";
+
+constexpr char TEXT_MAINMENU[] = "Main menu";
+constexpr char TEXT_STATUS[] = "Status";
+constexpr char TEXT_LEDSTRIP[] = "Ledstrip";
+constexpr char TEXT_STATISTICSMENU[] = "Statistics";
+constexpr char TEXT_SELECTMODE[] = "Select mode";
+constexpr char TEXT_MODESETTINGS[] = "Mode settings";
+constexpr char TEXT_PRESETS[] = "Presets";
+constexpr char TEXT_PROFILES[] = "Profiles";
+constexpr char TEXT_GRAPHS[] = "Graphs";
+constexpr char TEXT_POWERSUPPLY[] = "Powersupply";
+constexpr char TEXT_BMS[] = "BMS";
+constexpr char TEXT_SETTINGS[] = "Settings";
+constexpr char TEXT_GREENPASS[] = "Green Pass";
+constexpr char TEXT_LOCKVEHICLE[] = "Lock vehicle";
+constexpr char TEXT_MOSFETS[] = "Mosfets";
+constexpr char TEXT_DEMOS[] = "Demos";
+constexpr char TEXT_GARAGE[] = "Garage";
+constexpr char TEXT_UPDATE[] = "Update";
+constexpr char TEXT_POWEROFF[] = "Poweroff";
+constexpr char TEXT_REBOOT[] = "Reboot";
+constexpr char TEXT_DEBUG[] = "Debug";
+constexpr char TEXT_BATTERY[] = "Battery";
+constexpr char TEXT_BATTERYDEBUG[] = "Bat Debug Menu";
+constexpr char TEXT_TOGGLECLOUDDEBUG[] = "Cloud Debug";
 
-namespace mainmenu {
-/*
-class CurrentTimeText : public virtual TextInterface
-{
-public:
-    std::string text() const override
-    {
-        return fmt::format("&7Time: {}", local_clock_string());
-    }
-};
-*/
 } // namespace
 
 MainMenu::MainMenu()
 {
+    using namespace espgui;
+
     // constructMenuItem<makeComponent<MenuItem, mainmenu::CurrentTimeText,     DummyAction, StaticMenuItemIcon<&bobbyicons::time>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATUS>,       SwitchScreenAction<StatusDisplay>, StaticMenuItemIcon<&espgui::icons::back>>>();
 #ifdef FEATURE_LEDSTRIP
@@ -77,21 +94,8 @@ MainMenu::MainMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATISTICSMENU>, SwitchScreenAction<StatisticsMenu>, StaticMenuItemIcon<&bobbyicons::statistics>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SELECTMODE>,   SwitchScreenAction<SelectModeMenu>, StaticMenuItemIcon<&bobbyicons::modes>>>();
     if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MODESETTINGS>, ModeSettingsAction>>(); }
-    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PRESETS>,      SwitchScreenAction<PresetsMenu>, StaticMenuItemIcon<&bobbyicons::presets>>>(); }
-    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILES>,     SwitchScreenAction<ProfilesMenu>>>(); }
-    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GRAPHS>,       SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&bobbyicons::graph>>>(); }
     if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY>,      SwitchScreenAction<BatteryMenu>, StaticMenuItemIcon<&bobbyicons::battery>>>(); }
-#if defined(FEATURE_CAN) && defined(FEATURE_POWERSUPPLY)
-    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POWERSUPPLY>,  SwitchScreenAction<PowerSupplyDisplay>>>(); }
-#endif
-#if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
-    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMS>,          SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&bobbyicons::bms>>>(); }
-#endif
     if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETTINGS>,     SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&bobbyicons::settings>>>(); }
-#ifdef FEATURE_MOSFETS
-    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETS>,      SwitchScreenAction<MosfetsMenu>>>(); }
-#endif
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEMOS>,        SwitchScreenAction<DemosMenu>, StaticMenuItemIcon<&bobbyicons::demos>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GREENPASS>,    SwitchScreenAction<GreenPassMenu>, StaticMenuItemIcon<&bobbyicons::greenpass>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LOCKVEHICLE>,  SwitchScreenAction<Lockscreen>, StaticMenuItemIcon<&bobbyicons::lock>>>();
 #if defined(FEATURE_GARAGE) && defined (FEATURE_ESPNOW)
@@ -100,15 +104,33 @@ MainMenu::MainMenu()
 #ifdef FEATURE_OTA
     if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_UPDATE>,       SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&bobbyicons::update>>>(); }
 #endif
+    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GRAPHS>,       SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&bobbyicons::graph>>>(); }
+#if defined(FEATURE_CAN) && defined(FEATURE_POWERSUPPLY)
+    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POWERSUPPLY>,  SwitchScreenAction<PowerSupplyDisplay>>>(); }
+#endif
+#ifdef FEATURE_MOSFETS
+    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETS>,      SwitchScreenAction<MosfetsMenu>>>(); }
+#endif
+#if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
+    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMS>,          SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&bobbyicons::bms>>>(); }
+#endif
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEMOS>,        SwitchScreenAction<DemosMenu>, StaticMenuItemIcon<&bobbyicons::demos>>>();
+    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILES>,     SwitchScreenAction<ProfilesMenu>>>(); }
+    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PRESETS>,      SwitchScreenAction<PresetsMenu>, StaticMenuItemIcon<&bobbyicons::presets>>>(); }
+    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEBUG>,        SwitchScreenAction<DebugMenu>>>(); }
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POWEROFF>,     SwitchScreenAction<PoweroffDisplay>, StaticMenuItemIcon<&bobbyicons::poweroff>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REBOOT>,       RebootAction, StaticMenuItemIcon<&bobbyicons::reboot>>>();
-    if (SHOWITEM)   { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEBUG>,        SwitchScreenAction<DebugMenu>>>(); }
 #ifdef MAINMENU_PLUGIN
     GMEN1
 #endif
 }
 
+std::string MainMenu::text() const
+{
+    return TEXT_MAINMENU;
+}
+
 void MainMenu::back()
 {
-    switchScreen<StatusDisplay>();
+    espgui::switchScreen<StatusDisplay>();
 }

main/displays/menus/mainmenu.h

@@ -4,7 +4,6 @@
 #include "menuitem.h"
 
 // local includes
-#include "texts.h"
 #include "displays/menudisplaywithtime.h"
 #ifdef MAINMENU_PLUGIN
 #include MAINMENU_PLUGIN
@@ -21,12 +20,14 @@ namespace {
 #endif
 } // namespace
 
-class MainMenu :
+class MainMenu : public bobbygui::MenuDisplayWithTime
-    public bobbygui::MenuDisplayWithTime,
-    public espgui::StaticText<TEXT_MAINMENU>
 {
     using Base = espgui::MenuDisplay;
+
 public:
     MainMenu();
+
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/modessettingsmenu.cpp

@@ -12,10 +12,18 @@
 #include "displays/menus/gametrakmodesettingsmenu.h"
 #include "displays/menus/settingsmenu.h"
 
-using namespace espgui;
+namespace {
+constexpr char TEXT_MODESSETTINGS[] = "Modes settings";
+constexpr char TEXT_DEFAULTMODESETTIGNS[] = "Default mode settings";
+constexpr char TEXT_TEMPOMATMODESETTINGS[] = "Tempomat mode settings";
+constexpr char TEXT_LARSMMODESETTINGS[] = "Larsm mode settings";
+constexpr char TEXT_GAMETRAKMODESETTINGS[] = "Gametrak mode settings";
+constexpr char TEXT_BACK[] = "Back";
+} // namespace
 
 ModesSettingsMenu::ModesSettingsMenu()
 {
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTMODESETTIGNS>,   SwitchScreenAction<DefaultModeSettingsMenu>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TEMPOMATMODESETTINGS>,  SwitchScreenAction<TempomatModeSettingsMenu>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LARSMMODESETTINGS>,     SwitchScreenAction<LarsmModeSettingsMenu>>>();
@@ -25,7 +33,12 @@ ModesSettingsMenu::ModesSettingsMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                  SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string ModesSettingsMenu::text() const
+{
+    return TEXT_MODESSETTINGS;
+}
+
 void ModesSettingsMenu::back()
 {
-    switchScreen<SettingsMenu>();
+    espgui::switchScreen<SettingsMenu>();
 }

main/displays/menus/modessettingsmenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class ModesSettingsMenu :
+class ModesSettingsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_MODESSETTINGS>
 {
 public:
     ModesSettingsMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/mosfetsmenu.cpp

@@ -1,26 +1,53 @@
 #include "mosfetsmenu.h"
 
 #ifdef FEATURE_MOSFETS
-
+// 3rdparty lib includes
+#include "accessorinterface.h"
 #include "actions/switchscreenaction.h"
-#include "actions/toggleboolaction.h"
-#include "checkboxicon.h"
-#include "displays/menus/mainmenu.h"
 #include "icons/back.h"
 
-using namespace espgui;
+// local includes
+#include "displays/menus/mainmenu.h"
+#include "bobbycheckbox.h"
+#include "types.h"
+
+namespace {
+constexpr char TEXT_MOSFETS[] = "Mosfets";
+constexpr char TEXT_MOSFET0[] = "Mosfet0";
+constexpr char TEXT_MOSFET1[] = "Mosfet1";
+constexpr char TEXT_MOSFET2[] = "Mosfet2";
+constexpr char TEXT_BACK[] = "Back";
+
+template<pin_t PIN>
+class GPIOAccessor : public virtual espgui::AccessorInterface<bool>
+{
+public:
+    bool getValue() const override { return digitalRead(PIN); }
+    espgui::AccessorInterface<bool>::setter_result_t setValue(bool value) override { digitalWrite(PIN, value ? HIGH : LOW); return {}; }
+};
+
+using Mosfet0Accessor = GPIOAccessor<PINS_MOSFET0>;
+using Mosfet1Accessor = GPIOAccessor<PINS_MOSFET1>;
+using Mosfet2Accessor = GPIOAccessor<PINS_MOSFET2>;
+} // namespace
 
 MosfetsMenu::MosfetsMenu()
 {
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET0>, ToggleBoolAction, CheckboxIcon, Mosfet0Accessor>>();
+    using namespace espgui;
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET1>, ToggleBoolAction, CheckboxIcon, Mosfet1Accessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET0>, BobbyCheckbox, Mosfet0Accessor>>();
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET2>, ToggleBoolAction, CheckboxIcon, Mosfet2Accessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET1>, BobbyCheckbox, Mosfet1Accessor>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET2>, BobbyCheckbox, Mosfet2Accessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,    SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string MosfetsMenu::text() const
+{
+    return TEXT_MOSFETS;
+}
+
 void MosfetsMenu::back()
 {
-    switchScreen<MainMenu>();
+    espgui::switchScreen<MainMenu>();
 }
 
 #endif

main/displays/menus/mosfetsmenu.h

@@ -1,32 +1,17 @@
 #pragma once
 
 #ifdef FEATURE_MOSFETS
-// 3rdparty lib includes
-#include "accessorinterface.h"
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
-#include "types.h"
 
-template<pin_t PIN>
+class MosfetsMenu : public BobbyMenuDisplay
-class GPIOAccessor : public virtual espgui::AccessorInterface<bool>
-{
-public:
-    bool getValue() const override { return digitalRead(PIN); }
-    espgui::AccessorInterface<bool>::setter_result_t setValue(bool value) override { digitalWrite(PIN, value ? HIGH : LOW); return {}; }
-};
-
-using Mosfet0Accessor = GPIOAccessor<PINS_MOSFET0>;
-using Mosfet1Accessor = GPIOAccessor<PINS_MOSFET1>;
-using Mosfet2Accessor = GPIOAccessor<PINS_MOSFET2>;
-
-class MosfetsMenu :
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_MOSFETS>
 {
 public:
     MosfetsMenu();
+
+    std::string text() const override;
+
     void back() override;
 };
 #endif

main/displays/menus/motorfeedbackdebugmenu.h

@@ -8,7 +8,6 @@
 #include "actions/dummyaction.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
-#include "texts.h"
 #include "debugtexthelpers.h"
 #include "debugcolorhelpers.h"
 
@@ -37,11 +36,21 @@ public:
         constructMenuItem<makeComponent<MenuItem, typename Ttexts::DcPhaCFixedText,  ColorInterface<TFT_DARKGREY>, DummyAction>>();
         constructMenuItem<makeComponent<MenuItem, typename Ttexts::ChopsText,        ColorInterface<TFT_DARKGREY>, DummyAction>>();
         constructMenuItem<makeComponent<MenuItem, typename Ttexts::HallText,         ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                             SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,             SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
     }
+
+private:
+    static constexpr char TEXT_BACK[] = "Back";
 };
 
+constexpr char TEXT_FRONTLEFTFEEDBACK[] = "Front left feedback";
 using FrontLeftMotorFeedbackDebugMenu = MotorFeedbackDebugMenu<TEXT_FRONTLEFTFEEDBACK, FrontTexts::LeftFeedback, FrontFeedbackColor>;
+
+constexpr char TEXT_FRONTRIGHTFEEDBACK[] = "Front right feedback";
 using FrontRightMotorFeedbackDebugMenu = MotorFeedbackDebugMenu<TEXT_FRONTRIGHTFEEDBACK, FrontTexts::RightFeedback, FrontFeedbackColor>;
+
+constexpr char TEXT_BACKLEFTFEEDBACK[] = "Back left feedback";
 using BackLeftMotorFeedbackDebugMenu = MotorFeedbackDebugMenu<TEXT_BACKLEFTFEEDBACK, BackTexts::LeftFeedback, BackFeedbackColor>;
+
+constexpr char TEXT_BACKRIGHTFEEDBACK[] = "Back right feedback";
 using BackRightMotorFeedbackDebugMenu = MotorFeedbackDebugMenu<TEXT_BACKRIGHTFEEDBACK, BackTexts::RightFeedback, BackFeedbackColor>;

main/displays/menus/motorstatedebugmenu.h

@@ -10,7 +10,6 @@
 #include "displays/bobbymenudisplay.h"
 #include "debugmenu.h"
 #include "utils.h"
-#include "texts.h"
 #include "debugtexthelpers.h"
 
 template<const char *Ttext, typename Ttexts>
@@ -36,9 +35,19 @@ public:
         constructMenuItem<makeComponent<MenuItem, typename Ttexts::NCruiseMotTgtText, DisabledColor, DummyAction>>();
         constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,    SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
     }
+
+private:
+    static constexpr char TEXT_BACK[] = "Back";
 };
 
+constexpr char TEXT_FRONTLEFTCOMMAND[] = "Front left command";
 using FrontLeftMotorStateDebugMenu = MotorStateDebugMenu<TEXT_FRONTLEFTCOMMAND, FrontTexts::LeftCommand>;
+
+constexpr char TEXT_FRONTRIGHTCOMMAND[] = "Front right command";
 using FrontRightMotorStateDebugMenu = MotorStateDebugMenu<TEXT_FRONTRIGHTCOMMAND, FrontTexts::RightCommand>;
+
+constexpr char TEXT_BACKLEFTCOMMAND[] = "Back left command";
 using BackLeftMotorStateDebugMenu = MotorStateDebugMenu<TEXT_BACKLEFTCOMMAND, BackTexts::LeftCommand>;
+
+constexpr char TEXT_BACKRIGHTCOMMAND[] = "Back right command";
 using BackRightMotorStateDebugMenu = MotorStateDebugMenu<TEXT_BACKRIGHTCOMMAND, BackTexts::RightCommand>;

main/displays/menus/motortestmodesettingsmenu.cpp

@@ -13,6 +13,11 @@
 #include "displays/menus/modessettingsmenu.h"
 
 namespace {
+constexpr char TEXT_MOTORTESTMODESETTINGS[] = "Motortest mode seetings";
+constexpr char TEXT_MOTORTESTMAXPWM[] = "Max Pwm";
+constexpr char TEXT_MOTORTESTMULTIPLIKATOR[] = "Acceleration";
+constexpr char TEXT_BACK[] = "Back";
+
 using MotortestMultiplikatorChangeDisplay = espgui::makeComponent<
     BobbyChangeValueDisplay<uint8_t>,
     espgui::StaticText<TEXT_MOTORTESTMULTIPLIKATOR>,
@@ -39,6 +44,11 @@ MotortestModeSettingsMenu::MotortestModeSettingsMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                    SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string MotortestModeSettingsMenu::text() const
+{
+    return TEXT_MOTORTESTMODESETTINGS;
+}
+
 void MotortestModeSettingsMenu::back()
 {
     switchScreen<ModesSettingsMenu>();

main/displays/menus/motortestmodesettingsmenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class MotortestModeSettingsMenu :
+class MotortestModeSettingsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_MOTORTESTMODESETTINGS>
 {
 public:
     MotortestModeSettingsMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/networksettingsmenu.cpp

@@ -19,7 +19,7 @@ using namespace espgui;
 namespace {
 constexpr char TEXT_STASETTINGS[] = "STA Settings";
 constexpr char TEXT_APSETTINGS[] = "AP Settings";
-//constexpr char TEXT_BACK[] = "Back";
+constexpr char TEXT_BACK[] = "Back";
 } // namespace
 
 NetworkSettingsMenu::NetworkSettingsMenu()

main/displays/menus/otamenu.cpp

@@ -16,11 +16,18 @@
 #include "displays/updatedisplay.h"
 
 #ifdef FEATURE_OTA
-
+namespace {
-using namespace espgui;
+constexpr char TEXT_UPDATE[] = "Update";
+constexpr char TEXT_UPDATENOW[] = "Update now";
+constexpr char TEXT_SELECTBUILD[] = "Select build";
+constexpr char TEXT_SELECT_BRANCH[] = "Select Branch";
+constexpr char TEXT_SELECTBUILDSERVERMENU[] = "Select Buildserver";
+constexpr char TEXT_BACK[] = "Back";
+} // namespace
 
 OtaMenu::OtaMenu()
 {
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SELECTBUILD>,             SwitchScreenAction<SelectBuildMenu>, StaticMenuItemIcon<&bobbyicons::presets>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SELECT_BRANCH>,           SwitchScreenAction<SelectBuildserverBranchMenu>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_UPDATENOW>,               SwitchScreenAction<UpdateDisplay>, StaticMenuItemIcon<&bobbyicons::update>>>();
@@ -28,8 +35,13 @@ OtaMenu::OtaMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                    SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string OtaMenu::text() const
+{
+    return TEXT_UPDATE;
+}
+
 void OtaMenu::back()
 {
-    switchScreen<MainMenu>();
+    espgui::switchScreen<MainMenu>();
 }
 #endif

main/displays/menus/otamenu.h

@@ -2,14 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class OtaMenu :
+class OtaMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_UPDATE>
 {
 public:
     OtaMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/presetsmenu.cpp

@@ -10,10 +10,28 @@
 #include "menudisplay.h"
 #include "presets.h"
 #include "settings.h"
-#include "texts.h"
 #include "utils.h"
 
 namespace {
+constexpr char TEXT_PRESETS[] = "Presets";
+constexpr char TEXT_DEFAULTEVERYTHING[] = "Default everything";
+constexpr char TEXT_DEFAULTLIMITS[] = "Default limits";
+constexpr char TEXT_KIDSLIMITS[] = "Kids limits";
+constexpr char TEXT_DEFAULTPOTI[] = "Default poti";
+constexpr char TEXT_DEFAULTCONTROLLERHARDWARE[] = "Default controller H/W";
+constexpr char TEXT_MOSFETSOFFCONTROLLERHARDWARE[] = "MOSFETs off controller H/W";
+constexpr char TEXT_SPINNERCONTROLLERHARDWARE[] = "Spinner controller H/W";
+constexpr char TEXT_DEFAULTBOARDCOMPUTERHARDWARE[] = "Default boardcomputer H/W";
+constexpr char TEXT_DEFAULTDEFAULTMODE[] = "Default defaultMode";
+constexpr char TEXT_SINUSOIDALDEFAULTMODE[] = "Sinusoidal defaultMode";
+constexpr char TEXT_DEFAULTTEMPOMATMODE[] = "Default tempomatMode";
+constexpr char TEXT_DEFAULTLARSMMODE[] = "Default larsmMode";
+constexpr char TEXT_STREET[] = "Street";
+constexpr char TEXT_SIDEWALK[] = "Sidewalk";
+constexpr char TEXT_POLICE[] = "Police";
+constexpr char TEXT_RACE[] = "Race";
+constexpr char TEXT_BACK[] = "Back";
+
 class ApplyPresetAction : public virtual ActionInterface
 {
 public:
@@ -86,6 +104,11 @@ PresetsMenu::PresetsMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                         SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string PresetsMenu::text() const
+{
+    return TEXT_PRESETS;
+}
+
 void PresetsMenu::back()
 {
     switchScreen<MainMenu>();

main/displays/menus/presetsmenu.h

@@ -2,13 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class PresetsMenu :
+class PresetsMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_PRESETS>
 {
 public:
     PresetsMenu();
+
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/profilesmenu.cpp

@@ -6,7 +6,15 @@
 #include "displays/menus/mainmenu.h"
 #include "icons/back.h"
 #include "menudisplay.h"
-#include "texts.h"
+
+namespace {
+constexpr char TEXT_PROFILES[] = "Profiles";
+constexpr char TEXT_PROFILE0[] = "Profile 0";
+constexpr char TEXT_PROFILE1[] = "Profile 1";
+constexpr char TEXT_PROFILE2[] = "Profile 2";
+constexpr char TEXT_PROFILE3[] = "Profile 3";
+constexpr char TEXT_BACK[] = "Back";
+} // namespace
 
 ProfilesMenu::ProfilesMenu()
 {
@@ -17,6 +25,11 @@ ProfilesMenu::ProfilesMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,     SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string ProfilesMenu::text() const
+{
+    return TEXT_PROFILES;
+}
+
 void ProfilesMenu::back()
 {
     switchScreen<MainMenu>();

main/displays/menus/profilesmenu.h

@@ -2,13 +2,13 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class ProfilesMenu :
+class ProfilesMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_PROFILES>
 {
 public:
     ProfilesMenu();
+
+    std::string text() const override;
+
     void back() override;
 };