More program space savings by removing menu item interface abstraction

2021-01-03 03:44:15 +01:00
parent 5ae0e6314e
commit b87a3c5fbc
53 changed files with 773 additions and 1065 deletions
--- a/platformio.ini
+++ b/platformio.ini
@ -8,6 +8,9 @@
 ; Please visit documentation for the other options and examples
 ; https://docs.platformio.org/page/projectconf.html

+[platformio]
+inc_dir = src/espcpputils
+
 [common_env_data]
 platform = espressif32
 board = esp32dev
@ -96,7 +99,7 @@ platform = ${common_env_data.platform}
 board = ${common_env_data.board}
 framework = ${common_env_data.framework}
 platform_packages = ${common_env_data.platform_packages}
-board_build.partitions = partitions_4M_noota.csv
+board_build.partitions = partitions_4M_ota.csv
 lib_deps =
  ${common_env_data.lib_deps}
  ${webserver_common.lib_deps}
@ -130,7 +133,8 @@ build_flags =
  -DDEVICE_PREFIX=bobbyquad
  -DAP_PASSWORD=Passwort_123
  ${webserver_common.build_flags}
-;  -DFEATURE_OTA
+  -DFEATURE_ARDUINOOTA
+;  -DFEATURE_WEBOTA
  -DFEATURE_DPAD_5WIRESW
  -DPINS_DPAD_5WIRESW_OUT=32
  -DPINS_DPAD_5WIRESW_IN1=25
@ -150,8 +154,8 @@ build_flags =
  -DDEFAULT_GASMAX=3700
  -DDEFAULT_BREMSMIN=1300
  -DDEFAULT_BREMSMAX=4000
-  -DFEATURE_BLUETOOTH
-  -DFEATURE_BMS
+;  -DFEATURE_BLUETOOTH
+;  -DFEATURE_BMS
 ;  -DFEATURE_GAMETRAK
 ;  -DPINS_GAMETRAKX=34
 ;  -DPINS_GAMETRAKY=39
@ -212,7 +216,7 @@ build_flags =
  -DDEVICE_PREFIX=bobbycar
  -DAP_PASSWORD=Passwort_123
  ${webserver_common.build_flags}
-  -DFEATURE_OTA
+  -DFEATURE_ARDUINOOTA
  -DDEFAULT_GASMIN=400
  -DDEFAULT_GASMAX=2000
  -DDEFAULT_BREMSMIN=600
@ -276,7 +280,7 @@ build_flags =
  -DDEVICE_PREFIX=bobbyquad
  -DAP_PASSWORD=Passwort_123
  ${webserver_common.build_flags}
-  -DFEATURE_OTA
+  -DFEATURE_ARDUINOOTA
  -DFEATURE_DPAD
  -DPINS_DPAD_UP=32
  -DPINS_DPAD_DOWN=22
@ -310,7 +314,7 @@ build_flags =
  -DDEVICE_PREFIX=bobbyquad
  -DAP_PASSWORD=Passwort_123
  ${webserver_common.build_flags}
-  -DFEATURE_OTA
+  -DFEATURE_ARDUINOOTA
  -DRPI_DISPLAY_TYPE
  -DR61581_DRIVER
 ; TODO: TFT_MISO (touch MISO?)
@ -359,7 +363,7 @@ build_flags =
  -DDEVICE_PREFIX=bobbycar
  -DAP_PASSWORD=Passwort_123
  ${webserver_common.build_flags}
-  -DFEATURE_OTA
+  -DFEATURE_ARDUINOOTA
  -DDEFAULT_GASMIN=1000
  -DDEFAULT_GASMAX=4000
  -DDEFAULT_BREMSMIN=200
--- a/src/bobby_webserver.h
+++ b/src/bobby_webserver.h
@ -8,11 +8,15 @@
 #include "textinterface.h"
 #include "menudisplay.h"
 #include "changevaluedisplay.h"
+#include "displays/updatedisplay.h"
+//#include "esputils.h"

 namespace {
 #ifdef FEATURE_WEBSERVER
 AsyncWebServer webServer{80};

+bool shouldReboot;
+
 class HtmlTag {
 public:
    HtmlTag(const char *tagName, AsyncResponseStream *response) :
@ -34,6 +38,8 @@ private:

 void initWebserver()
 {
+    shouldReboot = false;
+
    DefaultHeaders::Instance().addHeader("Access-Control-Allow-Origin", "*");

    webServer.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
@ -184,7 +190,7 @@ void initWebserver()
            return;
        }

-        if (index < 0 || index >= menuDisplay->size())
+        if (index < 0 || index >= menuDisplay->menuItemCount())
        {
            request->send(400, "text/plain", "index out of range");
            return;
@ -235,11 +241,111 @@ void initWebserver()
        request->send(response);
    });

+
+#ifdef FEATURE_WEBOTA
+    webServer.on("/update", HTTP_GET, [](AsyncWebServerRequest *request){
+        request->send(200, "text/html",
+                      "<form method=\"POST\" action=\"/updateCode\" enctype=\"multipart/form-data\">"
+                      "<input type=\"file\" name=\"update\">"
+                      "<input type=\"submit\" value=\"Update Code\">"
+                      "</form>"
+                      "<form method=\"POST\" action=\"/updateData\" enctype=\"multipart/form-data\">"
+                      "<input type=\"file\" name=\"update\">"
+                      "<input type=\"submit\" value=\"Update Data\">"
+                      "</form>");
+    });
+
+    const auto handleUpdate = [](AsyncWebServerRequest *request){
+        shouldReboot = !Update.hasError();
+
+        AsyncWebServerResponse *response = request->beginResponse(200, "text/plain", shouldReboot ? "OK" : "FAIL");
+        response->addHeader("Connection", "close");
+        request->send(response);
+    };
+
+    const auto createHandleUpdtateUpload = [](size_t size, int command){
+        return [size, command](AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final){
+            //ESP_UNUSED(request)
+
+            Serial.printf("callback %u %u\r\n", index, len);
+
+            if (!index)
+            {
+                Serial.printf("Update Start: %s\r\n", filename.c_str());
+                //Update.runAsync(true);
+                if (!Update.begin(size, command))
+                    Update.printError(Serial);
+
+                String type;
+                if (ArduinoOTA.getCommand() == U_FLASH)
+                    type = "sketch";
+                else if (ArduinoOTA.getCommand() == U_SPIFFS) // U_SPIFFS
+                    type = "filesystem";
+                else
+                    type = "unknown";
+
+                switchScreenImpl<UpdateDisplay>("Updating " + type);
+            }
+
+            if (!Update.hasError())
+            {
+                if (Update.write(data, len) == len)
+                {
+                    ((UpdateDisplay*)currentDisplay.get())->m_progress = index;
+                    ((UpdateDisplay*)currentDisplay.get())->m_total = size;
+                    ((UpdateDisplay*)currentDisplay.get())->redraw();
+                }
+                else
+                {
+                    Update.printError(Serial);
+
+                    ((UpdateDisplay*)currentDisplay.get())->m_error = {};
+                    ((UpdateDisplay*)currentDisplay.get())->m_errorValid = true;
+                    ((UpdateDisplay*)currentDisplay.get())->redraw();
+                }
+            }
+            else
+            {
+                ((UpdateDisplay*)currentDisplay.get())->m_error = {};
+                ((UpdateDisplay*)currentDisplay.get())->m_errorValid = true;
+                ((UpdateDisplay*)currentDisplay.get())->redraw();
+            }
+
+            if (final)
+            {
+                if (Update.end(true))
+                {
+                    Serial.printf("Update Success: %uB\r\n", index + len);
+
+                    ((UpdateDisplay*)currentDisplay.get())->m_finished = true;
+                    ((UpdateDisplay*)currentDisplay.get())->redraw();
+                }
+                else
+                {
+                    Update.printError(Serial);
+
+                    ((UpdateDisplay*)currentDisplay.get())->m_error = {};
+                    ((UpdateDisplay*)currentDisplay.get())->m_errorValid = true;
+                    ((UpdateDisplay*)currentDisplay.get())->redraw();
+                }
+            }
+        };
+    };
+
+    webServer.on("/updateCode", HTTP_POST, handleUpdate, createHandleUpdtateUpload((ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000, U_FLASH));
+    webServer.on("/updateData", HTTP_POST, handleUpdate, createHandleUpdtateUpload(UPDATE_SIZE_UNKNOWN, U_SPIFFS));
+#endif
+
    webServer.begin();
 }

 void handleWebserver()
 {
+    if (shouldReboot)
+    {
+        shouldReboot = false;
+        ESP.restart();
+    }
 }
 #endif
 }
--- a/src/changevaluedisplay_bluetoothmode.h
+++ b/src/changevaluedisplay_bluetoothmode.h
@ -22,66 +22,30 @@ class ChangeValueDisplay<BluetoothMode> :
    using Base = MenuDisplay;

 public:
+    ChangeValueDisplay();
+
    void start() override;
-
-    std::size_t size() const override { return 4; }
-
-    MenuItem& getMenuItem(std::size_t index) override
-    {
-        switch (index)
-        {
-        case 0: return m_offAction;
-        case 1: return m_masterAction;
-        case 2: return m_slaveAction;
-        case 3: return m_backItem;
-        }
-
-        throw "aua";
-    }
-    const MenuItem& getMenuItem(std::size_t index) const override
-    {
-        switch (index)
-        {
-        case 0: return m_offAction;
-        case 1: return m_masterAction;
-        case 2: return m_slaveAction;
-        case 3: return m_backItem;
-        }
-
-        throw "aua";
-    }
-
-    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
-    {
-        callback(m_offAction);
-        callback(m_masterAction);
-        callback(m_slaveAction);
-        callback(m_backItem);
-    }
-    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
-    {
-        callback(m_offAction);
-        callback(m_masterAction);
-        callback(m_slaveAction);
-        callback(m_backItem);
-    }
-
-private:
-    makeComponentArgs<MenuItem, SetValueAction<BluetoothMode>, StaticText<TEXT_OFF>> m_offAction{BluetoothMode::Off, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<BluetoothMode>, StaticText<TEXT_MASTER>> m_masterAction{BluetoothMode::Master, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<BluetoothMode>, StaticText<TEXT_SLAVE>> m_slaveAction{BluetoothMode::Slave, *this, *this};
-    makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
 };

+ChangeValueDisplay<BluetoothMode>::ChangeValueDisplay()
+{
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<BluetoothMode>, StaticText<TEXT_OFF>>>(BluetoothMode::Off, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<BluetoothMode>, StaticText<TEXT_MASTER>>>(BluetoothMode::Master, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<BluetoothMode>, StaticText<TEXT_SLAVE>>>(BluetoothMode::Slave, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
+}
+
 void ChangeValueDisplay<BluetoothMode>::start()
 {
    Base::start();

-    if (getValue() == m_offAction.value())    setSelectedIndex(0); else
-    if (getValue() == m_masterAction.value()) setSelectedIndex(1); else
-    if (getValue() == m_slaveAction.value())  setSelectedIndex(2); else
+    switch (const auto value = getValue())
    {
-        Serial.printf("Unknown BluetoothMode: %i", int(getValue()));
+    case BluetoothMode::Off:    setSelectedIndex(0); break;
+    case BluetoothMode::Master: setSelectedIndex(1); break;
+    case BluetoothMode::Slave:  setSelectedIndex(2); break;
+    default:
+        Serial.printf("Unknown BluetoothMode: %i\r\n", int(value));
        setSelectedIndex(4);
    }
 }
--- a/src/changevaluedisplay_bool.h
+++ b/src/changevaluedisplay_bool.h
@ -19,57 +19,26 @@ class ChangeValueDisplay<bool> :
    using Base = MenuDisplay;

 public:
+    ChangeValueDisplay();
+
    void start() override;
-
-    std::size_t size() const override { return 4; }
-
-    MenuItem& getMenuItem(std::size_t index) override
-    {
-        switch (index)
-        {
-        case 0: return m_trueItem;
-        case 1: return m_falseItem;
-        case 2: return m_backItem;
-        }
-
-        throw "aua";
-    }
-    const MenuItem& getMenuItem(std::size_t index) const override
-    {
-        switch (index)
-        {
-        case 0: return m_trueItem;
-        case 1: return m_falseItem;
-        case 2: return m_backItem;
-        }
-
-        throw "aua";
-    }
-
-    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
-    {
-        callback(m_trueItem);
-        callback(m_falseItem);
-        callback(m_backItem);
-    }
-    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
-    {
-        callback(m_trueItem);
-        callback(m_falseItem);
-        callback(m_backItem);
-    }
-
-private:
-    makeComponentArgs<MenuItem, SetValueAction<bool>, StaticText<TEXT_TRUE>> m_trueItem{true, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<bool>, StaticText<TEXT_FALSE>> m_falseItem{false, *this, *this};
-    makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
 };

+ChangeValueDisplay<bool>::ChangeValueDisplay()
+{
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<bool>, StaticText<TEXT_TRUE>>>(true, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<bool>, StaticText<TEXT_FALSE>>>(false, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
+}
+
 void ChangeValueDisplay<bool>::start()
 {
    Base::start();

-    if (getValue() == m_trueItem.value())  setSelectedIndex(0); else
-    if (getValue() == m_falseItem.value()) setSelectedIndex(1);
+    switch (getValue())
+    {
+    case true:  setSelectedIndex(0); break;
+    case false: setSelectedIndex(1); break;
+    }
 }
 }
--- a/src/changevaluedisplay_controlmode.h
+++ b/src/changevaluedisplay_controlmode.h
@ -18,72 +18,32 @@ class ChangeValueDisplay<ControlMode> :
    using Base = MenuDisplay;

 public:
+    ChangeValueDisplay();
+
    void start() override;
-
-    std::size_t size() const override { return 5; }
-
-    MenuItem& getMenuItem(std::size_t index) override
-    {
-        switch (index)
-        {
-        case 0: return m_openModeItem;
-        case 1: return m_voltageItem;
-        case 2: return m_speedItem;
-        case 3: return m_torqueItem;
-        case 4: return m_backItem;
-        }
-
-        throw "aua";
-    }
-    const MenuItem& getMenuItem(std::size_t index) const override
-    {
-        switch (index)
-        {
-        case 0: return m_openModeItem;
-        case 1: return m_voltageItem;
-        case 2: return m_speedItem;
-        case 3: return m_torqueItem;
-        case 4: return m_backItem;
-        }
-
-        throw "aua";
-    }
-
-    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
-    {
-        callback(m_openModeItem);
-        callback(m_voltageItem);
-        callback(m_speedItem);
-        callback(m_torqueItem);
-        callback(m_backItem);
-    }
-    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
-    {
-        callback(m_openModeItem);
-        callback(m_voltageItem);
-        callback(m_speedItem);
-        callback(m_torqueItem);
-        callback(m_backItem);
-    }
-
-private:
-    makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_OPENMODE>> m_openModeItem{ControlMode::OpenMode, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_VOLTAGE>> m_voltageItem{ControlMode::Voltage, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_SPEED>> m_speedItem{ControlMode::Speed, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_TORQUE>> m_torqueItem{ControlMode::Torque, *this, *this};
-    makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem;
 };

+ChangeValueDisplay<ControlMode>::ChangeValueDisplay()
+{
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_OPENMODE>>>(ControlMode::OpenMode, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_VOLTAGE>>>(ControlMode::Voltage, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_SPEED>>>(ControlMode::Speed, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_TORQUE>>>(ControlMode::Torque, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
+}
+
 void ChangeValueDisplay<ControlMode>::start()
 {
    Base::start();

-    if (getValue() == m_openModeItem.value()) setSelectedIndex(0); else
-    if (getValue() == m_voltageItem.value())  setSelectedIndex(1); else
-    if (getValue() == m_speedItem.value())    setSelectedIndex(2); else
-    if (getValue() == m_torqueItem.value())   setSelectedIndex(3); else
+    switch (const auto value = getValue())
    {
-        Serial.printf("Unknown ControlMode: %i", int(getValue()));
+    case ControlMode::OpenMode: setSelectedIndex(0); break;
+    case ControlMode::Voltage:  setSelectedIndex(1); break;
+    case ControlMode::Speed:    setSelectedIndex(2); break;
+    case ControlMode::Torque:   setSelectedIndex(3); break;
+    default:
+        Serial.printf("Unknown ControlMode: %i\r\n", int(value));
        setSelectedIndex(4);
    }
 }
--- a/src/changevaluedisplay_controltype.h
+++ b/src/changevaluedisplay_controltype.h
@ -18,66 +18,30 @@ class ChangeValueDisplay<ControlType> :
    using Base = MenuDisplay;

 public:
+    ChangeValueDisplay();
+
    void start() override;
-
-    std::size_t size() const override { return 4; }
-
-    MenuItem& getMenuItem(std::size_t index) override
-    {
-        switch (index)
-        {
-        case 0: return m_commutationItem;
-        case 1: return m_sinusoidalItem;
-        case 2: return m_fieldOrientedControlItem;
-        case 3: return m_backItem;
-        }
-
-        throw "aua";
-    }
-    const MenuItem& getMenuItem(std::size_t index) const override
-    {
-        switch (index)
-        {
-        case 0: return m_commutationItem;
-        case 1: return m_sinusoidalItem;
-        case 2: return m_fieldOrientedControlItem;
-        case 3: return m_backItem;
-        }
-
-        throw "aua";
-    }
-
-    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
-    {
-        callback(m_commutationItem);
-        callback(m_sinusoidalItem);
-        callback(m_fieldOrientedControlItem);
-        callback(m_backItem);
-    }
-    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
-    {
-        callback(m_commutationItem);
-        callback(m_sinusoidalItem);
-        callback(m_fieldOrientedControlItem);
-        callback(m_backItem);
-    }
-
-private:
-    makeComponentArgs<MenuItem, SetValueAction<ControlType>, StaticText<TEXT_COMMUTATION>> m_commutationItem{ControlType::Commutation, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<ControlType>, StaticText<TEXT_SINUSOIDAL>> m_sinusoidalItem{ControlType::Sinusoidal, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<ControlType>, StaticText<TEXT_FIELDORIENTEDCONTROL>> m_fieldOrientedControlItem{ControlType::FieldOrientedControl, *this, *this};
-    makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
 };

+ChangeValueDisplay<ControlType>::ChangeValueDisplay()
+{
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlType>, StaticText<TEXT_COMMUTATION>>>(ControlType::Commutation, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlType>, StaticText<TEXT_SINUSOIDAL>>>(ControlType::Sinusoidal, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlType>, StaticText<TEXT_FIELDORIENTEDCONTROL>>>(ControlType::FieldOrientedControl, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
+}
+
 void ChangeValueDisplay<ControlType>::start()
 {
    Base::start();

-    if (getValue() == m_commutationItem.value())          setSelectedIndex(0); else
-    if (getValue() == m_sinusoidalItem.value())           setSelectedIndex(1); else
-    if (getValue() == m_fieldOrientedControlItem.value()) setSelectedIndex(2); else
+    switch (const auto value = getValue())
    {
-        Serial.printf("Unknown ControlType: %i", int(getValue()));
+    case ControlType::Commutation:          setSelectedIndex(0); break;
+    case ControlType::Sinusoidal:           setSelectedIndex(1); break;
+    case ControlType::FieldOrientedControl: setSelectedIndex(2); break;
+    default:
+        Serial.printf("Unknown ControlType: %i\r\n", int(value));
        setSelectedIndex(3);
    }
 }
--- a/src/changevaluedisplay_larsmmode_mode.h
+++ b/src/changevaluedisplay_larsmmode_mode.h
@ -19,72 +19,32 @@ class ChangeValueDisplay<LarsmModeMode> :
    using Base = MenuDisplay;

 public:
+    ChangeValueDisplay();
+
    void start() override;
-
-    std::size_t size() const override { return 5; }
-
-    MenuItem& getMenuItem(std::size_t index) override
-    {
-        switch (index)
-        {
-        case 0: return m_larsmMode1Item;
-        case 1: return m_larsmMode2Item;
-        case 2: return m_larsmMode3Item;
-        case 3: return m_larsmMode4Item;
-        case 4: return m_backItem;
-        }
-
-        throw "aua";
-    }
-    const MenuItem& getMenuItem(std::size_t index) const override
-    {
-        switch (index)
-        {
-        case 0: return m_larsmMode1Item;
-        case 1: return m_larsmMode2Item;
-        case 2: return m_larsmMode3Item;
-        case 3: return m_larsmMode4Item;
-        case 4: return m_backItem;
-        }
-
-        throw "aua";
-    }
-
-    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
-    {
-        callback(m_larsmMode1Item);
-        callback(m_larsmMode2Item);
-        callback(m_larsmMode3Item);
-        callback(m_larsmMode4Item);
-        callback(m_backItem);
-    }
-    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
-    {
-        callback(m_larsmMode1Item);
-        callback(m_larsmMode2Item);
-        callback(m_larsmMode3Item);
-        callback(m_larsmMode4Item);
-        callback(m_backItem);
-    }
-
-private:
-    makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE1>> m_larsmMode1Item{LarsmModeMode::Mode1, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE2>> m_larsmMode2Item{LarsmModeMode::Mode2, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE3>> m_larsmMode3Item{LarsmModeMode::Mode3, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE4>> m_larsmMode4Item{LarsmModeMode::Mode4, *this, *this};
-    makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
 };

+ChangeValueDisplay<LarsmModeMode>::ChangeValueDisplay()
+{
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE1>>>(LarsmModeMode::Mode1, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE2>>>(LarsmModeMode::Mode2, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE3>>>(LarsmModeMode::Mode3, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE4>>>(LarsmModeMode::Mode4, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
+}
+
 void ChangeValueDisplay<LarsmModeMode>::start()
 {
    Base::start();

-    if (getValue() == m_larsmMode1Item.value()) setSelectedIndex(0); else
-    if (getValue() == m_larsmMode2Item.value()) setSelectedIndex(1); else
-    if (getValue() == m_larsmMode3Item.value()) setSelectedIndex(2); else
-    if (getValue() == m_larsmMode4Item.value()) setSelectedIndex(3); else
+    switch (const auto value = getValue())
    {
-        Serial.printf("Unknown LarsmModeMode: %i", int(getValue()));
+    case LarsmModeMode::Mode1: setSelectedIndex(0); break;
+    case LarsmModeMode::Mode2: setSelectedIndex(1); break;
+    case LarsmModeMode::Mode3: setSelectedIndex(2); break;
+    case LarsmModeMode::Mode4: setSelectedIndex(3); break;
+    default:
+        Serial.printf("Unknown LarsmModeMode: %i\r\n", int(value));
        setSelectedIndex(4);
    }
 }
--- a/src/changevaluedisplay_unifiedmodelmode.h
+++ b/src/changevaluedisplay_unifiedmodelmode.h
@ -19,78 +19,34 @@ class ChangeValueDisplay<UnifiedModelMode> :
    using Base = MenuDisplay;

 public:
+    ChangeValueDisplay();
+
    void start() override;
-
-    std::size_t size() const override { return 6; }
-
-    MenuItem& getMenuItem(std::size_t index) override
-    {
-        switch (index)
-        {
-        case 0: return m_commutationItem;
-        case 1: return m_sinusoidalItem;
-        case 2: return m_focVoltageItem;
-        case 3: return m_focSpeedItem;
-        case 4: return m_focTorqueItem;
-        case 5: return m_backItem;
-        }
-
-        throw "aua";
-    }
-    const MenuItem& getMenuItem(std::size_t index) const override
-    {
-        switch (index)
-        {
-        case 0: return m_commutationItem;
-        case 1: return m_sinusoidalItem;
-        case 2: return m_focVoltageItem;
-        case 3: return m_focSpeedItem;
-        case 4: return m_focTorqueItem;
-        case 5: return m_backItem;
-        }
-
-        throw "aua";
-    }
-
-    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
-    {
-        callback(m_commutationItem);
-        callback(m_sinusoidalItem);
-        callback(m_focVoltageItem);
-        callback(m_focSpeedItem);
-        callback(m_focTorqueItem);
-        callback(m_backItem);
-    }
-    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
-    {
-        callback(m_commutationItem);
-        callback(m_sinusoidalItem);
-        callback(m_focVoltageItem);
-        callback(m_focSpeedItem);
-        callback(m_focTorqueItem);
-        callback(m_backItem);
-    }
-
-private:
-    makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_COMMUTATION>> m_commutationItem{UnifiedModelMode::Commutation, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_SINUSOIDAL>> m_sinusoidalItem{UnifiedModelMode::Sinusoidal, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_FOCVOLTAGE>> m_focVoltageItem{UnifiedModelMode::FocVoltage, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_FOCSPEED>> m_focSpeedItem{UnifiedModelMode::FocSpeed, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_FOCTORQUE>> m_focTorqueItem{UnifiedModelMode::FocTorque, *this, *this};
-    makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
 };

+ChangeValueDisplay<UnifiedModelMode>::ChangeValueDisplay()
+{
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_COMMUTATION>>>(UnifiedModelMode::Commutation, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_SINUSOIDAL>>>(UnifiedModelMode::Sinusoidal, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_FOCVOLTAGE>>>(UnifiedModelMode::FocVoltage, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_FOCSPEED>>>(UnifiedModelMode::FocSpeed, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_FOCTORQUE>>>(UnifiedModelMode::FocTorque, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
+}
+
 void ChangeValueDisplay<UnifiedModelMode>::start()
 {
    Base::start();

-    if (getValue() == m_commutationItem.value()) setSelectedIndex(0); else
-    if (getValue() == m_sinusoidalItem.value())  setSelectedIndex(1); else
-    if (getValue() == m_focVoltageItem.value())  setSelectedIndex(2); else
-    if (getValue() == m_focSpeedItem.value())    setSelectedIndex(3); else
-    if (getValue() == m_focTorqueItem.value())   setSelectedIndex(4); else
+    switch (const auto value = getValue())
    {
-        Serial.printf("Unknown UnifiedModelMode: %i", int(getValue()));
+    case UnifiedModelMode::Commutation: setSelectedIndex(0); break;
+    case UnifiedModelMode::Sinusoidal:  setSelectedIndex(1); break;
+    case UnifiedModelMode::FocVoltage:  setSelectedIndex(2); break;
+    case UnifiedModelMode::FocSpeed:    setSelectedIndex(3); break;
+    case UnifiedModelMode::FocTorque:   setSelectedIndex(4); break;
+    default:
+        Serial.printf("Unknown UnifiedModelMode: %i\r\n", int(value));
        setSelectedIndex(5);
    }
 }
--- a/src/changevaluedisplay_wifi_mode_t.h
+++ b/src/changevaluedisplay_wifi_mode_t.h
@ -20,72 +20,32 @@ class ChangeValueDisplay<wifi_mode_t> :
    using Base = MenuDisplay;

 public:
+    ChangeValueDisplay();
+
    void start() override;
-
-    std::size_t size() const override { return 5; }
-
-    MenuItem& getMenuItem(std::size_t index) override
-    {
-        switch (index)
-        {
-        case 0: return m_nullItem;
-        case 1: return m_staItem;
-        case 2: return m_apItem;
-        case 3: return m_apStaItem;
-        case 4: return m_backItem;
-        }
-
-        throw "aua";
-    }
-    const MenuItem& getMenuItem(std::size_t index) const override
-    {
-        switch (index)
-        {
-        case 0: return m_nullItem;
-        case 1: return m_staItem;
-        case 2: return m_apItem;
-        case 3: return m_apStaItem;
-        case 4: return m_backItem;
-        }
-
-        throw "aua";
-    }
-
-    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
-    {
-        callback(m_nullItem);
-        callback(m_staItem);
-        callback(m_apItem);
-        callback(m_apStaItem);
-        callback(m_backItem);
-    }
-    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
-    {
-        callback(m_nullItem);
-        callback(m_staItem);
-        callback(m_apItem);
-        callback(m_apStaItem);
-        callback(m_backItem);
-    }
-
-private:
-    makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_NULL>> m_nullItem{WIFI_MODE_NULL, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_STA>> m_staItem{WIFI_MODE_STA, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_AP>> m_apItem{WIFI_MODE_AP, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_APSTA>> m_apStaItem{WIFI_MODE_APSTA, *this, *this};
-    makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
 };

+ChangeValueDisplay<wifi_mode_t>::ChangeValueDisplay()
+{
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_NULL>>>(WIFI_MODE_NULL, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_STA>>>(WIFI_MODE_STA, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_AP>>>(WIFI_MODE_AP, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_APSTA>>>(WIFI_MODE_APSTA, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
+}
+
 void ChangeValueDisplay<wifi_mode_t>::start()
 {
    Base::start();

-    if (getValue() == m_nullItem.value())  setSelectedIndex(0); else
-    if (getValue() == m_staItem.value())   setSelectedIndex(1); else
-    if (getValue() == m_apItem.value())    setSelectedIndex(2); else
-    if (getValue() == m_apStaItem.value()) setSelectedIndex(3); else
+    switch (const auto value = getValue())
    {
-        Serial.printf("Unknown wifi_mode_t: %i", int(getValue()));
+    case WIFI_MODE_NULL:  setSelectedIndex(0); break;
+    case WIFI_MODE_STA:   setSelectedIndex(1); break;
+    case WIFI_MODE_AP:    setSelectedIndex(2); break;
+    case WIFI_MODE_APSTA: setSelectedIndex(3); break;
+    default:
+        Serial.printf("Unknown wifi_mode_t: %i\r\n", int(value));
        setSelectedIndex(4);
    }
 }
--- a/src/changevaluedisplay_wifi_power_t.h
+++ b/src/changevaluedisplay_wifi_power_t.h
@ -20,120 +20,48 @@ class ChangeValueDisplay<wifi_power_t> :
    using Base = MenuDisplay;

 public:
+    ChangeValueDisplay();
+
    void start() override;
-
-    std::size_t size() const override { return 13; }
-
-    MenuItem& getMenuItem(std::size_t index) override
-    {
-        switch (index)
-        {
-        case 0: return m_19_5dBmItem;
-        case 1: return m_19dBmItem;
-        case 2: return m_18_5dBmItem;
-        case 3: return m_17dBmItem;
-        case 4: return m_15dBmItem;
-        case 5: return m_13dBmItem;
-        case 6: return m_11dBmItem;
-        case 7: return m_8_5dBmItem;
-        case 8: return m_7dBmItem;
-        case 9: return m_5dBmItem;
-        case 10: return m_2dBmItem;
-        case 11: return m_MINUS_1dBmItem;
-        case 12: return m_backItem;
-        }
-
-        throw "aua";
-    }
-    const MenuItem& getMenuItem(std::size_t index) const override
-    {
-        switch (index)
-        {
-        case 0: return m_19_5dBmItem;
-        case 1: return m_19dBmItem;
-        case 2: return m_18_5dBmItem;
-        case 3: return m_17dBmItem;
-        case 4: return m_15dBmItem;
-        case 5: return m_13dBmItem;
-        case 6: return m_11dBmItem;
-        case 7: return m_8_5dBmItem;
-        case 8: return m_7dBmItem;
-        case 9: return m_5dBmItem;
-        case 10: return m_2dBmItem;
-        case 11: return m_MINUS_1dBmItem;
-        case 12: return m_backItem;
-        }
-
-        throw "aua";
-    }
-
-    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
-    {
-        callback(m_19_5dBmItem);
-        callback(m_19dBmItem);
-        callback(m_18_5dBmItem);
-        callback(m_17dBmItem);
-        callback(m_15dBmItem);
-        callback(m_13dBmItem);
-        callback(m_11dBmItem);
-        callback(m_8_5dBmItem);
-        callback(m_7dBmItem);
-        callback(m_5dBmItem);
-        callback(m_2dBmItem);
-        callback(m_MINUS_1dBmItem);
-        callback(m_backItem);
-    }
-    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
-    {
-        callback(m_19_5dBmItem);
-        callback(m_19dBmItem);
-        callback(m_18_5dBmItem);
-        callback(m_17dBmItem);
-        callback(m_15dBmItem);
-        callback(m_13dBmItem);
-        callback(m_11dBmItem);
-        callback(m_8_5dBmItem);
-        callback(m_7dBmItem);
-        callback(m_5dBmItem);
-        callback(m_2dBmItem);
-        callback(m_MINUS_1dBmItem);
-        callback(m_backItem);
-    }
-
-private:
-    makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_19_5dBm>> m_19_5dBmItem{WIFI_POWER_19_5dBm, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_19dBm>> m_19dBmItem{WIFI_POWER_19dBm, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_18_5dBm>> m_18_5dBmItem{WIFI_POWER_18_5dBm, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_17dBm>> m_17dBmItem{WIFI_POWER_17dBm, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_15dBm>> m_15dBmItem{WIFI_POWER_15dBm, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_13dBm>> m_13dBmItem{WIFI_POWER_13dBm, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_11dBm>> m_11dBmItem{WIFI_POWER_11dBm, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_8_5dBm>> m_8_5dBmItem{WIFI_POWER_8_5dBm, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_7dBm>> m_7dBmItem{WIFI_POWER_7dBm, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_5dBm>> m_5dBmItem{WIFI_POWER_5dBm, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_2dBm>> m_2dBmItem{WIFI_POWER_2dBm, *this, *this};
-    makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_MINUS_1dBm>> m_MINUS_1dBmItem{WIFI_POWER_MINUS_1dBm, *this, *this};
-    makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
 };

+ChangeValueDisplay<wifi_power_t>::ChangeValueDisplay()
+{
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_19_5dBm>>>(WIFI_POWER_19_5dBm, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_19dBm>>>(WIFI_POWER_19dBm, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_18_5dBm>>>(WIFI_POWER_18_5dBm, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_17dBm>>>(WIFI_POWER_17dBm, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_15dBm>>>(WIFI_POWER_15dBm, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_13dBm>>>(WIFI_POWER_13dBm, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_11dBm>>>(WIFI_POWER_11dBm, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_8_5dBm>>>(WIFI_POWER_8_5dBm, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_7dBm>>>(WIFI_POWER_7dBm, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_5dBm>>>(WIFI_POWER_5dBm, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_2dBm>>>(WIFI_POWER_2dBm, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_MINUS_1dBm>>>(WIFI_POWER_MINUS_1dBm, *this, *this);
+    constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
+}
+
 void ChangeValueDisplay<wifi_power_t>::start()
 {
    Base::start();

-    if (getValue() == m_19_5dBmItem.value())    setSelectedIndex(0); else
-    if (getValue() == m_19dBmItem.value())      setSelectedIndex(1); else
-    if (getValue() == m_18_5dBmItem.value())    setSelectedIndex(2); else
-    if (getValue() == m_17dBmItem.value())      setSelectedIndex(3); else
-    if (getValue() == m_15dBmItem.value())      setSelectedIndex(4); else
-    if (getValue() == m_13dBmItem.value())      setSelectedIndex(5); else
-    if (getValue() == m_11dBmItem.value())      setSelectedIndex(6); else
-    if (getValue() == m_8_5dBmItem.value())     setSelectedIndex(7); else
-    if (getValue() == m_7dBmItem.value())       setSelectedIndex(8); else
-    if (getValue() == m_5dBmItem.value())       setSelectedIndex(9); else
-    if (getValue() == m_2dBmItem.value())       setSelectedIndex(10); else
-    if (getValue() == m_MINUS_1dBmItem.value()) setSelectedIndex(11); else
+    switch (const auto value = getValue())
    {
-        Serial.printf("Unknown wifi_power_t: %i", int(getValue()));
+    case WIFI_POWER_19_5dBm:    setSelectedIndex(0); break;
+    case WIFI_POWER_19dBm:      setSelectedIndex(1); break;
+    case WIFI_POWER_18_5dBm:    setSelectedIndex(2); break;
+    case WIFI_POWER_17dBm:      setSelectedIndex(3); break;
+    case WIFI_POWER_15dBm:      setSelectedIndex(4); break;
+    case WIFI_POWER_13dBm:      setSelectedIndex(5); break;
+    case WIFI_POWER_11dBm:      setSelectedIndex(6); break;
+    case WIFI_POWER_8_5dBm:     setSelectedIndex(7); break;
+    case WIFI_POWER_7dBm:       setSelectedIndex(8); break;
+    case WIFI_POWER_5dBm:       setSelectedIndex(9); break;
+    case WIFI_POWER_2dBm:       setSelectedIndex(10); break;
+    case WIFI_POWER_MINUS_1dBm: setSelectedIndex(11); break;
+    default:
+        Serial.printf("Unknown wifi_power_t: %i\r\n", int(value));
        setSelectedIndex(12);
    }
 }
--- a/src/containermenudefinition.h
+++ b/src/containermenudefinition.h
@ -1,76 +0,0 @@
-#pragma once
-
-// system includes
-#include <vector>
-#include <memory>
-
-// local includes
-#include "menudefinitioninterface.h"
-
-namespace {
-class ContainerMenuDefinition : public virtual MenuDefinitionInterface
-{
-public:
-    std::size_t size() const override { return m_items.size(); }
-
-    MenuItem& getMenuItem(std::size_t index) override
-    {
-        if (index < m_items.size())
-            return *m_items[index].get();
-
-        throw "aua";
-    }
-
-    const MenuItem& getMenuItem(std::size_t index) const override
-    {
-        if (index < m_items.size())
-            return *m_items[index].get();
-
-        throw "aua";
-    }
-
-    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
-    {
-        for (const auto &ptr : m_items)
-            callback(*ptr);
-    }
-
-    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
-    {
-        for (const auto &ptr : m_items)
-            callback(*ptr);
-    }
-
-    template<typename T, typename... Args>
-    T &constructItem(Args&&... args)
-    {
-        auto ptr = std::make_unique<T>(std::forward<Args>(args)...);
-        T &ref = *ptr;
-        emplaceItem(std::move(ptr));
-        return ref;
-    }
-
-    void emplaceItem(std::unique_ptr<MenuItem> &&ptr)
-    {
-        m_items.emplace_back(std::move(ptr));
-    }
-
-    void clearItems()
-    {
-        m_items.clear();
-    }
-
-    std::unique_ptr<MenuItem> takeLast()
-    {
-        if (m_items.empty())
-            throw "aua";
-
-        std::unique_ptr<MenuItem> ptr = std::move(m_items.back());
-        m_items.pop_back();
-        return ptr;
-    }
-
-private:
-    std::vector<std::unique_ptr<MenuItem>> m_items;
-};
-} // namespace
--- a/src/displays/gameoflifedisplay.h
+++ b/src/displays/gameoflifedisplay.h
@ -46,34 +46,37 @@ private:

    static const constexpr auto GEN_DELAY = 0;

-    template<typename T> auto index(T x, T y)
+    int index(int x, int y)
    {
        if (x >= GRIDX)
        {
-            Serial.printf("x: %i", x);
+            Serial.printf("x: %i\r\n", x);
            return 0;
        }
        if (y >= GRIDY)
        {
-            Serial.printf("y: %i", x);
+            Serial.printf("y: %i\r\n", x);
            return 0;
        }
-        return (x * GRIDX) + y;
+        const auto result = (x * GRIDY) + y;
+        if (result >= GRIDX*GRIDY)
+        {
+            Serial.printf("x:%i y:%i x*y:%i\r\n", x, y, result);
+            return 0;
+        }
+        return result;
    }

-    struct Data
-    {
-        std::bitset<GRIDX*GRIDY> grid, newgrid;
-    };
-
-    std::unique_ptr<Data> m_data;
+    std::unique_ptr<std::bitset<GRIDX*GRIDY>> m_grid;
+    std::unique_ptr<std::bitset<GRIDX*GRIDY>> m_newgrid;

    int gen = 0;
 };

 void GameOfLifeDisplay::start()
 {
-    m_data = std::make_unique<Data>();
+    m_grid = std::make_unique<std::bitset<GRIDX*GRIDY>>();
+    m_newgrid = std::make_unique<std::bitset<GRIDX*GRIDY>>();
 }

 void GameOfLifeDisplay::initScreen()
@ -93,21 +96,17 @@ void GameOfLifeDisplay::redraw()
    computeCA();
    drawGrid();

-    m_data->grid = m_data->newgrid;
-//    for (int16_t x = 1; x < GRIDX-1; x++) {
-//        for (int16_t y = 1; y < GRIDY-1; y++) {
-//            grid[index(x,y)] = m_data->newgrid[index(x,y)];
-//        }
-//    }
+    *m_grid = *m_newgrid;

-    if (++gen == 200)
+    if (++gen == 500)
        gen = 0;
 }

 void GameOfLifeDisplay::stop()
 {
    tft.setRotation(0);
-    m_data = nullptr;
+    m_grid = nullptr;
+    m_newgrid = nullptr;
 }

 void GameOfLifeDisplay::drawGrid()
@ -115,8 +114,8 @@ void GameOfLifeDisplay::drawGrid()
    uint16_t color = TFT_WHITE;
    for (int16_t x = 1; x < GRIDX - 1; x++) {
        for (int16_t y = 1; y < GRIDY - 1; y++) {
-            if ((m_data->grid[index(x,y)]) != (m_data->newgrid[index(x,y)])) {
-                if (m_data->newgrid[index(x,y)] == 1)
+            if (((*m_grid)[index(x,y)]) != ((*m_newgrid)[index(x,y)])) {
+                if ((*m_newgrid)[index(x,y)] == 1)
                    color = 0xFFFF; //random(0xFFFF);
                else
                    color = 0;
@ -130,16 +129,16 @@ void GameOfLifeDisplay::initGrid()
 {
    for (int16_t x = 0; x < GRIDX; x++) {
        for (int16_t y = 0; y < GRIDY; y++) {
-            m_data->newgrid[index(x,y)] = 0;
+            (*m_newgrid)[index(x,y)] = 0;

            if (x == 0 || x == GRIDX - 1 || y == 0 || y == GRIDY - 1)
-                m_data->grid[index(x,y)] = 0;
+                (*m_grid)[index(x,y)] = 0;
            else
            {
                if (random(3) == 1)
-                    m_data->grid[index(x,y)] = 1;
+                    (*m_grid)[index(x,y)] = 1;
                else
-                    m_data->grid[index(x,y)] = 0;
+                    (*m_grid)[index(x,y)] = 0;
            }

        }
@ -160,7 +159,7 @@ int GameOfLifeDisplay::getNumberOfNeighbors(int x, int y)

            if (new_x >= 0 && new_y >= 0 &&
                new_x < GRIDX && new_y < GRIDY)
-                n += m_data->grid[index(new_x, new_y)];
+                n += (*m_grid)[index(new_x, new_y)];
        }

    return n;
@ -171,14 +170,14 @@ void GameOfLifeDisplay::computeCA()
    for (int16_t x = 1; x < GRIDX; x++) {
        for (int16_t y = 1; y < GRIDY; y++) {
            int neighbors = getNumberOfNeighbors(x, y);
-            if (m_data->grid[index(x,y)] == true && (neighbors == 2 || neighbors == 3 ))
-                m_data->newgrid[index(x,y)] = true;
-            else if (m_data->grid[index(x,y)] == 1)
-                m_data->newgrid[index(x,y)] = false;
-            if (m_data->grid[index(x,y)] == false && (neighbors == 3))
-                m_data->newgrid[index(x,y)] = true;
-            else if (m_data->grid[index(x,y)] == 0)
-                m_data->newgrid[index(x,y)] = false;
+            if ((*m_grid)[index(x,y)] == true && (neighbors == 2 || neighbors == 3 ))
+                (*m_newgrid)[index(x,y)] = true;
+            else if ((*m_grid)[index(x,y)] == 1)
+                (*m_newgrid)[index(x,y)] = false;
+            if ((*m_grid)[index(x,y)] == false && (neighbors == 3))
+                (*m_newgrid)[index(x,y)] = true;
+            else if ((*m_grid)[index(x,y)] == 0)
+                (*m_newgrid)[index(x,y)] = false;
        }
    }
 }
--- a/src/displays/menus/aboutmenu.h
+++ b/src/displays/menus/aboutmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "actions/dummyaction.h"
 #include "actions/switchscreenaction.h"
@ -22,34 +21,33 @@ constexpr char TEXT_ESPINFO[] = "ESP info:";
 class AboutMenu :
    public MenuDisplay,
    public StaticText<TEXT_ABOUT>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
 {
 public:
    AboutMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_VERSION>,                                   DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<nullptr>,                                        DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_ESPINFO>,                                   DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspHeapSizeText,              StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspFreeHeapText,              StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspMinFreeHeapText,           StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspMaxAllocHeapText,          StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspPsramSizeText,             StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspFreePsramText,             StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspMinFreePsramText,          StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspMaxAllocPsramText,         StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspChipRevisionText,          StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspCpuFreqMHzText,            StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspCycleCountText,            StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspSdkVersionText,            StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspFlashChipSizeText,         StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspFlashChipSpeedText,        StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspFlashChipModeText,         StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspSketchSizeText,            StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspSketchMd5Text,             StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, EspFreeSketchSpaceText,       StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,        SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VERSION>,                                   DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>,                                        DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPINFO>,                                   DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspHeapSizeText,              StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspFreeHeapText,              StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspMinFreeHeapText,           StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspMaxAllocHeapText,          StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspPsramSizeText,             StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspFreePsramText,             StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspMinFreePsramText,          StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspMaxAllocPsramText,         StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspChipRevisionText,          StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspCpuFreqMHzText,            StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspCycleCountText,            StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspSdkVersionText,            StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspFlashChipSizeText,         StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspFlashChipSpeedText,        StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspFlashChipModeText,         StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspSketchSizeText,            StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspSketchMd5Text,             StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, EspFreeSketchSpaceText,       StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,        SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/accesspointwifisettingsmenu.h
+++ b/src/displays/menus/accesspointwifisettingsmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
 #include "actions/wifisoftapaction.h"
@ -23,25 +22,24 @@ namespace {
 class AccessPointWifiSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_ACCESSPOINTWIFISETTINGS>,
-    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
 {
 public:
    AccessPointWifiSettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAP>,                  WifiSoftApAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPDISCONNECT>,        WifiSoftApDisconnectAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPDISCONNECTWIFIOFF>, WifiSoftApDisconnectWifioffAction>>();
-        constructItem<makeComponent<MenuItem, WifiSoftApGetStationNumText,                  StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiSoftApIpText,                             StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiSoftApBroadcastIpText,                    StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiSoftApNetworkIdText,                      StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiSoftApSubnetCidrText,                     StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPENABLEIPV6>,        WifiSoftApEnableIpV6Action>>();
-        constructItem<makeComponent<MenuItem, WifiSoftApIpV6Text,                           StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiSoftApHostnameText,                       StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiSoftApMacAddressText,                     StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                        SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAP>,                  WifiSoftApAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPDISCONNECT>,        WifiSoftApDisconnectAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPDISCONNECTWIFIOFF>, WifiSoftApDisconnectWifioffAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiSoftApGetStationNumText,                  StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiSoftApIpText,                             StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiSoftApBroadcastIpText,                    StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiSoftApNetworkIdText,                      StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiSoftApSubnetCidrText,                     StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPENABLEIPV6>,        WifiSoftApEnableIpV6Action>>();
+        constructMenuItem<makeComponent<MenuItem, WifiSoftApIpV6Text,                           StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiSoftApHostnameText,                       StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiSoftApMacAddressText,                     StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                        SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/bluetoothsettingsmenu.h
+++ b/src/displays/menus/bluetoothsettingsmenu.h
@ -3,7 +3,6 @@
 // local includes
 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
 #ifdef FEATURE_BLUETOOTH
@ -39,24 +38,23 @@ using AutoBluetoothModeChangeDisplay = makeComponent<
 class BluetoothSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_BLUETOOTHSETTINGS>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
 {
 public:
    BluetoothSettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, BluetoothAvailableText,                 DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, BluetoothHasClientText,                 DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, BluetoothAvailableText,                 DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, BluetoothHasClientText,                 DisabledColor, DummyAction>>();
 //        constructItem<makeComponent<MenuItem, BluetoothConnectedText,                 DisabledColor, DummyAction>>(); // crashes
-        constructItem<makeComponent<MenuItem, BluetoothIsReadyText,                   DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, BluetoothIsReadyMasterText,             DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHBEGIN>,        BluetoothBeginAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHBEGINMASTER>,  BluetoothBeginMasterAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHFLUSH>,        BluetoothFlushAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHEND>,          BluetoothEndAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHDISCONNECT>,   BluetoothDisconnectAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_AUTOBLUETOOTHMODE>,     SwitchScreenAction<AutoBluetoothModeChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                  SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, BluetoothIsReadyText,                   DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, BluetoothIsReadyMasterText,             DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHBEGIN>,        BluetoothBeginAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHBEGINMASTER>,  BluetoothBeginMasterAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHFLUSH>,        BluetoothFlushAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHEND>,          BluetoothEndAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHDISCONNECT>,   BluetoothDisconnectAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AUTOBLUETOOTHMODE>,     SwitchScreenAction<AutoBluetoothModeChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                  SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 #endif
--- a/src/displays/menus/bmsmenu.h
+++ b/src/displays/menus/bmsmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #ifdef FEATURE_BLUETOOTH
@ -29,20 +28,19 @@ namespace {
 class BmsMenu :
    public MenuDisplay,
    public StaticText<TEXT_BMS>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
 {
 public:
    BmsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_CONNECTBMS>,       BluetoothConnectBmsAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DISCONNECTBMS>,    BluetoothDisconnectAction>>();
-        constructItem<makeComponent<MenuItem, BluetoothHasClientText,            DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_TURNONCHARGE>,     BmsTurnOnChargeAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_TURNOFFCHARGE>,    BmsTurnOffChargeAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_TURNONDISCHARGE>,  BmsTurnOnDischargeAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_TURNOFFDISCHARGE>, BmsTurnOffDischargeAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,             SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CONNECTBMS>,       BluetoothConnectBmsAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISCONNECTBMS>,    BluetoothDisconnectAction>>();
+        constructMenuItem<makeComponent<MenuItem, BluetoothHasClientText,            DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNONCHARGE>,     BmsTurnOnChargeAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNOFFCHARGE>,    BmsTurnOffChargeAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNONDISCHARGE>,  BmsTurnOnDischargeAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNOFFDISCHARGE>, BmsTurnOffDischargeAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,             SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 #endif
--- a/src/displays/menus/boardcomputerhardwaresettingsmenu.h
+++ b/src/displays/menus/boardcomputerhardwaresettingsmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "actions/dummyaction.h"
@ -139,22 +138,21 @@ using GametrakDistMaxChangeScreen = makeComponent<
 class BoardcomputerHardwareSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_BOARDCOMPUTERHARDWARESETTINGS>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
 {
 public:
    BoardcomputerHardwareSettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, GasText,                             DisabledColor, StaticFont<2>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, BremsText,                           DisabledColor, StaticFont<2>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_CALIBRATE>,          SwitchScreenAction<CalibrateDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETSAMPLECOUNT>,     SwitchScreenAction<SampleCountChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGASMIN>,          SwitchScreenAction<GasMinChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGASMAX>,          SwitchScreenAction<GasMaxChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMSMIN>,        SwitchScreenAction<BremsMinChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMSMAX>,        SwitchScreenAction<BremsMaxChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, GasText,                             DisabledColor, StaticFont<2>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, BremsText,                           DisabledColor, StaticFont<2>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CALIBRATE>,          SwitchScreenAction<CalibrateDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETSAMPLECOUNT>,     SwitchScreenAction<SampleCountChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGASMIN>,          SwitchScreenAction<GasMinChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGASMAX>,          SwitchScreenAction<GasMaxChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMSMIN>,        SwitchScreenAction<BremsMinChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMSMAX>,        SwitchScreenAction<BremsMaxChangeScreen>>>();
 #if defined(FEATURE_DPAD) || defined(FEATURE_DPAD_3WIRESW) || defined(FEATURE_DPAD_5WIRESW)
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETDPADDEBOUNCE>,    SwitchScreenAction<DPadDebounceChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETDPADDEBOUNCE>,    SwitchScreenAction<DPadDebounceChangeScreen>>>();
 #endif
 #ifdef FEATURE_GAMETRAK
        constructItem<makeComponent<MenuItem, StaticText<nullptr>,                 DummyAction>,
@ -169,10 +167,10 @@ public:
        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMIN>, SwitchScreenAction<GametrakDistMinChangeScreen>>>();
        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMAX>, SwitchScreenAction<GametrakDistMaxChangeScreen>>>();
 #endif
-        constructItem<makeComponent<MenuItem, StaticText<nullptr>,                 DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SWAPSCREENBYTES>,    ToggleBoolAction, CheckboxIcon, SwapScreenBytesAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_TIMERS>,             SwitchScreenAction<TimersMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,               SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>,                 DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SWAPSCREENBYTES>,    ToggleBoolAction, CheckboxIcon, SwapScreenBytesAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TIMERS>,             SwitchScreenAction<TimersMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,               SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/buzzermenu.h
+++ b/src/displays/menus/buzzermenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "menuitem.h"
@ -89,22 +88,21 @@ using ReverseBeepDuration1ChangeScreen = makeComponent<
 class BuzzerMenu :
    public MenuDisplay,
    public StaticText<TEXT_BUZZER>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
 {
 public:
    BuzzerMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTFREQ>,            SwitchScreenAction<FrontFreqChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTPATTERN>,         SwitchScreenAction<FrontPatternChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKFREQ>,             SwitchScreenAction<BackFreqChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKPATTERN>,          SwitchScreenAction<BackPatternChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEP>,          ToggleBoolAction, CheckboxIcon, ReverseBeepAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ0>,     SwitchScreenAction<ReverseBeepFreq0ChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ1>,     SwitchScreenAction<ReverseBeepFreq1ChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPDURATION0>, SwitchScreenAction<ReverseBeepDuration0ChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPDURATION1>, SwitchScreenAction<ReverseBeepDuration1ChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTFREQ>,            SwitchScreenAction<FrontFreqChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTPATTERN>,         SwitchScreenAction<FrontPatternChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKFREQ>,             SwitchScreenAction<BackFreqChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKPATTERN>,          SwitchScreenAction<BackPatternChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEP>,          ToggleBoolAction, CheckboxIcon, ReverseBeepAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ0>,     SwitchScreenAction<ReverseBeepFreq0ChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ1>,     SwitchScreenAction<ReverseBeepFreq1ChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPDURATION0>, SwitchScreenAction<ReverseBeepDuration0ChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPDURATION1>, SwitchScreenAction<ReverseBeepDuration1ChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/commanddebugmenu.h
+++ b/src/displays/menus/commanddebugmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
@ -21,17 +20,16 @@ template<const char *Ttext, typename Ttexts>
 class CommandDebugMenu :
    public MenuDisplay,
    public StaticText<Ttext>,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<DebugMenu>>
 {
 public:
    CommandDebugMenu()
    {
-        constructItem<makeComponent<MenuItem, typename Ttexts::BuzzerFreqText,    DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::BuzzerPatternText, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::PoweroffText,      DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::LedText,           DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::BuzzerFreqText,    DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::BuzzerPatternText, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::PoweroffText,      DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::LedText,           DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };

--- a/src/displays/menus/controllerhardwaresettingsmenu.h
+++ b/src/displays/menus/controllerhardwaresettingsmenu.h
@ -4,7 +4,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "actions/toggleboolaction.h"
@ -51,19 +50,18 @@ using NumMagnetPolesChangeScreen = makeComponent<
 class ControllerHardwareSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_CONTROLLERHARDWARESETTINGS>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
 {
 public:
    ControllerHardwareSettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETENABLED>,        SwitchScreenAction<EnableMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETINVERTED>,       SwitchScreenAction<InvertMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERMM>,   SwitchScreenAction<WheelDiameterMmChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERINCH>, SwitchScreenAction<WheelDiameterInchChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_NUMMAGNETPOLES>,    SwitchScreenAction<NumMagnetPolesChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SWAPFRONTBACK>,     ToggleBoolAction, CheckboxIcon, SwapFrontBackAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETENABLED>,        SwitchScreenAction<EnableMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETINVERTED>,       SwitchScreenAction<InvertMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERMM>,   SwitchScreenAction<WheelDiameterMmChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERINCH>, SwitchScreenAction<WheelDiameterInchChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_NUMMAGNETPOLES>,    SwitchScreenAction<NumMagnetPolesChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SWAPFRONTBACK>,     ToggleBoolAction, CheckboxIcon, SwapFrontBackAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/debugmenu.h
+++ b/src/displays/menus/debugmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/loadsettingsaction.h"
@ -39,34 +38,33 @@ namespace {
 class DebugMenu :
    public MenuDisplay,
    public StaticText<TEXT_DEBUG>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
 {
 public:
    DebugMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_LOADSETTINGS>,         LoadSettingsAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SAVESETTINGS>,         SaveSettingsAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_ERASENVS>,             EraseNvsAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTCOMMAND>,         SwitchScreenAction<FrontCommandDebugMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKCOMMAND>,          SwitchScreenAction<BackCommandDebugMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLEFTCOMMAND>,     SwitchScreenAction<FrontLeftMotorStateDebugMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTRIGHTCOMMAND>,    SwitchScreenAction<FrontRightMotorStateDebugMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKLEFTCOMMAND>,      SwitchScreenAction<BackLeftMotorStateDebugMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKRIGHTCOMMAND>,     SwitchScreenAction<BackRightMotorStateDebugMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTFEEDBACK>,        SwitchScreenAction<FrontFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKFEEDBACK>,         SwitchScreenAction<BackFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>();
-        constructItem<makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLEFTFEEDBACK>,    SwitchScreenAction<FrontLeftMotorFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTRIGHTFEEDBACK>,   SwitchScreenAction<FrontRightMotorFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKLEFTFEEDBACK>,     SwitchScreenAction<BackLeftMotorFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKRIGHTFEEDBACK>,    SwitchScreenAction<BackRightMotorFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>();
-        constructItem<makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICMENU>,          SwitchScreenAction<DynamicDebugMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LOADSETTINGS>,         LoadSettingsAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SAVESETTINGS>,         SaveSettingsAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ERASENVS>,             EraseNvsAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTCOMMAND>,         SwitchScreenAction<FrontCommandDebugMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKCOMMAND>,          SwitchScreenAction<BackCommandDebugMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLEFTCOMMAND>,     SwitchScreenAction<FrontLeftMotorStateDebugMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTRIGHTCOMMAND>,    SwitchScreenAction<FrontRightMotorStateDebugMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKLEFTCOMMAND>,      SwitchScreenAction<BackLeftMotorStateDebugMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKRIGHTCOMMAND>,     SwitchScreenAction<BackRightMotorStateDebugMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTFEEDBACK>,        SwitchScreenAction<FrontFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKFEEDBACK>,         SwitchScreenAction<BackFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLEFTFEEDBACK>,    SwitchScreenAction<FrontLeftMotorFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTRIGHTFEEDBACK>,   SwitchScreenAction<FrontRightMotorFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKLEFTFEEDBACK>,     SwitchScreenAction<BackLeftMotorFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKRIGHTFEEDBACK>,    SwitchScreenAction<BackRightMotorFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICMENU>,          SwitchScreenAction<DynamicDebugMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/defaultmodesettingsmenu.h
+++ b/src/displays/menus/defaultmodesettingsmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "menuitem.h"
@ -87,25 +86,24 @@ using DefaultModeBrems2WertChangeDisplay = makeComponent<
 class DefaultModeSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_DEFAULTMODESETTIGNS>,
-    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
 {
 public:
    DefaultModeSettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>,       SwitchScreenAction<DefaultModeModelModeChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREGAS>,          ToggleBoolAction, CheckboxIcon, DefaultModeSquareGasAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREBREMS>,        ToggleBoolAction, CheckboxIcon, DefaultModeSquareBremsAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHING>,    ToggleBoolAction, CheckboxIcon, DefaultModeEnableSmoothingAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETSMOOTHING>,       SwitchScreenAction<DefaultModeSmoothingChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETFRONTPERCENTAGE>, SwitchScreenAction<DefaultModeFrontPercentageChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETBACKPERCENTAGE>,  SwitchScreenAction<DefaultModeBackPercentageChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETADDSCHWELLE>,     SwitchScreenAction<DefaultModeAddSchwelleChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGAS1WERT>,        SwitchScreenAction<DefaultModeGas1WertChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGAS2WERT>,        SwitchScreenAction<DefaultModeGas2WertChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMS1WERT>,      SwitchScreenAction<DefaultModeBrems1WertChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMS2WERT>,      SwitchScreenAction<DefaultModeBrems2WertChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,               SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>,       SwitchScreenAction<DefaultModeModelModeChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREGAS>,          ToggleBoolAction, CheckboxIcon, DefaultModeSquareGasAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREBREMS>,        ToggleBoolAction, CheckboxIcon, DefaultModeSquareBremsAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHING>,    ToggleBoolAction, CheckboxIcon, DefaultModeEnableSmoothingAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETSMOOTHING>,       SwitchScreenAction<DefaultModeSmoothingChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETFRONTPERCENTAGE>, SwitchScreenAction<DefaultModeFrontPercentageChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETBACKPERCENTAGE>,  SwitchScreenAction<DefaultModeBackPercentageChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETADDSCHWELLE>,     SwitchScreenAction<DefaultModeAddSchwelleChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAS1WERT>,        SwitchScreenAction<DefaultModeGas1WertChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAS2WERT>,        SwitchScreenAction<DefaultModeGas2WertChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMS1WERT>,      SwitchScreenAction<DefaultModeBrems1WertChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMS2WERT>,      SwitchScreenAction<DefaultModeBrems2WertChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,               SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/demosmenu.h
+++ b/src/displays/menus/demosmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
@ -22,17 +21,16 @@ namespace {
 class DemosMenu :
    public MenuDisplay,
    public StaticText<TEXT_DEMOS>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
 {
 public:
    DemosMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_STARFIELD>,  SwitchScreenAction<StarfieldDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_PINGPONG>,   SwitchScreenAction<PingPongDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SPIRO>,      SwitchScreenAction<SpiroDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_GAMEOFLIFE>, SwitchScreenAction<GameOfLifeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,       SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STARFIELD>,  SwitchScreenAction<StarfieldDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PINGPONG>,   SwitchScreenAction<PingPongDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SPIRO>,      SwitchScreenAction<SpiroDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GAMEOFLIFE>, SwitchScreenAction<GameOfLifeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,       SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/dynamicdebugmenu.h
+++ b/src/displays/menus/dynamicdebugmenu.h
@ -6,7 +6,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
@ -125,38 +124,37 @@ constexpr char TEXT_DEBUGTOGGLE[] = "Toggle";
 class DynamicDebugMenu :
    public MenuDisplay,
    public RandomText,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<DebugMenu>>
 {
 public:
    DynamicDebugMenu()
    {
        // dummy items to allow for scrolling
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();

        // the interesting bits
-        constructItem<makeComponent<MenuItem, RandomText,                    DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICCOLOR>, RandomColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICFONT>,  RandomFont, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICICON>,  RandomIcon, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_STATICICON>,   StaticMenuItemIcon<&icons::lock>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DEBUGTOGGLE>,  ToggleBoolAction, CheckboxIcon, ToggleAccessor>>();
-        constructItem<makeComponent<MenuItem, RandomText,                    RandomColor, RandomFont, RandomIcon, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, RandomText,                    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICCOLOR>, RandomColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICFONT>,  RandomFont, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICICON>,  RandomIcon, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATICICON>,   StaticMenuItemIcon<&icons::lock>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEBUGTOGGLE>,  ToggleBoolAction, CheckboxIcon, ToggleAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, RandomText,                    RandomColor, RandomFont, RandomIcon, DummyAction>>();

        // more scrolling
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>>();

-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,         SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,         SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/enablemenu.h
+++ b/src/displays/menus/enablemenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/toggleboolaction.h"
@ -21,17 +20,16 @@ namespace {
 class EnableMenu :
    public MenuDisplay,
    public StaticText<TEXT_SETENABLED>,
-    public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>
 {
 public:
    EnableMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTLEFT>,  ToggleBoolAction, CheckboxIcon, FrontLeftEnabledAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightEnabledAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKLEFT>,   ToggleBoolAction, CheckboxIcon, BackLeftEnabledAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKRIGHT>,  ToggleBoolAction, CheckboxIcon, BackRightEnabledAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,             SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTLEFT>,  ToggleBoolAction, CheckboxIcon, FrontLeftEnabledAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightEnabledAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKLEFT>,   ToggleBoolAction, CheckboxIcon, BackLeftEnabledAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKRIGHT>,  ToggleBoolAction, CheckboxIcon, BackRightEnabledAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,             SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/feedbackdebugmenu.h
+++ b/src/displays/menus/feedbackdebugmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
@ -22,18 +21,17 @@ template<const char *Ttext, typename Ttexts, template<int> class ColorInterface>
 class FeedbackDebugMenu :
    public MenuDisplay,
    public StaticText<Ttext>,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<DebugMenu>>
 {
 public:
    FeedbackDebugMenu()
    {
-        constructItem<makeComponent<MenuItem, typename Ttexts::BatVoltageText,       ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::BatVoltageFixedText,  ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::BoardTempText,        ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::BoardTempFixedText,   ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::TimeoutCntSerialText, StaticFont<2>, ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::BatVoltageText,       ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::BatVoltageFixedText,  ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::BoardTempText,        ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::BoardTempFixedText,   ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::TimeoutCntSerialText, StaticFont<2>, ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };

--- a/src/displays/menus/gametrakmodesettingsmenu.h
+++ b/src/displays/menus/gametrakmodesettingsmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
@ -19,8 +18,7 @@ namespace {
 class ContainerModeSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_GAMETRAKMODESETTINGS>,
-    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
 {
 public:
    ContainerModeSettingsMenu()
--- a/src/displays/menus/genericwifisettingsmenu.h
+++ b/src/displays/menus/genericwifisettingsmenu.h
@ -5,7 +5,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "changevaluedisplay.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
@ -43,18 +42,17 @@ using WifiTxPowerChangeScreen = makeComponent<
 class GenericWifiSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_GENERICWIFISETTINGS>,
-    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
 {
 public:
    GenericWifiSettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, WifiStatusBitsText,                 DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiChannelText,                    DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEMODE>,    SwitchScreenAction<WifiModeChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGESLEEP>,   ToggleBoolAction, CheckboxIcon, WifiSleepAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGETXPOWER>, SwitchScreenAction<WifiTxPowerChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, WifiStatusBitsText,                 DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiChannelText,                    DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEMODE>,    SwitchScreenAction<WifiModeChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGESLEEP>,   ToggleBoolAction, CheckboxIcon, WifiSleepAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGETXPOWER>, SwitchScreenAction<WifiTxPowerChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/graphsmenu.h
+++ b/src/displays/menus/graphsmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
@ -150,31 +149,30 @@ using MotorCurrentsGraphDisplay = makeComponent<
 class GraphsMenu :
    public MenuDisplay,
    public StaticText<TEXT_GRAPHS>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
 {
 public:
    GraphsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_GAS>,                   SwitchScreenAction<GasGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BREMS>,                 SwitchScreenAction<BremsGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_POTIS>,                 SwitchScreenAction<PotisGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_POTIS>,                 SwitchScreenAction<PotisSplitGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_AVGSPEED>,              SwitchScreenAction<AvgSpeedGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_AVGSPEEDKMH>,           SwitchScreenAction<AvgSpeedKmhGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SUMCURRENT>,            SwitchScreenAction<SumCurrentGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTVOLTAGE>,          SwitchScreenAction<FrontVoltageGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKVOLTAGE>,           SwitchScreenAction<BackVoltageGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGES>,              SwitchScreenAction<VoltagesGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGES>,              SwitchScreenAction<VoltagesSplitGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GAS>,                   SwitchScreenAction<GasGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BREMS>,                 SwitchScreenAction<BremsGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POTIS>,                 SwitchScreenAction<PotisGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POTIS>,                 SwitchScreenAction<PotisSplitGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AVGSPEED>,              SwitchScreenAction<AvgSpeedGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AVGSPEEDKMH>,           SwitchScreenAction<AvgSpeedKmhGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SUMCURRENT>,            SwitchScreenAction<SumCurrentGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTVOLTAGE>,          SwitchScreenAction<FrontVoltageGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKVOLTAGE>,           SwitchScreenAction<BackVoltageGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGES>,              SwitchScreenAction<VoltagesGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGES>,              SwitchScreenAction<VoltagesSplitGraphDisplay>>>();
 #ifdef FEATURE_BMS
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BMSVOLTAGE>,            SwitchScreenAction<BmsVoltageGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BMSCURRENT>,            SwitchScreenAction<BmsCurrentGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BMSPOWER>,              SwitchScreenAction<BmsPowerGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SUMCURRENTSCOMPARISON>, SwitchScreenAction<SumCurrentsComparisonGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMSVOLTAGE>,            SwitchScreenAction<BmsVoltageGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMSCURRENT>,            SwitchScreenAction<BmsCurrentGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMSPOWER>,              SwitchScreenAction<BmsPowerGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SUMCURRENTSCOMPARISON>, SwitchScreenAction<SumCurrentsComparisonGraphDisplay>>>();
 #endif
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_MOTORCURRENTS>,         SwitchScreenAction<MotorCurrentsGraphDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                  SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOTORCURRENTS>,         SwitchScreenAction<MotorCurrentsGraphDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                  SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/invertmenu.h
+++ b/src/displays/menus/invertmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/toggleboolaction.h"
@ -21,17 +20,16 @@ namespace {
 class InvertMenu :
    public MenuDisplay,
    public StaticText<TEXT_SETINVERTED>,
-    public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>
 {
 public:
    InvertMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTLEFT>,  ToggleBoolAction, CheckboxIcon, FrontLeftInvertedAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightInvertedAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKLEFT>,   ToggleBoolAction, CheckboxIcon, BackLeftInvertedAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKRIGHT>,  ToggleBoolAction, CheckboxIcon, BackRightInvertedAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,             SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTLEFT>,  ToggleBoolAction, CheckboxIcon, FrontLeftInvertedAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightInvertedAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKLEFT>,   ToggleBoolAction, CheckboxIcon, BackLeftInvertedAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKRIGHT>,  ToggleBoolAction, CheckboxIcon, BackRightInvertedAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,             SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/larsmmodesettingsmenu.h
+++ b/src/displays/menus/larsmmodesettingsmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "menuitem.h"
@ -43,16 +42,15 @@ using LarsmModeIterationsChangeDisplay = makeComponent<
 class LarsmModeSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_LARSMMODESETTINGS>,
-    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
 {
 public:
    LarsmModeSettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>,  SwitchScreenAction<LarsmModeModelModeChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETMODE>,       SwitchScreenAction<LarsmModeModeChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETITERATIONS>, SwitchScreenAction<LarsmModeIterationsChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,          SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>,  SwitchScreenAction<LarsmModeModelModeChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETMODE>,       SwitchScreenAction<LarsmModeModeChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETITERATIONS>, SwitchScreenAction<LarsmModeIterationsChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,          SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/limitssettingsmenu.h
+++ b/src/displays/menus/limitssettingsmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "menuitem.h"
@ -64,19 +63,18 @@ using PhaseAdvMaxChangeScreen = makeComponent<
 class LimitsSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_LIMITSSETTINGS>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
 {
 public:
    LimitsSettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETIMOTMAX>,      SwitchScreenAction<IMotMaxChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETIDCMAX>,       SwitchScreenAction<IDcMaxChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETNMOTMAXKMH>,   SwitchScreenAction<NMotMaxKmhChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETNMOTMAX>,      SwitchScreenAction<NMotMaxRpmChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETFIELDWEAKMAX>, SwitchScreenAction<FieldWeakMaxChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETPHASEADVMAX>,  SwitchScreenAction<PhaseAdvMaxChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,            SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETIMOTMAX>,      SwitchScreenAction<IMotMaxChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETIDCMAX>,       SwitchScreenAction<IDcMaxChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETNMOTMAXKMH>,   SwitchScreenAction<NMotMaxKmhChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETNMOTMAX>,      SwitchScreenAction<NMotMaxRpmChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETFIELDWEAKMAX>, SwitchScreenAction<FieldWeakMaxChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETPHASEADVMAX>,  SwitchScreenAction<PhaseAdvMaxChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,            SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/mainmenu.h
+++ b/src/displays/menus/mainmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
 #include "actions/modesettingsaction.h"
@ -39,30 +38,29 @@ namespace {
 class MainMenu :
    public MenuDisplay,
    public StaticText<TEXT_MAINMENU>,
-    public BackActionInterface<SwitchScreenAction<StatusDisplay>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<StatusDisplay>>
 {
 public:
    MainMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_STATUS>,       SwitchScreenAction<StatusDisplay>, StaticMenuItemIcon<&icons::back>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SELECTMODE>,   SwitchScreenAction<SelectModeMenu>, StaticMenuItemIcon<&icons::modes>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_MODESETTINGS>, ModeSettingsAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_PRESETS>,      SwitchScreenAction<PresetsMenu>, StaticMenuItemIcon<&icons::presets>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_PROFILES>,     SwitchScreenAction<ProfilesMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_GRAPHS>,       SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&icons::graph>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATUS>,       SwitchScreenAction<StatusDisplay>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SELECTMODE>,   SwitchScreenAction<SelectModeMenu>, StaticMenuItemIcon<&icons::modes>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MODESETTINGS>, ModeSettingsAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PRESETS>,      SwitchScreenAction<PresetsMenu>, StaticMenuItemIcon<&icons::presets>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILES>,     SwitchScreenAction<ProfilesMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GRAPHS>,       SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&icons::graph>>>();
 #ifdef FEATURE_BMS
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BMS>,          SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&icons::bms>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMS>,          SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&icons::bms>>>();
 #endif
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETTINGS>,     SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::settings>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_LOCKVEHICLE>,  SwitchScreenAction<Lockscreen>, StaticMenuItemIcon<&icons::lock>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETTINGS>,     SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::settings>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LOCKVEHICLE>,  SwitchScreenAction<Lockscreen>, StaticMenuItemIcon<&icons::lock>>>();
 #ifdef FEATURE_MOSFETS
        constructItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETS>,      SwitchScreenAction<MosfetsMenu>>>();
 #endif
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DEMOS>,        SwitchScreenAction<DemosMenu>, StaticMenuItemIcon<&icons::demos>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_POWEROFF>,     SwitchScreenAction<PoweroffDisplay>, StaticMenuItemIcon<&icons::poweroff>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_REBOOT>,       RebootAction, StaticMenuItemIcon<&icons::reboot>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DEBUG>,        SwitchScreenAction<DebugMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEMOS>,        SwitchScreenAction<DemosMenu>, StaticMenuItemIcon<&icons::demos>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POWEROFF>,     SwitchScreenAction<PoweroffDisplay>, StaticMenuItemIcon<&icons::poweroff>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REBOOT>,       RebootAction, StaticMenuItemIcon<&icons::reboot>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEBUG>,        SwitchScreenAction<DebugMenu>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/modessettingsmenu.h
+++ b/src/displays/menus/modessettingsmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
@ -21,19 +20,18 @@ namespace {
 class ModesSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_MODESSETTINGS>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
 {
 public:
    ModesSettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTMODESETTIGNS>,   SwitchScreenAction<DefaultModeSettingsMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_TEMPOMATMODESETTINGS>,  SwitchScreenAction<TempomatModeSettingsMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_LARSMMODESETTINGS>,     SwitchScreenAction<LarsmModeSettingsMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTMODESETTIGNS>,   SwitchScreenAction<DefaultModeSettingsMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TEMPOMATMODESETTINGS>,  SwitchScreenAction<TempomatModeSettingsMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LARSMMODESETTINGS>,     SwitchScreenAction<LarsmModeSettingsMenu>>>();
 #ifdef FEATURE_GAMETRAK
        constructItem<makeComponent<MenuItem, StaticText<TEXT_GAMETRAKMODESETTINGS>,  SwitchScreenAction<GametrakModeSettingsMenu>>>();
 #endif
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                  SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                  SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/mosfetsmenu.h
+++ b/src/displays/menus/mosfetsmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/toggleboolaction.h"
@ -34,8 +33,7 @@ using Mosfet2Accessor = GPIOAccessor<PINS_MOSFET2>;
 class MosfetsMenu :
    public MenuDisplay,
    public StaticText<TEXT_MOSFETS>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
 {
 public:
    MosfetsMenu()
--- a/src/displays/menus/motorfeedbackdebugmenu.h
+++ b/src/displays/menus/motorfeedbackdebugmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
@ -22,21 +21,20 @@ template<const char *Ttext, typename Ttexts, template<int> class ColorInterface>
 class MotorFeedbackDebugMenu :
    public MenuDisplay,
    public StaticText<Ttext>,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<DebugMenu>>
 {
 public:
    MotorFeedbackDebugMenu()
    {
-        constructItem<makeComponent<MenuItem, typename Ttexts::AngleText,        ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::SpeedText,        ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::SpeedKmhText,     ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::ErrorText,        ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::CurrentText,      ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::CurrentFixedText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::ChopsText,        ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::HallText,         ColorInterface<TFT_DARKGREY>, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                             SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::AngleText,        ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::SpeedText,        ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::SpeedKmhText,     ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::ErrorText,        ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::CurrentText,      ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::CurrentFixedText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::ChopsText,        ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::HallText,         ColorInterface<TFT_DARKGREY>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                             SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };

--- a/src/displays/menus/motorstatedebugmenu.h
+++ b/src/displays/menus/motorstatedebugmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
@ -21,22 +20,21 @@ template<const char *Ttext, typename Ttexts>
 class MotorStateDebugMenu :
    public MenuDisplay,
    public StaticText<Ttext>,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<DebugMenu>>
 {
 public:
    MotorStateDebugMenu()
    {
-        constructItem<makeComponent<MenuItem, typename Ttexts::EnableText,       DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::PwmText,          DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::CtrlTypText,      DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::CtrlModText,      DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::IMotMaxText,      DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::IDcMaxText,       DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::NMotMaxText,      DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::FieldWeakMaxText, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, typename Ttexts::PhaseAdvMaxText,  DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,    SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::EnableText,       DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::PwmText,          DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::CtrlTypText,      DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::CtrlModText,      DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::IMotMaxText,      DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::IDcMaxText,       DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::NMotMaxText,      DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::FieldWeakMaxText, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, typename Ttexts::PhaseAdvMaxText,  DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,    SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };

--- a/src/displays/menus/presetsmenu.h
+++ b/src/displays/menus/presetsmenu.h
@ -3,7 +3,6 @@
 // local includes
 #include "actioninterface.h"
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "actions/multiaction.h"
 #include "actions/switchscreenaction.h"
@ -77,24 +76,23 @@ public:
 class PresetsMenu :
    public MenuDisplay,
    public StaticText<TEXT_PRESETS>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
 {
 public:
    PresetsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTEVERYTHING>,            MultiAction<ApplySettingsPresetAction<&presets::defaultSettings>, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTLIMITS>,                MultiAction<ApplyLimitsPresetAction<&presets::defaultLimits>, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_KIDSLIMITS>,                   MultiAction<ApplyLimitsPresetAction<&presets::kidsLimits>, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTCONTROLLERHARDWARE>,    MultiAction<ApplyControllerHardwarePresetAction<&presets::defaultControllerHardware>, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETSOFFCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::mosfetsOffControllerHardware>, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SPINNERCONTROLLERHARDWARE>,    MultiAction<ApplyControllerHardwarePresetAction<&presets::spinnerControllerHardware>, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTBOARDCOMPUTERHARDWARE>, MultiAction<ApplyBoardcomputerHardwarePresetAction<&presets::defaultBoardcomputerHardware>, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTDEFAULTMODE>,           MultiAction<ApplyDefaultModePresetAction<&presets::defaultDefaultMode>, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SINUSOIDALDEFAULTMODE>,        MultiAction<ApplyDefaultModePresetAction<&presets::sinusoidalDefaultMode>, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTTEMPOMATMODE>,          MultiAction<ApplyTempomatModePresetAction<&presets::defaultTempomatMode>, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTLARSMMODE>,             MultiAction<ApplyLarsmModePresetAction<&presets::defaultLarsmMode>, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                         SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTEVERYTHING>,            MultiAction<ApplySettingsPresetAction<&presets::defaultSettings>, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTLIMITS>,                MultiAction<ApplyLimitsPresetAction<&presets::defaultLimits>, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_KIDSLIMITS>,                   MultiAction<ApplyLimitsPresetAction<&presets::kidsLimits>, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTCONTROLLERHARDWARE>,    MultiAction<ApplyControllerHardwarePresetAction<&presets::defaultControllerHardware>, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETSOFFCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::mosfetsOffControllerHardware>, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SPINNERCONTROLLERHARDWARE>,    MultiAction<ApplyControllerHardwarePresetAction<&presets::spinnerControllerHardware>, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTBOARDCOMPUTERHARDWARE>, MultiAction<ApplyBoardcomputerHardwarePresetAction<&presets::defaultBoardcomputerHardware>, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTDEFAULTMODE>,           MultiAction<ApplyDefaultModePresetAction<&presets::defaultDefaultMode>, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SINUSOIDALDEFAULTMODE>,        MultiAction<ApplyDefaultModePresetAction<&presets::sinusoidalDefaultMode>, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTTEMPOMATMODE>,          MultiAction<ApplyTempomatModePresetAction<&presets::defaultTempomatMode>, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTLARSMMODE>,             MultiAction<ApplyLarsmModePresetAction<&presets::defaultLarsmMode>, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                         SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/profilesmenu.h
+++ b/src/displays/menus/profilesmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "actions/switchprofileaction.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
@ -17,17 +16,16 @@ namespace {
 class ProfilesMenu :
    public MenuDisplay,
    public StaticText<TEXT_PROFILES>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
 {
 public:
    ProfilesMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE0>, SwitchProfileAction<0>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE1>, SwitchProfileAction<1>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE2>, SwitchProfileAction<2>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE3>, SwitchProfileAction<3>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,     SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE0>, SwitchProfileAction<0>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE1>, SwitchProfileAction<1>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE2>, SwitchProfileAction<2>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE3>, SwitchProfileAction<3>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,     SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/selectmodemenu.h
+++ b/src/displays/menus/selectmodemenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "actions/multiaction.h"
 #include "actions/switchscreenaction.h"
@ -37,21 +36,20 @@ using SetGametrakModeAction = SetterAction<ModeInterface*, currentMode, Gametrak
 class SelectModeMenu :
    public MenuDisplay,
    public StaticText<TEXT_SELECTMODE>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
 {
    using Base = MenuDisplay;

 public:
    SelectModeMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULT>,   MultiAction<SetDefaultModeAction, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_TEMPOMAT>,  MultiAction<SetTempomatModeAction, SwitchScreenAction<MainMenu>>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_LARSM>,     MultiAction<SetLarsmModeAction, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULT>,   MultiAction<SetDefaultModeAction, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TEMPOMAT>,  MultiAction<SetTempomatModeAction, SwitchScreenAction<MainMenu>>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LARSM>,     MultiAction<SetLarsmModeAction, SwitchScreenAction<MainMenu>>>>();
 #ifdef FEATURE_GAMETRAK
        constructItem<makeComponent<MenuItem, StaticText<TEXT_GAMETRAK>,  MultiAction<SetGametrakModeAction, SwitchScreenAction<MainMenu>>>>();
 #endif
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,      SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,      SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
    }

    void start() override;
--- a/src/displays/menus/settingsmenu.h
+++ b/src/displays/menus/settingsmenu.h
@ -5,7 +5,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "actions/toggleboolaction.h"
 #include "actions/switchscreenaction.h"
@ -42,28 +41,27 @@ struct BackLedAccessor : public RefAccessor<bool> { bool &getRef() const overrid
 class SettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_SETTINGS>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
 {
 public:
    SettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_LIMITSSETTINGS>,                SwitchScreenAction<LimitsSettingsMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFISETTINGS>,                  SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::wifi>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LIMITSSETTINGS>,                SwitchScreenAction<LimitsSettingsMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISETTINGS>,                  SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::wifi>>>();
 #ifdef FEATURE_BLUETOOTH
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHSETTINGS>,             SwitchScreenAction<BluetoothSettingsMenu>, StaticMenuItemIcon<&icons::bluetooth>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHSETTINGS>,             SwitchScreenAction<BluetoothSettingsMenu>, StaticMenuItemIcon<&icons::bluetooth>>>();
 #endif
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_MODESSETTINGS>,                 SwitchScreenAction<ModesSettingsMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_CONTROLLERHARDWARESETTINGS>,    SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::hardware>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BOARDCOMPUTERHARDWARESETTINGS>, SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::hardware>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MODESSETTINGS>,                 SwitchScreenAction<ModesSettingsMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CONTROLLERHARDWARESETTINGS>,    SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::hardware>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BOARDCOMPUTERHARDWARESETTINGS>, SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::hardware>>>();
 #if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_AUTOCONNECTBMS>,                ToggleBoolAction, CheckboxIcon, AutoConnectBmsAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AUTOCONNECTBMS>,                ToggleBoolAction, CheckboxIcon, AutoConnectBmsAccessor>>();
 #endif
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BUZZER>,                        SwitchScreenAction<BuzzerMenu>, StaticMenuItemIcon<&icons::buzzer>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLED>,                      ToggleBoolAction, CheckboxIcon, FrontLedAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKLED>,                       ToggleBoolAction, CheckboxIcon, BackLedAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_ABOUT>,                         SwitchScreenAction<AboutMenu>, StaticMenuItemIcon<&icons::info>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                          SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BUZZER>,                        SwitchScreenAction<BuzzerMenu>, StaticMenuItemIcon<&icons::buzzer>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLED>,                      ToggleBoolAction, CheckboxIcon, FrontLedAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKLED>,                       ToggleBoolAction, CheckboxIcon, BackLedAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ABOUT>,                         SwitchScreenAction<AboutMenu>, StaticMenuItemIcon<&icons::info>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                          SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/stationwifisettingsmenu.h
+++ b/src/displays/menus/stationwifisettingsmenu.h
@ -5,7 +5,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
@ -29,34 +28,33 @@ namespace {
 class StationWifiSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_STATIONWIFISETTINGS>,
-    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
 {
 public:
    StationWifiSettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFIRECONNECT>,           WifiReconnectAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFIDISCONNECT>,          WifiDisconnectAction>>();
-        constructItem<makeComponent<MenuItem, WifiIsConnectedText,                      StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEAUTOCONNECT>,   ToggleBoolAction, CheckboxIcon, WifiAutoConnectAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEAUTORECONNECT>, ToggleBoolAction, CheckboxIcon, WifiAutoReconnectAccessor>>();
-        constructItem<makeComponent<MenuItem, WifiLocalIpText,                          StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiMacAddressText,                       StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiSubnetMaskText,                       StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiGatewayIpText,                        StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiDnsIpText,                            StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiBroadcastIpText,                      StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiNetworkIdText,                        StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiSubnetCIDRText,                       StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFIENABLEIPV6>,          WifiEnableIpV6Action>>();
-        constructItem<makeComponent<MenuItem, WifiLocalIpV6Text,                        StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiHostnameText,                         StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiStatusText,                           StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiSsidText,                             StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiPskText,                              StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiBssidText,                            StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, WifiRssiText,                             StaticFont<2>, DisabledColor, DummyAction>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                    SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIRECONNECT>,           WifiReconnectAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIDISCONNECT>,          WifiDisconnectAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiIsConnectedText,                      StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEAUTOCONNECT>,   ToggleBoolAction, CheckboxIcon, WifiAutoConnectAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEAUTORECONNECT>, ToggleBoolAction, CheckboxIcon, WifiAutoReconnectAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, WifiLocalIpText,                          StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiMacAddressText,                       StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiSubnetMaskText,                       StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiGatewayIpText,                        StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiDnsIpText,                            StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiBroadcastIpText,                      StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiNetworkIdText,                        StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiSubnetCIDRText,                       StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIENABLEIPV6>,          WifiEnableIpV6Action>>();
+        constructMenuItem<makeComponent<MenuItem, WifiLocalIpV6Text,                        StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiHostnameText,                         StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiStatusText,                           StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiSsidText,                             StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiPskText,                              StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiBssidText,                            StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, WifiRssiText,                             StaticFont<2>, DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                    SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/tempomatmodesettingsmenu.h
+++ b/src/displays/menus/tempomatmodesettingsmenu.h
@ -2,7 +2,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "menuitem.h"
@ -29,14 +28,13 @@ using TempomatModeModelModeChangeScreen = makeComponent<
 class TempomatModeSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_TEMPOMATMODESETTINGS>,
-    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
 {
 public:
    TempomatModeSettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<TempomatModeModelModeChangeScreen>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,         SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<TempomatModeModelModeChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,         SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/timersmenu.h
+++ b/src/displays/menus/timersmenu.h
@ -3,7 +3,6 @@
 // local includes
 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
@ -61,18 +60,17 @@ using DisplayRedrawRateChangeDisplay = makeComponent<
 class TimersMenu :
    public MenuDisplay,
    public StaticText<TEXT_TIMERS>,
-    public BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>
 {
 public:
    TimersMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_POTIREADRATE>,      SwitchScreenAction<PotiReadRateChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_MODEUPDATERATE>,    SwitchScreenAction<ModeUpdateRateChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_STATSUPDATERATE>,   SwitchScreenAction<StatsUpdateRateChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DISPLAYUPDATERATE>, SwitchScreenAction<DisplayUpdateRateChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_DISPLAYREDRAWRATE>, SwitchScreenAction<DisplayRedrawRateChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POTIREADRATE>,      SwitchScreenAction<PotiReadRateChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MODEUPDATERATE>,    SwitchScreenAction<ModeUpdateRateChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATSUPDATERATE>,   SwitchScreenAction<StatsUpdateRateChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISPLAYUPDATERATE>, SwitchScreenAction<DisplayUpdateRateChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISPLAYREDRAWRATE>, SwitchScreenAction<DisplayRedrawRateChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/menus/wifiscanmenu.h
+++ b/src/displays/menus/wifiscanmenu.h
@ -6,7 +6,6 @@

 // local includes
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "actions/multiaction.h"
 #include "actions/switchscreenaction.h"
@ -21,11 +20,13 @@ class WifiSettingsMenu;
 } // namespace

 namespace {
-class WifiScanMenu : public MenuDisplay, public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>, public ContainerMenuDefinition
+class WifiScanMenu : public MenuDisplay, public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
 {
    using Base = MenuDisplay;

 public:
+    WifiScanMenu();
+
    String text() const override;

    void start() override;
@ -38,9 +39,14 @@ private:
    std::vector<std::unique_ptr<makeComponent<MenuItem, ChangeableText, DummyAction>>> m_reusableItems;
 };

+WifiScanMenu::WifiScanMenu()
+{
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+}
+
 String WifiScanMenu::text() const
 {
-    auto text = String{size()-1} + " found";
+    auto text = String{menuItemCount()-1} + " found";
    switch (WiFi.scanComplete())
    {
    case WIFI_SCAN_RUNNING: text += " (scanning)"; break;
@ -51,8 +57,6 @@ String WifiScanMenu::text() const

 void WifiScanMenu::start()
 {
-    constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
-
    Base::start();

    m_lastScanComplete = 0;
@ -68,16 +72,16 @@ void WifiScanMenu::update()
        const auto now = millis();
        if (!m_lastScanComplete)
        {
-            auto backButton = takeLast();
+            auto backButton = takeLastMenuItem();

            for (std::size_t i = 0; i < n; i++)
            {
                const auto ssid = WiFi.SSID(i);
-                if (size() <= i)
+                if (menuItemCount() <= i)
                {
                    if (m_reusableItems.empty())
                    {
-                        auto &item = constructItem<makeComponent<MenuItem, ChangeableText, DummyAction>>();
+                        auto &item = constructMenuItem<makeComponent<MenuItem, ChangeableText, DummyAction>>();
                        item.setTitle(ssid);
                    }
                    else
@ -85,7 +89,7 @@ void WifiScanMenu::update()
                        std::unique_ptr<makeComponent<MenuItem, ChangeableText, DummyAction>> ptr = std::move(m_reusableItems.back());
                        m_reusableItems.pop_back();
                        ptr->setTitle(ssid);
-                        emplaceItem(std::move(ptr));
+                        emplaceMenuItem(std::move(ptr));
                    }
                }
                else
@ -95,10 +99,10 @@ void WifiScanMenu::update()
                }
            }

-            while (size() > n)
-                m_reusableItems.emplace_back((makeComponent<MenuItem, ChangeableText, DummyAction>*)takeLast().release());
+            while (menuItemCount() > n)
+                m_reusableItems.emplace_back((makeComponent<MenuItem, ChangeableText, DummyAction>*)takeLastMenuItem().release());

-            emplaceItem(std::move(backButton));
+            emplaceMenuItem(std::move(backButton));

            m_lastScanComplete = now;
        }
--- a/src/displays/menus/wifisettingsmenu.h
+++ b/src/displays/menus/wifisettingsmenu.h
@ -3,7 +3,6 @@
 // local includes
 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "containermenudefinition.h"
 #include "utils.h"
 #include "actions/switchscreenaction.h"
 #include "actions/toggleboolaction.h"
@ -36,19 +35,18 @@ using AutoWifiModeChangeDisplay = makeComponent<
 class WifiSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_WIFISETTINGS>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public ContainerMenuDefinition
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
 {
 public:
    WifiSettingsMenu()
    {
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_AUTOWIFIMODE>,            SwitchScreenAction<AutoWifiModeChangeDisplay>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_AUTOENABLEAP>,            ToggleBoolAction, CheckboxIcon, AutoEnableApAccessor>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_GENERICWIFISETTINGS>,     SwitchScreenAction<GenericWifiSettingsMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_STATIONWIFISETTINGS>,     SwitchScreenAction<StationWifiSettingsMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFISCAN>,                SwitchScreenAction<WifiScanMenu>, StaticMenuItemIcon<&icons::scan>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_ACCESSPOINTWIFISETTINGS>, SwitchScreenAction<AccessPointWifiSettingsMenu>>>();
-        constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                    SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AUTOWIFIMODE>,            SwitchScreenAction<AutoWifiModeChangeDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AUTOENABLEAP>,            ToggleBoolAction, CheckboxIcon, AutoEnableApAccessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GENERICWIFISETTINGS>,     SwitchScreenAction<GenericWifiSettingsMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATIONWIFISETTINGS>,     SwitchScreenAction<StationWifiSettingsMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISCAN>,                SwitchScreenAction<WifiScanMenu>, StaticMenuItemIcon<&icons::scan>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ACCESSPOINTWIFISETTINGS>, SwitchScreenAction<AccessPointWifiSettingsMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,                    SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
    }
 };
 } // namespace
--- a/src/displays/updatedisplay.h
+++ b/src/displays/updatedisplay.h
@ -18,7 +18,7 @@ class StatusDisplay;
 }

 namespace {
-#ifdef FEATURE_OTA
+#ifdef FEATURE_ARDUINOOTA
 class UpdateDisplay : public Display, public DummyBack
 {
 public:
--- a/src/icons/logo.h
+++ b/src/icons/logo.h
@ -4,6 +4,7 @@

 namespace {
 namespace icons {
+/*
 const Icon<240, 130> logo{{
    0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0010 (16) pixels
    0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0020 (32) pixels
@ -1956,5 +1957,6 @@ const Icon<240, 130> logo{{
    0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x79D0 (31184) pixels
    0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x79E0 (31200) pixels
 }};
+*/
 }
 }
--- a/src/main.cpp
+++ b/src/main.cpp
@ -88,16 +88,28 @@ millis_t lastDisplayUpdate{};
 millis_t lastDisplayRedraw{};
 }

+void printMemoryStats(const char *s)
+{
+    Serial.printf("MEMORY %s 8bit: %u 32bit: %u\r\n",
+                  s,
+                  heap_caps_get_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT),
+                  heap_caps_get_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_32BIT));
+}
+
 void setup()
 {
    Serial.begin(115200);
    Serial.setDebugOutput(true);
-    Serial.println("setup()");
+    //Serial.println("setup()");
+
+    printMemoryStats("setup()");
+
    pinMode(3, INPUT_PULLUP);

    currentlyReverseBeeping = false;

    initScreen();
+    printMemoryStats("initScreen()");

 #ifdef FEATURE_DPAD
    bootLabel.redraw("dpad");
@ -140,9 +152,11 @@ void setup()
            loadSettings();
        }
    }
+    printMemoryStats("loadSettings()");

    bootLabel.redraw("swap front back");
    updateSwapFrontBack();
+    printMemoryStats("swapFronBack()");

    bootLabel.redraw("deviceName");
    {
@ -150,39 +164,47 @@ void setup()
        WiFi.macAddress(&macAddress[0]);
        std::sprintf(deviceName, STRING(DEVICE_PREFIX) "_%02hhx%02hhx%02hhx", macAddress[3], macAddress[4], macAddress[5]);
    }
+    printMemoryStats("deviceName");

    bootLabel.redraw("setHostname");
    if (!WiFi.setHostname(deviceName))
        Serial.println("Could not setHostname");
+    printMemoryStats("setHostname()");

    bootLabel.redraw("softAPsetHostname");
    if (!WiFi.softAPsetHostname(deviceName))
        Serial.println("Could not softAPsetHostname");
+    printMemoryStats("softAPsetHostname()");

    bootLabel.redraw("WiFi mode");
    if (!WiFi.mode(settings.wifiSettings.autoWifiMode))
        Serial.println("Could not set mode to WIFI_AP_STA");
+    printMemoryStats("WiFi.mode()");

    if (settings.wifiSettings.autoEnableAp)
    {
        bootLabel.redraw("WiFi softAp");
        WifiSoftApAction{}.triggered();
    }
+    printMemoryStats("WifiSoftApAction()");

    bootLabel.redraw("WiFi begin");
    if (!WiFi.begin("realraum", "r3alraum"))
        Serial.println("Could not begin WiFi");
+    printMemoryStats("WiFi.begin()");

 #ifdef FEATURE_BLUETOOTH
    if (settings.bluetoothSettings.autoBluetoothMode == BluetoothMode::Master)
    {
        bootLabel.redraw("bluetooth begin master");
        BluetoothBeginMasterAction{}.triggered();
+        printMemoryStats("BluetoothBeginMasterAction()");
 #ifdef FEATURE_BMS
        if (settings.autoConnectBms)
        {
            bootLabel.redraw("connect BMS");
            BluetoothConnectBmsAction{}.triggered();
+            printMemoryStats("BluetoothConnectBmsAction()");
        }
 #endif
    }
@ -190,6 +212,7 @@ void setup()
    {
        bootLabel.redraw("bluetooth begin");
        BluetoothBeginAction{}.triggered();
+        printMemoryStats("BluetoothBeginAction()");
    }
 #endif

@ -209,16 +232,19 @@ void setup()

    currentMode = &modes::defaultMode;

-#ifdef FEATURE_OTA
+#ifdef FEATURE_ARDUINOOTA
    bootLabel.redraw("ota");
    initOta();
+    printMemoryStats("initOta()");
 #endif

    bootLabel.redraw("webserver");
    initWebserver();
+    printMemoryStats("initWebserver()");

    bootLabel.redraw("potis");
    readPotis();
+    printMemoryStats("readPotis()");

 #if defined(FEATURE_DPAD_5WIRESW) && defined(DPAD_5WIRESW_DEBUG)
    switchScreen<DPad5WireDebugDisplay>();
@ -229,10 +255,15 @@ void setup()
        switchScreen<CalibrateDisplay>(true);
    else
        switchScreen<StatusDisplay>();
+
+    printMemoryStats("switchScreen()");
 }

 void loop()
 {
+    //Serial.println("loop()");
+    //printMemoryStats("loop()");
+
    const auto now = millis();

 #ifdef FEATURE_DPAD
@ -306,7 +337,7 @@ void loop()

    handleSerial();

-#ifdef FEATURE_OTA
+#ifdef FEATURE_ARDUINOOTA
    handleOta();
 #endif

--- a/src/menudefinitioninterface.h
+++ b/src/menudefinitioninterface.h
@ -1,19 +0,0 @@
-#pragma once
-
-#include <utility>
-
-#include "menuitem.h"
-
-namespace {
-class MenuDefinitionInterface
-{
-public:
-    virtual std::size_t size() const = 0;
-
-    virtual MenuItem& getMenuItem(std::size_t index) = 0;
-    virtual const MenuItem& getMenuItem(std::size_t index) const = 0;
-
-    virtual void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) = 0;
-    virtual void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const = 0;
-};
-}
--- a/src/menudisplay.h
+++ b/src/menudisplay.h
@ -8,11 +8,10 @@
 #include "textinterface.h"
 #include "widgets/label.h"
 #include "globals.h"
-#include "menudefinitioninterface.h"
 #include "menuitem.h"

 namespace {
-class MenuDisplay : public Display, public virtual TextInterface, public virtual MenuDefinitionInterface
+class MenuDisplay : public Display, public virtual TextInterface
 {
 public:
    void start() override;
@ -32,6 +31,66 @@ public:

    int selectedIndex() const { return m_selectedIndex; }

+
+    std::size_t menuItemCount() const { return m_menuItems.size(); }
+
+    MenuItem& getMenuItem(std::size_t index)
+    {
+        if (index < m_menuItems.size())
+            return *m_menuItems[index].get();
+
+        throw "aua";
+    }
+
+    const MenuItem& getMenuItem(std::size_t index) const
+    {
+        if (index < m_menuItems.size())
+            return *m_menuItems[index].get();
+
+        throw "aua";
+    }
+
+    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback)
+    {
+        for (const auto &ptr : m_menuItems)
+            callback(*ptr);
+    }
+
+    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const
+    {
+        for (const auto &ptr : m_menuItems)
+            callback(*ptr);
+    }
+
+    template<typename T, typename... Args>
+    T &constructMenuItem(Args&&... args)
+    {
+        auto ptr = std::make_unique<T>(std::forward<Args>(args)...);
+        T &ref = *ptr;
+        emplaceMenuItem(std::move(ptr));
+        return ref;
+    }
+
+    void emplaceMenuItem(std::unique_ptr<MenuItem> &&ptr)
+    {
+        m_menuItems.emplace_back(std::move(ptr));
+    }
+
+    void clearMenuItems()
+    {
+        m_menuItems.clear();
+    }
+
+    std::unique_ptr<MenuItem> takeLastMenuItem()
+    {
+        if (m_menuItems.empty())
+            throw "aua";
+
+        std::unique_ptr<MenuItem> ptr = std::move(m_menuItems.back());
+        m_menuItems.pop_back();
+        return ptr;
+    }
+
 protected:
    void setSelectedIndex(int selectedIndex) { m_selectedIndex = selectedIndex; }

@ -65,6 +124,8 @@ private:

    int m_rotateOffset;
    bool m_pressed;
+
+    std::vector<std::unique_ptr<MenuItem>> m_menuItems;
 };

 void MenuDisplay::start()
@ -102,7 +163,7 @@ void MenuDisplay::update()
        const auto offset = m_rotateOffset;
        m_rotateOffset = 0;

-        const auto itemCount = size();
+        const auto itemCount = menuItemCount();

        if (itemCount)
        {
--- a/src/ota.h
+++ b/src/ota.h
@ -1,14 +1,15 @@
 #pragma once

-#ifdef FEATURE_OTA
+#ifdef FEATURE_ARDUINOOTA
 #include <ArduinoOTA.h>
 #endif

 #include "screens.h"
+#include "globals.h"
 #include "displays/updatedisplay.h"

 namespace {
-#ifdef FEATURE_OTA
+#ifdef FEATURE_ARDUINOOTA
 void initOta()
 {
    ArduinoOTA
@ -24,18 +25,18 @@ void initOta()
            switchScreenImpl<UpdateDisplay>("Updating " + type);
        })
        .onEnd([]() {
-            getRefByType<UpdateDisplay>().m_finished = true;
-            getRefByType<UpdateDisplay>().redraw();
+            ((UpdateDisplay*)currentDisplay.get())->m_finished = true;
+            ((UpdateDisplay*)currentDisplay.get())->redraw();
        })
        .onProgress([](unsigned int progress, unsigned int total) {
-            getRefByType<UpdateDisplay>().m_progress = progress;
-            getRefByType<UpdateDisplay>().m_total = total;
-            getRefByType<UpdateDisplay>().redraw();
+            ((UpdateDisplay*)currentDisplay.get())->m_progress = progress;
+            ((UpdateDisplay*)currentDisplay.get())->m_total = total;
+            ((UpdateDisplay*)currentDisplay.get())->redraw();
        })
        .onError([](ota_error_t error) {
-            getRefByType<UpdateDisplay>().m_error = error;
-            getRefByType<UpdateDisplay>().m_errorValid = true;
-            getRefByType<UpdateDisplay>().redraw();
+            ((UpdateDisplay*)currentDisplay.get())->m_error = error;
+            ((UpdateDisplay*)currentDisplay.get())->m_errorValid = true;
+            ((UpdateDisplay*)currentDisplay.get())->redraw();
        });

    ArduinoOTA.begin();
--- a/src/screens.h
+++ b/src/screens.h
@ -50,7 +50,7 @@ void initScreen()
    tft.fillScreen(TFT_WHITE);
    tft.setTextColor(TFT_BLACK, TFT_WHITE);
    tft.setTextFont(4);
-    tft.pushImage(0, 40, icons::logo.WIDTH, icons::logo.HEIGHT, icons::logo.buffer);
+    //tft.pushImage(0, 40, icons::logo.WIDTH, icons::logo.HEIGHT, icons::logo.buffer);
    tft.drawString("Bobbycar-OS", 32, 200);
    tft.drawString("booting...", 32, 225);
    bootLabel.start();