Huge refactoring

main/CMakeLists.txt

@@ -57,7 +57,6 @@ set(headers
     statistics.h
     statustexthelper.h
     taskmanager.h
-    texts.h
     time_bobbycar.h
     types.h
     udpcloud.h
@@ -292,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/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/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/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,14 +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>
 
-// 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:
@@ -49,17 +70,58 @@ 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>,              BobbyCheckbox, BatteryApplyCalibrationAccessor>>();
@@ -75,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,7 +7,6 @@
 // local includes
 #include "globals.h"
 #include "utils.h"
-#include "texts.h"
 #include "displays/menus/mainmenu.h"
 #include "displays/calibratedisplay.h"
 #include "bobbybuttons.h"
@@ -40,7 +39,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);
 

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

@@ -10,22 +10,30 @@
 #include "bletexthelpers.h"
 #include "displays/menus/settingsmenu.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()
 {
+    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

@@ -19,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:
@@ -181,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

@@ -15,6 +15,18 @@
 #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>,
@@ -97,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

@@ -18,6 +18,12 @@
 
 #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>,
@@ -68,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

@@ -26,10 +26,12 @@ public:
         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";
-using FrontCommandDebugMenu = CommandDebugMenu<TEXT_FRONTCOMMAND, FrontTexts>;
-
 constexpr char TEXT_BACKCOMMAND[] = "Back command";
+using FrontCommandDebugMenu = CommandDebugMenu<TEXT_FRONTCOMMAND, FrontTexts>;
 using BackCommandDebugMenu = CommandDebugMenu<TEXT_BACKCOMMAND, BackTexts>;

main/displays/menus/controllerhardwaresettingsmenu.cpp

@@ -19,6 +19,21 @@
 #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>,
@@ -59,10 +74,9 @@ 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>>>();
@@ -78,7 +92,12 @@ ControllerHardwareSettingsMenu::ControllerHardwareSettingsMenu()
     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

@@ -29,7 +29,11 @@
 #include "bobbycheckbox.h"
 
 namespace {
-//constexpr char TEXT_DEBUG[] = "Debug";
+constexpr char TEXT_DEBUG[] = "Debug";
+constexpr char TEXT_TASKMANAGER[] = "Taskmanager";
+constexpr char TEXT_QRCODE_DEBUG[] = "QR Debug";
+constexpr char TEXT_BATTERYDEBUG[] = "Bat Debug Menu";
+constexpr char TEXT_TOGGLECLOUDDEBUG[] = "Cloud Debug";
 //constexpr char TEXT_FRONTCOMMAND[] = "Front command";
 //constexpr char TEXT_BACKCOMMAND[] = "Back command";
 //constexpr char TEXT_FRONTLEFTCOMMAND[] = "Front left command";
@@ -46,7 +50,7 @@ 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";
+constexpr char TEXT_BACK[] = "Back";
 } // namespace
 
 DebugMenu::DebugMenu()
@@ -83,6 +87,11 @@ DebugMenu::DebugMenu()
     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

@@ -18,6 +18,37 @@
 #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>,
@@ -141,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

@@ -19,7 +19,6 @@
 #include "displays/bobbychangevaluedisplay.h"
 #include "utils.h"
 #include "icons/lock.h"
-#include "texts.h"
 #include "bobbycheckbox.h"
 #include "bobbyerrorhandler.h"
 
@@ -39,6 +38,7 @@ 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{};

main/displays/menus/enablemenu.cpp

@@ -9,8 +9,18 @@
 #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()
 {
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTLEFT>,  BobbyCheckbox, FrontLeftEnabledAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTRIGHT>, BobbyCheckbox, FrontRightEnabledAccessor>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKLEFT>,   BobbyCheckbox, BackLeftEnabledAccessor>>();
@@ -18,7 +28,12 @@ EnableMenu::EnableMenu()
     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

@@ -5,6 +5,12 @@
 #include "actions/dummyaction.h"
 #include "actions/switchscreenaction.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"
@@ -12,22 +18,60 @@
 #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>, BobbyCheckbox, espnowmenu::ReceiveTimeStampAccessor>>();
+    using namespace espgui;
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETSFROMBOBBY>, BobbyCheckbox, 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,31 +1,49 @@
 #include "espnowsettingsmenu.h"
 
 #ifdef FEATURE_ESPNOW
+
 // 3rdparty lib includes
 #include "actions/dummyaction.h"
 #include "actions/switchscreenaction.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()
+{
+    using namespace espgui;
     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

@@ -29,6 +29,9 @@ 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";

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

@@ -18,9 +18,11 @@
 #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; } };
@@ -47,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:
@@ -62,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);
@@ -87,7 +91,12 @@ GreenPassMenu::GreenPassMenu()
     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

@@ -12,10 +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>,
@@ -51,6 +58,11 @@ HandbremsSettingsMenu::HandbremsSettingsMenu()
     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

@@ -9,6 +9,15 @@
 #include "displays/menus/controllerhardwaresettingsmenu.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;
@@ -19,6 +28,10 @@ InvertMenu::InvertMenu()
     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

@@ -25,6 +25,30 @@
 // 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>,
@@ -57,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>>
 >;
@@ -81,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,
@@ -89,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,
@@ -102,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
@@ -113,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>, BobbyCheckbox,    EnableLedAnimationAccessor>>();
+    if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_STVO>, BobbyCheckbox, EnableLedstripStVOAccessor>>(); }
+    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, espgui::StaticText<TEXT_LEDSTRIP_STVO>, BobbyCheckbox,   EnableLedstripStVOAccessor>>(); }
-    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_STVO_ENABLEFRONTLIGHT>, BobbyCheckbox,   EnableLedstripStVOFrontlight>>();
-    constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_ALLCUSTOMOFF>, AllCustomLedsOffAction>>();
     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

@@ -11,34 +11,31 @@
 #include "accessors/settingsaccessors.h"
 #include "actions/ledstripblinkactions.h"
 #include "displays/menus/ledstripmenu.h"
+#include "ledstrip.h"
+#include "ledstripdefines.h"
 #include "bobbycheckbox.h"
 
-using namespace espgui;
+namespace {
+constexpr char TEXT_BLINKANIMATION[] = "Blink animation";
+constexpr char TEXT_ANIMATION_BLINKNONE[] = "Blink Off";
+constexpr char TEXT_ANIMATION_BLINKLEFT[] = "Blink Left";
+constexpr char TEXT_ANIMATION_BLINKRIGHT[] = "Blink Right";
+constexpr char TEXT_ANIMATION_BLINKBOTH[] = "Blink Both";
+constexpr char TEXT_LEDSTRIP_EN_BLINK_ANIM[] = "Animated Blink";
+constexpr char TEXT_BACK[] = "Back";
 
-std::string currentSelectedBlinkAnimationText::text() const {
+class CurrentSelectedBlinkAnimationText : public virtual espgui::TextInterface
-    switch (blinkAnimation) {
+{
-        case LEDSTRIP_OVERWRITE_BLINKLEFT:
+public:
-#ifndef LEDSTRIP_WRONG_DIRECTION
+    std::string text() const override;
-            return TEXT_ANIMATION_BLINKLEFT;
+};
-#else
+
-            return TEXT_ANIMATION_BLINKRIGHT;
+} // namespace
-#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;
-    }
-}
 
 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>>();
@@ -48,8 +45,40 @@ LedstripSelectBlinkMenu::LedstripSelectBlinkMenu()
     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

@@ -15,6 +15,15 @@
 #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>,
@@ -48,10 +57,9 @@ using LockscreenPinDigit3ChangeScreen = espgui::makeComponent<
 >;
 } // namespace
 
-using namespace espgui;
-
 LockscreenSettingsMenu::LockscreenSettingsMenu()
 {
+    using namespace espgui;
     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>>>();
@@ -61,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

@@ -1,5 +1,7 @@
 #include "mainmenu.h"
 
+// esp-idf includes
+
 // 3rdparty lib includes
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
@@ -52,23 +54,42 @@
 #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;
+
+    ESP_LOGI(TAG, "called");
+
     // 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 +98,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 +108,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

@@ -2,26 +2,52 @@
 
 #ifdef FEATURE_MOSFETS
 // 3rdparty lib includes
+#include "accessorinterface.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
 
 // local includes
 #include "displays/menus/mainmenu.h"
 #include "bobbycheckbox.h"
+#include "types.h"
 
-using namespace espgui;
+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()
 {
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET0>, BobbyCheckbox, Mosfet0Accessor>>();
     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"
 
@@ -39,6 +38,9 @@ public:
         constructMenuItem<makeComponent<MenuItem, typename Ttexts::HallText,         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_FRONTLEFTFEEDBACK[] = "Front left feedback";

main/displays/menus/motorstatedebugmenu.h

@@ -35,6 +35,9 @@ 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";

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;
 };

main/displays/menus/selectbatterytypemenu.cpp

@@ -1,13 +1,44 @@
 #include "selectbatterytypemenu.h"
 
+// 3rdparty lib includes
+#include <menuitem.h>
+#include <icons/back.h>
+#include <actions/switchscreenaction.h>
+#include <actioninterface.h>
+#include <actions/dummyaction.h>
+
 // local includes
 #include "battery.h"
 #include "globals.h"
 #include "utils.h"
 #include "displays/menus/batterymenu.h"
+#include "batterymenu.h"
+#include "displays/menus/mainmenu.h"
 
 namespace {
-class CurrentBatteryTypeText : public virtual espgui::TextInterface { public: std::string text() const override { return getBatteryCellTypeString(); } };
+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 CurrentBatteryTypeText : public virtual espgui::TextInterface
+{
+public:
+    std::string text() const override
+    {
+        return getBatteryCellTypeString();
+    }
+};
 
 template<BatteryCellType T>
 class BatterySelectTypeAction : public virtual espgui::ActionInterface
@@ -17,10 +48,9 @@ public:
 };
 } // namespace
 
-using namespace espgui;
-
 BatteryTypeMenu::BatteryTypeMenu()
 {
+    using namespace espgui;
     constructMenuItem<makeComponent<MenuItem, CurrentBatteryTypeText,             DisabledColor, DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_TYPE_22P>,  BatterySelectTypeAction<BatteryCellType::_22P>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_TYPE_HG2>,  BatterySelectTypeAction<BatteryCellType::HG2>>>();
@@ -30,6 +60,11 @@ BatteryTypeMenu::BatteryTypeMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string BatteryTypeMenu::text() const
+{
+    return TEXT_SELECT_CELL_TYPE;
+}
+
 void BatteryTypeMenu::back()
 {
     espgui::switchScreen<BatteryMenu>();

main/displays/menus/selectbatterytypemenu.h

@@ -1,23 +1,14 @@
 #pragma once
 
-// 3rdparty lib includes
-#include <menuitem.h>
-#include <icons/back.h>
-#include <actions/switchscreenaction.h>
-#include <actioninterface.h>
-
 // Local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
-#include "batterymenu.h"
-#include "displays/menus/mainmenu.h"
 
-class BatteryTypeMenu :
+class BatteryTypeMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_SELECT_CELL_TYPE>
 {
 public:
     BatteryTypeMenu();
 
+    std::string text() const override;
+
     void back() override;
 };

main/displays/menus/selectbuildserverbranch.cpp

@@ -15,15 +15,14 @@
 #include "utils.h"
 #include "newsettings.h"
 
-#define ERR_MESSAGE(text)                                                                                                                       \
-    constructMenuItem<makeComponent<MenuItem, StaticText<text>, DefaultFont, StaticColor<TFT_RED>, DummyAction>>();                             \
-    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>(); \
-    return;
-
-using namespace espgui;
-using namespace buildserver;
-
 namespace {
+constexpr char TEXT_OTA_NOBUILDSERVERAVAILABLE[] = "E:No server saved.";
+constexpr char TEXT_OTA_NOBUILDSERVERSELECTED[] = "E:No server selected.";
+constexpr char TEXT_OTA_NOCONNECTION[] = "E:No internet.";
+constexpr char TEXT_SELECT_BRANCH[] = "Select Branch";
+constexpr char TEXT_SELECT_BRANCH_CLEAR[] = "Clear Branch";
+constexpr char TEXT_BACK[] = "Back";
+
 class CurrentBranch : public virtual espgui::TextInterface
 {
 public:
@@ -83,6 +82,14 @@ void ClearBranchAction::triggered()
 
 SelectBuildserverBranchMenu::SelectBuildserverBranchMenu()
 {
+    using namespace espgui;
+    using namespace buildserver;
+
+#define ERR_MESSAGE(text)                                                                                                                       \
+    constructMenuItem<makeComponent<MenuItem, StaticText<text>, DefaultFont, StaticColor<TFT_RED>, DummyAction>>();                             \
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>(); \
+    return;
+
     if (count_available_buildserver() < 1)
     {
         ERR_MESSAGE(TEXT_OTA_NOBUILDSERVERAVAILABLE); // E:No server saved.
@@ -97,14 +104,22 @@ SelectBuildserverBranchMenu::SelectBuildserverBranchMenu()
     {
         ERR_MESSAGE(TEXT_OTA_NOCONNECTION); // E:No internet.
     }
+#undef ERR_MESSAGE
 
     SelectBranch::setup_request();
     SelectBranch::start_descriptor_request(configs.otaServerUrl.value);
 }
 
+std::string SelectBuildserverBranchMenu::text() const
+{
+    return TEXT_SELECT_BRANCH;
+}
+
 void SelectBuildserverBranchMenu::update()
 {
-    using namespace SelectBranch;
+    using namespace espgui;
+    using namespace buildserver::SelectBranch;
+
     if(get_request_running())
     {
         check_descriptor_request();
@@ -138,11 +153,13 @@ void SelectBuildserverBranchMenu::update()
 
 void SelectBuildserverBranchMenu::back()
 {
-    switchScreen<OtaMenu>();
+    espgui::switchScreen<OtaMenu>();
 }
 
 void SelectBuildserverBranchMenu::buildMenuRequestError(std::string error)
 {
+    using namespace espgui;
+
     auto &item = constructMenuItem<makeComponent<MenuItem, ChangeableText, DefaultFont, StaticColor<TFT_RED>, DummyAction>>();
     item.setTitle(error);
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();

main/displays/menus/selectbuildserverbranch.h

@@ -2,18 +2,17 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
 #ifdef FEATURE_OTA
 
-class SelectBuildserverBranchMenu :
+class SelectBuildserverBranchMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_SELECT_BRANCH>
 {
     using Base = espgui::MenuDisplay;
 public:
     SelectBuildserverBranchMenu();
 
+    std::string text() const override;
+
     void buildMenuRequestError(std::string error);
     void update() override;
     void back() override;

main/displays/menus/selectbuildservermenu.cpp

@@ -18,9 +18,12 @@
 #ifdef FEATURE_OTA
 
 using namespace buildserver::SelectBuild;
-using namespace espgui;
 
 namespace {
+constexpr char TEXT_SELECTBUILDSERVERMENU[] = "Select Buildserver";
+constexpr char TEXT_NOBUILDSERVERCONFIGURED[] = "Not configured";
+constexpr char TEXT_BACK[] = "Back";
+
 class BuildserverMenuItem : public espgui::MenuItem
 {
 public:
@@ -49,6 +52,8 @@ private:
 
 SelectBuildServerMenu::SelectBuildServerMenu()
 {
+    using namespace espgui;
+
     for (const auto &otaServer : configs.otaServers)
     {
         std::string url = otaServer.url.value;
@@ -70,6 +75,11 @@ SelectBuildServerMenu::SelectBuildServerMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string SelectBuildServerMenu::text() const
+{
+    return TEXT_SELECTBUILDSERVERMENU;
+}
+
 void SelectBuildServerMenu::back()
 {
     espgui::switchScreen<OtaMenu>();

main/displays/menus/selectbuildservermenu.h

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

main/displays/menus/selectmodemenu.cpp

@@ -19,6 +19,15 @@
 #include "displays/menus/mainmenu.h"
 
 namespace {
+constexpr char TEXT_SELECTMODE[] = "Select mode";
+constexpr char TEXT_DEFAULT[] = "Default";
+constexpr char TEXT_TEMPOMAT[] = "Tempomat";
+constexpr char TEXT_LARSM[] = "Larsm";
+constexpr char TEXT_REMOTECONTROL[] = "Remote control";
+constexpr char TEXT_GAMETRAK[] = "Gametrak";
+constexpr char TEXT_MOTORTEST[] = "Motortest";
+constexpr char TEXT_BACK[] = "Back";
+
 template<typename T1, T1 &target, typename T2, T2 value>
 class SetterAction : public espgui::ActionInterface
 {
@@ -50,6 +59,11 @@ SelectModeMenu::SelectModeMenu()
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,      SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
 }
 
+std::string SelectModeMenu::text() const
+{
+    return TEXT_SELECTMODE;
+}
+
 void SelectModeMenu::start()
 {
     Base::start();

main/displays/menus/selectmodemenu.h

@@ -2,17 +2,16 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
-class SelectModeMenu :
+class SelectModeMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_SELECTMODE>
 {
     using Base = BobbyMenuDisplay;
 
 public:
     SelectModeMenu();
 
+    std::string text() const override;
+
     void start() override;
     void back() override;
 };

main/displays/menus/selectotabuildmenu.cpp

@@ -22,6 +22,14 @@ using namespace espgui;
 using namespace buildserver::SelectBuild;
 
 namespace {
+constexpr char TEXT_UPDATENOW[] = "Update now";
+constexpr char TEXT_SELECTBUILD[] = "Select build";
+constexpr char TEXT_OTA_NOBUILDSERVERAVAILABLE[] = "E:No server saved.";
+constexpr char TEXT_OTA_NOBUILDSERVERSELECTED[] = "E:No server selected.";
+constexpr char TEXT_OTA_NOCONNECTION[] = "E:No internet.";
+constexpr char TEXT_OTA_WAITFORRESPONSE[] = "Wait for response...";
+constexpr char TEXT_BACK[] = "Back";
+
 template<int item_color>
 class VersionMenuItem : public MenuItem
 {
@@ -89,6 +97,11 @@ SelectBuildMenu::SelectBuildMenu()
     }
 }
 
+std::string SelectBuildMenu::text() const
+{
+    return TEXT_SELECTBUILD;
+}
+
 void SelectBuildMenu::update()
 {
     if(get_request_running())

main/displays/menus/selectotabuildmenu.h

@@ -2,18 +2,18 @@
 
 // local includes
 #include "displays/bobbymenudisplay.h"
-#include "texts.h"
 
 #ifdef FEATURE_OTA
 
-class SelectBuildMenu :
+class SelectBuildMenu : public BobbyMenuDisplay
-    public BobbyMenuDisplay,
-    public espgui::StaticText<TEXT_SELECTBUILD>
 {
     using Base = BobbyMenuDisplay;
 
 public:
     SelectBuildMenu();
+
+    std::string text() const override;
+
     void update() override;
     void back() override;