Merge pull request #78 from bobbycar-graz/reduce-code-size

Reduce code size
2021-01-03 03:59:50 +01:00
parent 8add1a991a eb73d564fa
commit 31aedecfe2
55 changed files with 1260 additions and 1667 deletions
--- a/backtrace.sh
+++ b/backtrace.sh
@ -0,0 +1,32 @@
+#!/bin/bash
+
+GDB_BINARY=~/.platformio/packages/toolchain-xtensa32/bin/xtensa-esp32-elf-gdb
+ELF_FILE=.pio/build/feedc0de_usb/firmware.elf
+
+if [[ ! -x "$GDB_BINARY" ]]
+then
+    echo Could not find gdb binary: "$GDB_BINARY"
+    exit 1
+fi
+
+if [[ ! -f "$ELF_FILE" ]]
+then
+    echo Could not find elf file: "$ELF_FILE"
+    exit 1
+fi
+
+ls -lah "$ELF_FILE"
+
+PARAMS=()
+for i in $@
+do
+	ADDR="$(echo "$i" | cut -d ":" -f 1)"
+	OUTPUT="$($GDB_BINARY --batch $ELF_FILE -ex "set listsize 1" -ex "l *$ADDR" -ex "q")"
+
+        if [[ -z "$OUTPUT" ]]
+        then
+            echo "${ADDR} gdb empty output"
+        else
+            echo "${OUTPUT}"
+        fi
+done
--- 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
@ -1,13 +1,22 @@
 #pragma once

+// 3rdparty lib includes
 #include <ESPAsyncWebServer.h>

+// local includes
 #include "screens.h"
+#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) :
@ -29,6 +38,8 @@ private:

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

    webServer.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
@ -64,7 +75,7 @@ void initWebserver()
                                    "<a href=\"/back\">Back</a>");
                }

-                if (auto constCurrentDisplay = static_cast<const Display *>(currentDisplay))
+                if (auto constCurrentDisplay = static_cast<const Display *>(currentDisplay.get()))
                {
                    if (const auto *textInterface = constCurrentDisplay->asTextInterface())
                    {
@ -179,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;
@ -230,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
@ -2,7 +2,6 @@

 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/setvalueaction.h"
 #include "actions/backproxyaction.h"
@ -23,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
@ -2,7 +2,6 @@

 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "actioninterface.h"
 #include "utils.h"
 #include "actions/setvalueaction.h"
@ -20,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
@ -2,7 +2,6 @@

 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/setvalueaction.h"
 #include "actions/backproxyaction.h"
@ -19,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
@ -2,7 +2,6 @@

 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/setvalueaction.h"
 #include "actions/backproxyaction.h"
@ -19,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
@ -2,7 +2,6 @@

 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/setvalueaction.h"
 #include "actions/backproxyaction.h"
@ -20,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
@ -2,7 +2,6 @@

 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/setvalueaction.h"
 #include "actions/backproxyaction.h"
@ -20,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
@ -4,7 +4,6 @@

 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/setvalueaction.h"
 #include "actions/backproxyaction.h"
@ -21,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
@ -4,7 +4,6 @@

 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/setvalueaction.h"
 #include "actions/backproxyaction.h"
@ -21,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/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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/dummyaction.h"
 #include "actions/switchscreenaction.h"
@ -9,9 +9,10 @@
 #include "esptexthelpers.h"
 #include "texts.h"

+// forward declares
 namespace {
 class SettingsMenu;
-}
+} // namespace

 namespace {
 constexpr char TEXT_VERSION[] = "Version: 1.0";
@ -20,30 +21,33 @@ constexpr char TEXT_ESPINFO[] = "ESP info:";
 class AboutMenu :
    public MenuDisplay,
    public StaticText<TEXT_ABOUT>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_VERSION>, DummyAction>,
-        makeComponent<MenuItem, StaticText<nullptr>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_ESPINFO>, DummyAction>,
-        makeComponent<MenuItem, EspHeapSizeText,              StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspFreeHeapText,              StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspMinFreeHeapText,           StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspMaxAllocHeapText,          StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspPsramSizeText,             StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspFreePsramText,             StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspMinFreePsramText,          StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspMaxAllocPsramText,         StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspChipRevisionText,          StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspCpuFreqMHzText,            StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspCycleCountText,            StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspSdkVersionText,            StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspFlashChipSizeText,         StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspFlashChipSpeedText,        StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspFlashChipModeText,         StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspSketchSizeText,            StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspSketchMd5Text,             StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, EspFreeSketchSpaceText,       StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,        SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
+{
+public:
+    AboutMenu()
+    {
+        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
 #include "actions/wifisoftapaction.h"
@ -13,29 +13,33 @@
 #include "wifitexthelpers.h"
 #include "texts.h"

+// forward declares
 namespace {
 class WifiSettingsMenu;
-}
+} // namespace

 namespace {
 class AccessPointWifiSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_ACCESSPOINTWIFISETTINGS>,
-    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAP>,                  WifiSoftApAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPDISCONNECT>,        WifiSoftApDisconnectAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPDISCONNECTWIFIOFF>, WifiSoftApDisconnectWifioffAction>,
-        makeComponent<MenuItem, WifiSoftApGetStationNumText,                  StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiSoftApIpText,                             StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiSoftApBroadcastIpText,                    StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiSoftApNetworkIdText,                      StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiSoftApSubnetCidrText,                     StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPENABLEIPV6>,        WifiSoftApEnableIpV6Action>,
-        makeComponent<MenuItem, WifiSoftApIpV6Text,                           StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiSoftApHostnameText,                       StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiSoftApMacAddressText,                     StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,                        SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
+{
+public:
+    AccessPointWifiSettingsMenu()
+    {
+        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
@ -1,8 +1,8 @@
 #pragma once

+// local includes
 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
 #ifdef FEATURE_BLUETOOTH
@ -18,9 +18,10 @@
 #include "icons/back.h"
 #include "texts.h"

+// forward declares
 namespace {
 class SettingsMenu;
-}
+} // namespace

 namespace {
 #ifdef FEATURE_BLUETOOTH
@ -37,21 +38,24 @@ using AutoBluetoothModeChangeDisplay = makeComponent<
 class BluetoothSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_BLUETOOTHSETTINGS>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, BluetoothAvailableText,                 DisabledColor, DummyAction>,
-        makeComponent<MenuItem, BluetoothHasClientText,                 DisabledColor, DummyAction>,
-//        makeComponent<MenuItem, BluetoothConnectedText,                 DisabledColor, DummyAction>, // crashes
-        makeComponent<MenuItem, BluetoothIsReadyText,                   DisabledColor, DummyAction>,
-        makeComponent<MenuItem, BluetoothIsReadyMasterText,             DisabledColor, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHBEGIN>,        BluetoothBeginAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHBEGINMASTER>,  BluetoothBeginMasterAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHFLUSH>,        BluetoothFlushAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHEND>,          BluetoothEndAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHDISCONNECT>,   BluetoothDisconnectAction>,
-        makeComponent<MenuItem, StaticText<TEXT_AUTOBLUETOOTHMODE>,     SwitchScreenAction<AutoBluetoothModeChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,                  SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
+{
+public:
+    BluetoothSettingsMenu()
+    {
+        constructMenuItem<makeComponent<MenuItem, BluetoothAvailableText,                 DisabledColor, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, BluetoothHasClientText,                 DisabledColor, DummyAction>>();
+//        constructMenuItem<makeComponent<MenuItem, BluetoothConnectedText,                 DisabledColor, DummyAction>>(); // crashes
+        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
-}
+} // namespace
--- a/src/displays/menus/bmsmenu.h
+++ b/src/displays/menus/bmsmenu.h
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #ifdef FEATURE_BLUETOOTH
@ -18,26 +18,30 @@
 #include "icons/back.h"
 #include "texts.h"

+//forward declares
 namespace {
 class MainMenu;
-}
+} // namespace

 namespace {
 #if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
 class BmsMenu :
    public MenuDisplay,
    public StaticText<TEXT_BMS>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_CONNECTBMS>,       BluetoothConnectBmsAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DISCONNECTBMS>,    BluetoothDisconnectAction>,
-        makeComponent<MenuItem, BluetoothHasClientText,            DisabledColor, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_TURNONCHARGE>,     BmsTurnOnChargeAction>,
-        makeComponent<MenuItem, StaticText<TEXT_TURNOFFCHARGE>,    BmsTurnOffChargeAction>,
-        makeComponent<MenuItem, StaticText<TEXT_TURNONDISCHARGE>,  BmsTurnOnDischargeAction>,
-        makeComponent<MenuItem, StaticText<TEXT_TURNOFFDISCHARGE>, BmsTurnOffDischargeAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,             SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
+{
+public:
+    BmsMenu()
+    {
+        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
-}
+} // namespace
--- a/src/displays/menus/boardcomputerhardwaresettingsmenu.h
+++ b/src/displays/menus/boardcomputerhardwaresettingsmenu.h
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "actions/dummyaction.h"
@ -12,13 +12,14 @@
 #include "texts.h"
 #include "settingsaccessors.h"

+// forward declares
 namespace {
 class BoardcomputerHardwareSettingsMenu;
 class CalibrateDisplay;
 class GametrakCalibrateDisplay;
 class TimersMenu;
 class SettingsMenu;
-}
+} // namespace

 namespace {
 struct GasText : public virtual TextInterface {
@ -137,36 +138,39 @@ using GametrakDistMaxChangeScreen = makeComponent<
 class BoardcomputerHardwareSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_BOARDCOMPUTERHARDWARESETTINGS>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, GasText,                             DisabledColor, StaticFont<2>, DummyAction>,
-        makeComponent<MenuItem, BremsText,                           DisabledColor, StaticFont<2>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_CALIBRATE>,          SwitchScreenAction<CalibrateDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETSAMPLECOUNT>,     SwitchScreenAction<SampleCountChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETGASMIN>,          SwitchScreenAction<GasMinChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETGASMAX>,          SwitchScreenAction<GasMaxChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETBREMSMIN>,        SwitchScreenAction<BremsMinChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETBREMSMAX>,        SwitchScreenAction<BremsMaxChangeScreen>>,
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
+{
+public:
+    BoardcomputerHardwareSettingsMenu()
+    {
+        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)
-        makeComponent<MenuItem, StaticText<TEXT_SETDPADDEBOUNCE>,    SwitchScreenAction<DPadDebounceChangeScreen>>,
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETDPADDEBOUNCE>,    SwitchScreenAction<DPadDebounceChangeScreen>>>();
 #endif
 #ifdef FEATURE_GAMETRAK
-        makeComponent<MenuItem, StaticText<nullptr>,                 DummyAction>,
-        makeComponent<MenuItem, GametrakXText,                       DisabledColor, StaticFont<2>, DummyAction>,
-        makeComponent<MenuItem, GametrakYText,                       DisabledColor, StaticFont<2>, DummyAction>,
-        makeComponent<MenuItem, GametrakDistText,                    DisabledColor, StaticFont<2>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_GAMETRAKCALIBRATE>,  SwitchScreenAction<GametrakCalibrateDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKXMIN>,    SwitchScreenAction<GametrakXMinChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKXMAX>,    SwitchScreenAction<GametrakXMaxChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKYMIN>,    SwitchScreenAction<GametrakYMinChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKYMAX>,    SwitchScreenAction<GametrakYMaxChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMIN>, SwitchScreenAction<GametrakDistMinChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMAX>, SwitchScreenAction<GametrakDistMaxChangeScreen>>,
+        constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>,                 DummyAction>,
+        constructMenuItem<makeComponent<MenuItem, GametrakXText,                       DisabledColor, StaticFont<2>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, GametrakYText,                       DisabledColor, StaticFont<2>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, GametrakDistText,                    DisabledColor, StaticFont<2>, DummyAction>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GAMETRAKCALIBRATE>,  SwitchScreenAction<GametrakCalibrateDisplay>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKXMIN>,    SwitchScreenAction<GametrakXMinChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKXMAX>,    SwitchScreenAction<GametrakXMaxChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKYMIN>,    SwitchScreenAction<GametrakYMinChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKYMAX>,    SwitchScreenAction<GametrakYMaxChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMIN>, SwitchScreenAction<GametrakDistMinChangeScreen>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMAX>, SwitchScreenAction<GametrakDistMaxChangeScreen>>>();
 #endif
-        makeComponent<MenuItem, StaticText<nullptr>,                 DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_SWAPSCREENBYTES>,    ToggleBoolAction, CheckboxIcon, SwapScreenBytesAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_TIMERS>,             SwitchScreenAction<TimersMenu>>,
-        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "menuitem.h"
@ -13,10 +13,11 @@
 #include "globals.h"
 #include "settingsaccessors.h"

+// forward declares
 namespace {
 class BuzzerMenu;
 class SettingsMenu;
-}
+} // namespace

 namespace {
 struct FrontFreqAccessor : public RefAccessor<uint8_t> { uint8_t &getRef() const override { return controllers.front.command.buzzer.freq; } };
@ -87,18 +88,21 @@ using ReverseBeepDuration1ChangeScreen = makeComponent<
 class BuzzerMenu :
    public MenuDisplay,
    public StaticText<TEXT_BUZZER>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_FRONTFREQ>,            SwitchScreenAction<FrontFreqChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_FRONTPATTERN>,         SwitchScreenAction<FrontPatternChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACKFREQ>,             SwitchScreenAction<BackFreqChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACKPATTERN>,          SwitchScreenAction<BackPatternChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEP>,          ToggleBoolAction, CheckboxIcon, ReverseBeepAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ0>,     SwitchScreenAction<ReverseBeepFreq0ChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ1>,     SwitchScreenAction<ReverseBeepFreq1ChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPDURATION0>, SwitchScreenAction<ReverseBeepDuration0ChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPDURATION1>, SwitchScreenAction<ReverseBeepDuration1ChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
+{
+public:
+    BuzzerMenu()
+    {
+        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
@ -10,25 +10,30 @@
 #include "texts.h"
 #include "debugtexthelpers.h"

+// forward declares
 namespace {
 class DebugMenu;
-}
+} // namespace

 namespace {
 template<const char *Ttext, typename Ttexts>
 class CommandDebugMenu :
    public MenuDisplay,
    public StaticText<Ttext>,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, typename Ttexts::BuzzerFreqText,    DisabledColor, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::BuzzerPatternText, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::PoweroffText,      DisabledColor, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::LedText,           DisabledColor, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
+    public BackActionInterface<SwitchScreenAction<DebugMenu>>
+{
+public:
+    CommandDebugMenu()
+    {
+        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>>>();
+    }
+};

 class FrontCommandDebugMenu : public CommandDebugMenu<TEXT_FRONTCOMMAND, FrontTexts> {};
 class BackCommandDebugMenu : public CommandDebugMenu<TEXT_BACKCOMMAND, BackTexts> {};
-}
+
+} // namespace
--- a/src/displays/menus/controllerhardwaresettingsmenu.h
+++ b/src/displays/menus/controllerhardwaresettingsmenu.h
@ -2,8 +2,8 @@

 #include <ratio>

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "actions/toggleboolaction.h"
@ -14,13 +14,14 @@
 #include "globals.h"
 #include "settingsaccessors.h"

+// forward declares
 namespace {
 class ControllerHardwareSettingsMenu;
 class BoardcomputerHardwareSettingsMenu;
 class EnableMenu;
 class InvertMenu;
 class SettingsMenu;
-}
+} // namespace

 namespace {
 using WheelDiameterMmChangeScreen = makeComponent<
@ -49,15 +50,18 @@ using NumMagnetPolesChangeScreen = makeComponent<
 class ControllerHardwareSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_CONTROLLERHARDWARESETTINGS>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_SETENABLED>,        SwitchScreenAction<EnableMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETINVERTED>,       SwitchScreenAction<InvertMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERMM>,   SwitchScreenAction<WheelDiameterMmChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERINCH>, SwitchScreenAction<WheelDiameterInchChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_NUMMAGNETPOLES>,    SwitchScreenAction<NumMagnetPolesChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SWAPFRONTBACK>,     ToggleBoolAction, CheckboxIcon, SwapFrontBackAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
+{
+public:
+    ControllerHardwareSettingsMenu()
+    {
+        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/loadsettingsaction.h"
@ -16,6 +16,7 @@
 #include "texts.h"
 #include "debugcolorhelpers.h"

+// forward declares
 namespace {
 class MainMenu;
 class FrontCommandDebugMenu;
@ -31,36 +32,39 @@ class FrontRightMotorFeedbackDebugMenu;
 class BackLeftMotorFeedbackDebugMenu;
 class BackRightMotorFeedbackDebugMenu;
 class DynamicDebugMenu;
-}
+} // namespace

 namespace {
 class DebugMenu :
    public MenuDisplay,
    public StaticText<TEXT_DEBUG>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_LOADSETTINGS>,         LoadSettingsAction>,
-        makeComponent<MenuItem, StaticText<TEXT_SAVESETTINGS>,         SaveSettingsAction>,
-        makeComponent<MenuItem, StaticText<TEXT_ERASENVS>,             EraseNvsAction>,
-        makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_FRONTCOMMAND>,         SwitchScreenAction<FrontCommandDebugMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACKCOMMAND>,          SwitchScreenAction<BackCommandDebugMenu>>,
-        makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_FRONTLEFTCOMMAND>,     SwitchScreenAction<FrontLeftMotorStateDebugMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_FRONTRIGHTCOMMAND>,    SwitchScreenAction<FrontRightMotorStateDebugMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACKLEFTCOMMAND>,      SwitchScreenAction<BackLeftMotorStateDebugMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACKRIGHTCOMMAND>,     SwitchScreenAction<BackRightMotorStateDebugMenu>>,
-        makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_FRONTFEEDBACK>,        SwitchScreenAction<FrontFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACKFEEDBACK>,         SwitchScreenAction<BackFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>,
-        makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_FRONTLEFTFEEDBACK>,    SwitchScreenAction<FrontLeftMotorFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>,
-        makeComponent<MenuItem, StaticText<TEXT_FRONTRIGHTFEEDBACK>,   SwitchScreenAction<FrontRightMotorFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACKLEFTFEEDBACK>,     SwitchScreenAction<BackLeftMotorFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACKRIGHTFEEDBACK>,    SwitchScreenAction<BackRightMotorFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>,
-        makeComponent<MenuItem, StaticText<nullptr>,                   DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DYNAMICMENU>,          SwitchScreenAction<DynamicDebugMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
+{
+public:
+    DebugMenu()
+    {
+        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "menuitem.h"
@ -12,10 +12,11 @@
 #include "texts.h"
 #include "settingsaccessors.h"

+// forward declares
 namespace {
 class DefaultModeSettingsMenu;
 class ModesSettingsMenu;
-}
+} // namespace

 namespace {
 using DefaultModeModelModeChangeDisplay = makeComponent<
@ -85,21 +86,24 @@ using DefaultModeBrems2WertChangeDisplay = makeComponent<
 class DefaultModeSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_DEFAULTMODESETTIGNS>,
-    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>,       SwitchScreenAction<DefaultModeModelModeChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SQUAREGAS>,          ToggleBoolAction, CheckboxIcon, DefaultModeSquareGasAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_SQUAREBREMS>,        ToggleBoolAction, CheckboxIcon, DefaultModeSquareBremsAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHING>,    ToggleBoolAction, CheckboxIcon, DefaultModeEnableSmoothingAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_SETSMOOTHING>,       SwitchScreenAction<DefaultModeSmoothingChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETFRONTPERCENTAGE>, SwitchScreenAction<DefaultModeFrontPercentageChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETBACKPERCENTAGE>,  SwitchScreenAction<DefaultModeBackPercentageChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETADDSCHWELLE>,     SwitchScreenAction<DefaultModeAddSchwelleChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETGAS1WERT>,        SwitchScreenAction<DefaultModeGas1WertChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETGAS2WERT>,        SwitchScreenAction<DefaultModeGas2WertChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETBREMS1WERT>,      SwitchScreenAction<DefaultModeBrems1WertChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETBREMS2WERT>,      SwitchScreenAction<DefaultModeBrems2WertChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,               SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
+{
+public:
+    DefaultModeSettingsMenu()
+    {
+        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
@ -1,32 +1,36 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
 #include "texts.h"

+// forward declares
 namespace {
 class StarfieldDisplay;
 class PingPongDisplay;
 class SpiroDisplay;
 class GameOfLifeDisplay;
 class MainMenu;
-}
+} // namespace

 namespace {
 class DemosMenu :
    public MenuDisplay,
    public StaticText<TEXT_DEMOS>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_STARFIELD>,  SwitchScreenAction<StarfieldDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_PINGPONG>,   SwitchScreenAction<PingPongDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SPIRO>,      SwitchScreenAction<SpiroDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_GAMEOFLIFE>, SwitchScreenAction<GameOfLifeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,       SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
+{
+public:
+    DemosMenu()
+    {
+        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
@ -1,10 +1,11 @@
 #pragma once

+// Arduino includes
 #include <Arduino.h>
 #include <WString.h>

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
@ -16,9 +17,10 @@
 #include "texts.h"
 #include "types.h"

+// forward declares
 namespace {
 class DebugMenu;
-}
+} // namespace

 namespace {
 class RandomText : public virtual TextInterface
@ -122,34 +124,37 @@ constexpr char TEXT_DEBUGTOGGLE[] = "Toggle";
 class DynamicDebugMenu :
    public MenuDisplay,
    public RandomText,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>,
-    public StaticMenuDefinition<
+    public BackActionInterface<SwitchScreenAction<DebugMenu>>
+{
+public:
+    DynamicDebugMenu()
+    {
        // dummy items to allow for scrolling
-        makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>,
-        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
-        makeComponent<MenuItem, RandomText,                    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DYNAMICCOLOR>, RandomColor, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DYNAMICFONT>,  RandomFont, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DYNAMICICON>,  RandomIcon, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_STATICICON>,   StaticMenuItemIcon<&icons::lock>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DEBUGTOGGLE>,  ToggleBoolAction, CheckboxIcon, ToggleAccessor>,
-        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
-        makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>,    DummyAction>,
-        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>>();

-        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/toggleboolaction.h"
@ -11,21 +11,25 @@
 #include "texts.h"
 #include "settingsaccessors.h"

+// forward declares
 namespace {
 class ControllerHardwareSettingsMenu;
-}
+} // namespace

 namespace {
 class EnableMenu :
    public MenuDisplay,
    public StaticText<TEXT_SETENABLED>,
-    public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTLEFT>,  ToggleBoolAction, CheckboxIcon, FrontLeftEnabledAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightEnabledAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKLEFT>,   ToggleBoolAction, CheckboxIcon, BackLeftEnabledAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKRIGHT>,  ToggleBoolAction, CheckboxIcon, BackRightEnabledAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,             SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>
+{
+public:
+    EnableMenu()
+    {
+        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
@ -11,25 +11,31 @@
 #include "debugtexthelpers.h"
 #include "debugcolorhelpers.h"

+// forward declares
 namespace {
 class DebugMenu;
-}
+} // namespace

 namespace {
 template<const char *Ttext, typename Ttexts, template<int> class ColorInterface>
 class FeedbackDebugMenu :
    public MenuDisplay,
    public StaticText<Ttext>,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, typename Ttexts::BatVoltageText,       ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::BatVoltageFixedText,  ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::BoardTempText,        ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::BoardTempFixedText,   ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::TimeoutCntSerialText, StaticFont<2>, ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,                 SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
+    public BackActionInterface<SwitchScreenAction<DebugMenu>>
+{
+public:
+    FeedbackDebugMenu()
+    {
+        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>>>();
+    }
+};

 class FrontFeedbackDebugMenu : public FeedbackDebugMenu<TEXT_FRONTFEEDBACK, FrontTexts, FrontFeedbackColor> {};
-class BackFeedbackDebugMenu : public FeedbackDebugMenu<TEXT_BACKFEEDBACK, BackTexts, FrontFeedbackColor> {}; }
+class BackFeedbackDebugMenu : public FeedbackDebugMenu<TEXT_BACKFEEDBACK, BackTexts, FrontFeedbackColor> {};
+
+} // namespace
--- a/src/displays/menus/gametrakmodesettingsmenu.h
+++ b/src/displays/menus/gametrakmodesettingsmenu.h
@ -1,26 +1,30 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
 #include "texts.h"

+// forward declares
 namespace {
 class ModesSettingsMenu;
-}
+} // namespace

 namespace {
 #ifdef FEATURE_GAMETRAK
-class GametrakModeSettingsMenu :
+class ContainerModeSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_GAMETRAKMODESETTINGS>,
-    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
+    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
+{
+public:
+    ContainerModeSettingsMenu()
+    {
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
+    }
+};
 #endif
-}
+} // namespace
--- a/src/displays/menus/genericwifisettingsmenu.h
+++ b/src/displays/menus/genericwifisettingsmenu.h
@ -1,9 +1,10 @@
 #pragma once

+// Arduino includes
 #include <HardwareSerial.h>

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "changevaluedisplay.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
@ -15,10 +16,11 @@
 #include "wifiaccessors.h"
 #include "texts.h"

+// forward declares
 namespace {
 class GenericWifiSettingsMenu;
 class WifiSettingsMenu;
-}
+} // namespace

 namespace {
 using WifiModeChangeScreen = makeComponent<
@ -40,14 +42,17 @@ using WifiTxPowerChangeScreen = makeComponent<
 class GenericWifiSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_GENERICWIFISETTINGS>,
-    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, WifiStatusBitsText,                 DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiChannelText,                    DisabledColor, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEMODE>,    SwitchScreenAction<WifiModeChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFICHANGESLEEP>,   ToggleBoolAction, CheckboxIcon, WifiSleepAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFICHANGETXPOWER>, SwitchScreenAction<WifiTxPowerChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
+{
+public:
+    GenericWifiSettingsMenu()
+    {
+        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
@ -10,10 +10,11 @@
 #include "displays/splitgraphdisplay.h"
 #include "statistics.h"

+// forward declares
 namespace {
 class MainMenu;
 class GraphsMenu;
-}
+} // namespace

 namespace {
 using GasGraphDisplay = makeComponent<
@ -148,27 +149,30 @@ using MotorCurrentsGraphDisplay = makeComponent<
 class GraphsMenu :
    public MenuDisplay,
    public StaticText<TEXT_GRAPHS>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_GAS>,                   SwitchScreenAction<GasGraphDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_BREMS>,                 SwitchScreenAction<BremsGraphDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_POTIS>,                 SwitchScreenAction<PotisGraphDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_POTIS>,                 SwitchScreenAction<PotisSplitGraphDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_AVGSPEED>,              SwitchScreenAction<AvgSpeedGraphDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_AVGSPEEDKMH>,           SwitchScreenAction<AvgSpeedKmhGraphDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SUMCURRENT>,            SwitchScreenAction<SumCurrentGraphDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_FRONTVOLTAGE>,          SwitchScreenAction<FrontVoltageGraphDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACKVOLTAGE>,           SwitchScreenAction<BackVoltageGraphDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_VOLTAGES>,              SwitchScreenAction<VoltagesGraphDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_VOLTAGES>,              SwitchScreenAction<VoltagesSplitGraphDisplay>>,
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
+{
+public:
+    GraphsMenu()
+    {
+        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
-        makeComponent<MenuItem, StaticText<TEXT_BMSVOLTAGE>,            SwitchScreenAction<BmsVoltageGraphDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_BMSCURRENT>,            SwitchScreenAction<BmsCurrentGraphDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_BMSPOWER>,              SwitchScreenAction<BmsPowerGraphDisplay>>,
-        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
-        makeComponent<MenuItem, StaticText<TEXT_MOTORCURRENTS>,         SwitchScreenAction<MotorCurrentsGraphDisplay>>,
-        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/toggleboolaction.h"
@ -11,21 +11,25 @@
 #include "texts.h"
 #include "settingsaccessors.h"

+// forward declares
 namespace {
 class ControllerHardwareSettingsMenu;
-}
+} // namespace

 namespace {
 class InvertMenu :
    public MenuDisplay,
    public StaticText<TEXT_SETINVERTED>,
-    public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTLEFT>,  ToggleBoolAction, CheckboxIcon, FrontLeftInvertedAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightInvertedAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_INVERTBACKLEFT>,   ToggleBoolAction, CheckboxIcon, BackLeftInvertedAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_INVERTBACKRIGHT>,  ToggleBoolAction, CheckboxIcon, BackRightInvertedAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,             SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>
+{
+public:
+    InvertMenu()
+    {
+        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "menuitem.h"
@ -10,10 +10,11 @@
 #include "texts.h"
 #include "settingsaccessors.h"

+// forward declares
 namespace {
 class LarsmModeSettingsMenu;
 class ModesSettingsMenu;
-}
+} // namespace

 namespace {
 using LarsmModeModelModeChangeDisplay = makeComponent<
@ -41,12 +42,15 @@ using LarsmModeIterationsChangeDisplay = makeComponent<
 class LarsmModeSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_LARSMMODESETTINGS>,
-    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>,  SwitchScreenAction<LarsmModeModelModeChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETMODE>,       SwitchScreenAction<LarsmModeModeChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETITERATIONS>, SwitchScreenAction<LarsmModeIterationsChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,          SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
+{
+public:
+    LarsmModeSettingsMenu()
+    {
+        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "menuitem.h"
@ -10,10 +10,11 @@
 #include "texts.h"
 #include "settingsaccessors.h"

+// forward declares
 namespace {
 class LimitsSettingsMenu;
 class SettingsMenu;
-}
+} // namespace

 namespace {
 using IMotMaxChangeScreen = makeComponent<
@ -62,15 +63,18 @@ using PhaseAdvMaxChangeScreen = makeComponent<
 class LimitsSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_LIMITSSETTINGS>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_SETIMOTMAX>,      SwitchScreenAction<IMotMaxChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETIDCMAX>,       SwitchScreenAction<IDcMaxChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETNMOTMAXKMH>,   SwitchScreenAction<NMotMaxKmhChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETNMOTMAX>,      SwitchScreenAction<NMotMaxRpmChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETFIELDWEAKMAX>, SwitchScreenAction<FieldWeakMaxChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETPHASEADVMAX>,  SwitchScreenAction<PhaseAdvMaxChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,            SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
+{
+public:
+    LimitsSettingsMenu()
+    {
+        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
 #include "actions/modesettingsaction.h"
@ -18,6 +18,7 @@
 #include "icons/poweroff.h"
 #include "icons/reboot.h"

+// forward declares
 namespace {
 class StatusDisplay;
 class SelectModeMenu;
@ -31,32 +32,35 @@ class MosfetsMenu;
 class DemosMenu;
 class PoweroffDisplay;
 class DebugMenu;
-}
+} // namespace

 namespace {
 class MainMenu :
    public MenuDisplay,
    public StaticText<TEXT_MAINMENU>,
-    public BackActionInterface<SwitchScreenAction<StatusDisplay>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_STATUS>,       SwitchScreenAction<StatusDisplay>, StaticMenuItemIcon<&icons::back>>,
-        makeComponent<MenuItem, StaticText<TEXT_SELECTMODE>,   SwitchScreenAction<SelectModeMenu>, StaticMenuItemIcon<&icons::modes>>,
-        makeComponent<MenuItem, StaticText<TEXT_MODESETTINGS>, ModeSettingsAction>,
-        makeComponent<MenuItem, StaticText<TEXT_PRESETS>,      SwitchScreenAction<PresetsMenu>, StaticMenuItemIcon<&icons::presets>>,
-        makeComponent<MenuItem, StaticText<TEXT_PROFILES>,     SwitchScreenAction<ProfilesMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_GRAPHS>,       SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&icons::graph>>,
+    public BackActionInterface<SwitchScreenAction<StatusDisplay>>
+{
+public:
+    MainMenu()
+    {
+        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
-        makeComponent<MenuItem, StaticText<TEXT_BMS>,          SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&icons::bms>>,
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMS>,          SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&icons::bms>>>();
 #endif
-        makeComponent<MenuItem, StaticText<TEXT_SETTINGS>,     SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::settings>>,
-        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
-        makeComponent<MenuItem, StaticText<TEXT_MOSFETS>,      SwitchScreenAction<MosfetsMenu>>,
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETS>,      SwitchScreenAction<MosfetsMenu>>>();
 #endif
-        makeComponent<MenuItem, StaticText<TEXT_DEMOS>,        SwitchScreenAction<DemosMenu>, StaticMenuItemIcon<&icons::demos>>,
-        makeComponent<MenuItem, StaticText<TEXT_POWEROFF>,     SwitchScreenAction<PoweroffDisplay>, StaticMenuItemIcon<&icons::poweroff>>,
-        makeComponent<MenuItem, StaticText<TEXT_REBOOT>,       RebootAction, StaticMenuItemIcon<&icons::reboot>>,
-        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
@ -1,33 +1,37 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
 #include "texts.h"

+// forward declares
 namespace {
 class DefaultModeSettingsMenu;
 class TempomatModeSettingsMenu;
 class LarsmModeSettingsMenu;
 class GametrakModeSettingsMenu;
 class SettingsMenu;
-}
+} // namespace

 namespace {
 class ModesSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_MODESSETTINGS>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_DEFAULTMODESETTIGNS>,   SwitchScreenAction<DefaultModeSettingsMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_TEMPOMATMODESETTINGS>,  SwitchScreenAction<TempomatModeSettingsMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_LARSMMODESETTINGS>,     SwitchScreenAction<LarsmModeSettingsMenu>>,
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
+{
+public:
+    ModesSettingsMenu()
+    {
+        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
-        makeComponent<MenuItem, StaticText<TEXT_GAMETRAKMODESETTINGS>,  SwitchScreenAction<GametrakModeSettingsMenu>>,
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GAMETRAKMODESETTINGS>,  SwitchScreenAction<GametrakModeSettingsMenu>>>();
 #endif
-        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/toggleboolaction.h"
@ -11,9 +11,10 @@
 #include "texts.h"
 #include "types.h"

+// forward declares
 namespace {
 class MainMenu;
-}
+} // namespace

 namespace {
 #ifdef FEATURE_MOSFETS
@ -32,13 +33,16 @@ using Mosfet2Accessor = GPIOAccessor<PINS_MOSFET2>;
 class MosfetsMenu :
    public MenuDisplay,
    public StaticText<TEXT_MOSFETS>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_MOSFET0>, ToggleBoolAction, CheckboxIcon, Mosfet0Accessor>,
-        makeComponent<MenuItem, StaticText<TEXT_MOSFET1>, ToggleBoolAction, CheckboxIcon, Mosfet1Accessor>,
-        makeComponent<MenuItem, StaticText<TEXT_MOSFET2>, ToggleBoolAction, CheckboxIcon, Mosfet2Accessor>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,    SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
+{
+public:
+    MosfetsMenu()
+    {
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET0>, ToggleBoolAction, CheckboxIcon, Mosfet0Accessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET1>, ToggleBoolAction, CheckboxIcon, Mosfet1Accessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET2>, ToggleBoolAction, CheckboxIcon, Mosfet2Accessor>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,    SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
+    }
+};
 #endif
-}
+} // namespace
--- a/src/displays/menus/motorfeedbackdebugmenu.h
+++ b/src/displays/menus/motorfeedbackdebugmenu.h
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
@ -11,31 +11,36 @@
 #include "debugtexthelpers.h"
 #include "debugcolorhelpers.h"

+// forward declares
 namespace {
 class DebugMenu;
-}
+} // namespace

 namespace {
 template<const char *Ttext, typename Ttexts, template<int> class ColorInterface>
 class MotorFeedbackDebugMenu :
    public MenuDisplay,
    public StaticText<Ttext>,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, typename Ttexts::AngleText,        ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::SpeedText,        ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::SpeedKmhText,     ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::ErrorText,        ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::CurrentText,      ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::CurrentFixedText, ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::ChopsText,        ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::HallText,         ColorInterface<TFT_DARKGREY>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,                             SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
+    public BackActionInterface<SwitchScreenAction<DebugMenu>>
+{
+public:
+    MotorFeedbackDebugMenu()
+    {
+        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>>>();
+    }
+};

 class FrontLeftMotorFeedbackDebugMenu : public MotorFeedbackDebugMenu<TEXT_FRONTLEFTFEEDBACK, FrontTexts::LeftFeedback, FrontFeedbackColor> {};
 class FrontRightMotorFeedbackDebugMenu : public MotorFeedbackDebugMenu<TEXT_FRONTRIGHTFEEDBACK, FrontTexts::RightFeedback, FrontFeedbackColor> {};
 class BackLeftMotorFeedbackDebugMenu : public MotorFeedbackDebugMenu<TEXT_BACKLEFTFEEDBACK, BackTexts::LeftFeedback, BackFeedbackColor> {};
 class BackRightMotorFeedbackDebugMenu : public MotorFeedbackDebugMenu<TEXT_BACKRIGHTFEEDBACK, BackTexts::RightFeedback, BackFeedbackColor> {};
-}
+
+} // namespace
--- a/src/displays/menus/motorstatedebugmenu.h
+++ b/src/displays/menus/motorstatedebugmenu.h
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
@ -10,32 +10,37 @@
 #include "texts.h"
 #include "debugtexthelpers.h"

+// forward declares
 namespace {
 class DebugMenu;
-}
+} // namespace

 namespace {
 template<const char *Ttext, typename Ttexts>
 class MotorStateDebugMenu :
    public MenuDisplay,
    public StaticText<Ttext>,
-    public BackActionInterface<SwitchScreenAction<DebugMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, typename Ttexts::EnableText,       DisabledColor, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::PwmText,          DisabledColor, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::CtrlTypText,      DisabledColor, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::CtrlModText,      DisabledColor, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::IMotMaxText,      DisabledColor, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::IDcMaxText,       DisabledColor, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::NMotMaxText,      DisabledColor, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::FieldWeakMaxText, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, typename Ttexts::PhaseAdvMaxText,  DisabledColor, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,    SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
+    public BackActionInterface<SwitchScreenAction<DebugMenu>>
+{
+public:
+    MotorStateDebugMenu()
+    {
+        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>>>();
+    }
+};

 class FrontLeftMotorStateDebugMenu : public MotorStateDebugMenu<TEXT_FRONTLEFTCOMMAND, FrontTexts::LeftCommand> {};
 class FrontRightMotorStateDebugMenu : public MotorStateDebugMenu<TEXT_FRONTRIGHTCOMMAND, FrontTexts::RightCommand> {};
 class BackLeftMotorStateDebugMenu : public MotorStateDebugMenu<TEXT_BACKLEFTCOMMAND, BackTexts::LeftCommand> {};
 class BackRightMotorStateDebugMenu : public MotorStateDebugMenu<TEXT_BACKRIGHTCOMMAND, BackTexts::RightCommand> {};
-}
+
+} // namespace
--- a/src/displays/menus/presetsmenu.h
+++ b/src/displays/menus/presetsmenu.h
@ -1,8 +1,8 @@
 #pragma once

+// local includes
 #include "actioninterface.h"
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/multiaction.h"
 #include "actions/switchscreenaction.h"
@ -12,9 +12,10 @@
 #include "presets.h"
 #include "globals.h"

+// forward declares
 namespace {
 class MainMenu;
-}
+} // namespace

 namespace {
 class ApplyPresetAction : public virtual ActionInterface
@ -75,20 +76,23 @@ public:
 class PresetsMenu :
    public MenuDisplay,
    public StaticText<TEXT_PRESETS>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_DEFAULTEVERYTHING>,            MultiAction<ApplySettingsPresetAction<&presets::defaultSettings>, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_DEFAULTLIMITS>,                MultiAction<ApplyLimitsPresetAction<&presets::defaultLimits>, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_KIDSLIMITS>,                   MultiAction<ApplyLimitsPresetAction<&presets::kidsLimits>, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_DEFAULTCONTROLLERHARDWARE>,    MultiAction<ApplyControllerHardwarePresetAction<&presets::defaultControllerHardware>, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_MOSFETSOFFCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::mosfetsOffControllerHardware>, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_SPINNERCONTROLLERHARDWARE>,    MultiAction<ApplyControllerHardwarePresetAction<&presets::spinnerControllerHardware>, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_DEFAULTBOARDCOMPUTERHARDWARE>, MultiAction<ApplyBoardcomputerHardwarePresetAction<&presets::defaultBoardcomputerHardware>, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_DEFAULTDEFAULTMODE>,           MultiAction<ApplyDefaultModePresetAction<&presets::defaultDefaultMode>, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_SINUSOIDALDEFAULTMODE>,        MultiAction<ApplyDefaultModePresetAction<&presets::sinusoidalDefaultMode>, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_DEFAULTTEMPOMATMODE>,          MultiAction<ApplyTempomatModePresetAction<&presets::defaultTempomatMode>, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_DEFAULTLARSMMODE>,             MultiAction<ApplyLarsmModePresetAction<&presets::defaultLarsmMode>, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,                         SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
+{
+public:
+    PresetsMenu()
+    {
+        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
@ -1,27 +1,31 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "actions/switchprofileaction.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
 #include "texts.h"

+// forward declares
 namespace {
 class MainMenu;
-}
+} // namespace

 namespace {
 class ProfilesMenu :
    public MenuDisplay,
    public StaticText<TEXT_PROFILES>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_PROFILE0>, SwitchProfileAction<0>>,
-        makeComponent<MenuItem, StaticText<TEXT_PROFILE1>, SwitchProfileAction<1>>,
-        makeComponent<MenuItem, StaticText<TEXT_PROFILE2>, SwitchProfileAction<2>>,
-        makeComponent<MenuItem, StaticText<TEXT_PROFILE3>, SwitchProfileAction<3>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,     SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
+{
+public:
+    ProfilesMenu()
+    {
+        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/multiaction.h"
 #include "actions/switchscreenaction.h"
@ -14,9 +14,10 @@
 #include "modes/larsmmode.h"
 #include "modes/gametrakmode.h"

+// forward declares
 namespace {
 class MainMenu;
-}
+} // namespace

 namespace {
 template<typename T1, T1 &target, typename T2, T2 value>
@ -35,20 +36,22 @@ using SetGametrakModeAction = SetterAction<ModeInterface*, currentMode, Gametrak
 class SelectModeMenu :
    public MenuDisplay,
    public StaticText<TEXT_SELECTMODE>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_DEFAULT>,   MultiAction<SetDefaultModeAction, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_TEMPOMAT>,  MultiAction<SetTempomatModeAction, SwitchScreenAction<MainMenu>>>,
-        makeComponent<MenuItem, StaticText<TEXT_LARSM>,     MultiAction<SetLarsmModeAction, SwitchScreenAction<MainMenu>>>,
-#ifdef FEATURE_GAMETRAK
-        makeComponent<MenuItem, StaticText<TEXT_GAMETRAK>,  MultiAction<SetGametrakModeAction, SwitchScreenAction<MainMenu>>>,
-#endif
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,      SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>
-    >
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
 {
    using Base = MenuDisplay;

 public:
+    SelectModeMenu()
+    {
+        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
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GAMETRAK>,  MultiAction<SetGametrakModeAction, SwitchScreenAction<MainMenu>>>>();
+#endif
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>,      SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
+    }
+
    void start() override;
 };

@ -68,4 +71,4 @@ void SelectModeMenu::start()
        setSelectedIndex(3);
    }
 }
-}
+} // namespace
--- a/src/displays/menus/settingsmenu.h
+++ b/src/displays/menus/settingsmenu.h
@ -1,9 +1,10 @@
 #pragma once

+// Arduino includes
 #include <HardwareSerial.h>

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/toggleboolaction.h"
 #include "actions/switchscreenaction.h"
@ -18,7 +19,9 @@
 #include "icons/back.h"
 #include "texts.h"
 #include "globals.h"
+#include "settingsaccessors.h"

+// forward declares
 namespace {
 class LimitsSettingsMenu;
 class WifiSettingsMenu;
@ -38,24 +41,27 @@ struct BackLedAccessor : public RefAccessor<bool> { bool &getRef() const overrid
 class SettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_SETTINGS>,
-    public BackActionInterface<SwitchScreenAction<MainMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_LIMITSSETTINGS>,                SwitchScreenAction<LimitsSettingsMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFISETTINGS>,                  SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::wifi>>,
+    public BackActionInterface<SwitchScreenAction<MainMenu>>
+{
+public:
+    SettingsMenu()
+    {
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LIMITSSETTINGS>,                SwitchScreenAction<LimitsSettingsMenu>>>();
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISETTINGS>,                  SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::wifi>>>();
 #ifdef FEATURE_BLUETOOTH
-        makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHSETTINGS>,             SwitchScreenAction<BluetoothSettingsMenu>, StaticMenuItemIcon<&icons::bluetooth>>,
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHSETTINGS>,             SwitchScreenAction<BluetoothSettingsMenu>, StaticMenuItemIcon<&icons::bluetooth>>>();
 #endif
-        makeComponent<MenuItem, StaticText<TEXT_MODESSETTINGS>,                 SwitchScreenAction<ModesSettingsMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_CONTROLLERHARDWARESETTINGS>,    SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::hardware>>,
-        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)
-        makeComponent<MenuItem, StaticText<TEXT_AUTOCONNECTBMS>,                ToggleBoolAction, CheckboxIcon, AutoConnectBmsAccessor>,
+        constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AUTOCONNECTBMS>,                ToggleBoolAction, CheckboxIcon, AutoConnectBmsAccessor>>();
 #endif
-        makeComponent<MenuItem, StaticText<TEXT_BUZZER>,                        SwitchScreenAction<BuzzerMenu>, StaticMenuItemIcon<&icons::buzzer>>,
-        makeComponent<MenuItem, StaticText<TEXT_FRONTLED>,                      ToggleBoolAction, CheckboxIcon, FrontLedAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_BACKLED>,                       ToggleBoolAction, CheckboxIcon, BackLedAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_ABOUT>,                         SwitchScreenAction<AboutMenu>, StaticMenuItemIcon<&icons::info>>,
-        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
@ -1,9 +1,10 @@
 #pragma once

+// Arduino includes
 #include <WiFi.h>

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "menuitem.h"
 #include "actions/dummyaction.h"
@ -18,38 +19,42 @@
 #include "wifiaccessors.h"
 #include "texts.h"

+// forward declares
 namespace {
 class WifiSettingsMenu;
-}
+} // namespace

 namespace {
 class StationWifiSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_STATIONWIFISETTINGS>,
-    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_WIFIRECONNECT>,           WifiReconnectAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFIDISCONNECT>,          WifiDisconnectAction>,
-        makeComponent<MenuItem, WifiIsConnectedText,                      StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEAUTOCONNECT>,   ToggleBoolAction, CheckboxIcon, WifiAutoConnectAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEAUTORECONNECT>, ToggleBoolAction, CheckboxIcon, WifiAutoReconnectAccessor>,
-        makeComponent<MenuItem, WifiLocalIpText,                          StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiMacAddressText,                       StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiSubnetMaskText,                       StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiGatewayIpText,                        StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiDnsIpText,                            StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiBroadcastIpText,                      StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiNetworkIdText,                        StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiSubnetCIDRText,                       StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFIENABLEIPV6>,          WifiEnableIpV6Action>,
-        makeComponent<MenuItem, WifiLocalIpV6Text,                        StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiHostnameText,                         StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiStatusText,                           StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiSsidText,                             StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiPskText,                              StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiBssidText,                            StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, WifiRssiText,                             StaticFont<2>, DisabledColor, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,                    SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
+{
+public:
+    StationWifiSettingsMenu()
+    {
+        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
@ -1,7 +1,7 @@
 #pragma once

+// local includes
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "changevaluedisplay.h"
 #include "menuitem.h"
@ -10,10 +10,11 @@
 #include "texts.h"
 #include "settingsaccessors.h"

+// forward declares
 namespace {
 class TempomatModeSettingsMenu;
 class ModesSettingsMenu;
-}
+} // namespace

 namespace {
 using TempomatModeModelModeChangeScreen = makeComponent<
@ -27,10 +28,13 @@ using TempomatModeModelModeChangeScreen = makeComponent<
 class TempomatModeSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_TEMPOMATMODESETTINGS>,
-    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<TempomatModeModelModeChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,         SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
+{
+public:
+    TempomatModeSettingsMenu()
+    {
+        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
@ -1,17 +1,18 @@
 #pragma once

+// local includes
 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/switchscreenaction.h"
 #include "icons/back.h"
 #include "texts.h"
 #include "settingsaccessors.h"

+// forward declares
 namespace {
 class BoardcomputerHardwareSettingsMenu;
-}
+} // namespace

 namespace {
 class TimersMenu;
@ -59,14 +60,17 @@ using DisplayRedrawRateChangeDisplay = makeComponent<
 class TimersMenu :
    public MenuDisplay,
    public StaticText<TEXT_TIMERS>,
-    public BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_POTIREADRATE>,      SwitchScreenAction<PotiReadRateChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_MODEUPDATERATE>,    SwitchScreenAction<ModeUpdateRateChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_STATSUPDATERATE>,   SwitchScreenAction<StatsUpdateRateChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_DISPLAYUPDATERATE>, SwitchScreenAction<DisplayUpdateRateChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_DISPLAYREDRAWRATE>, SwitchScreenAction<DisplayRedrawRateChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,              SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>
+{
+public:
+    TimersMenu()
+    {
+        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
@ -1,10 +1,10 @@
 #pragma once

-#include <vector>
-
+// Arduino includes
 #include <Arduino.h>
 #include <WiFi.h>

+// local includes
 #include "menudisplay.h"
 #include "utils.h"
 #include "actions/multiaction.h"
@ -14,9 +14,10 @@
 #include "texts.h"
 #include "types.h"

+// forward declares
 namespace {
 class WifiSettingsMenu;
-}
+} // namespace

 namespace {
 class WifiScanMenu : public MenuDisplay, public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
@ -24,55 +25,28 @@ class WifiScanMenu : public MenuDisplay, public BackActionInterface<SwitchScreen
    using Base = MenuDisplay;

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

    void start() override;
    void update() override;
    void stop() override;

-    std::size_t size() const override { return 1 + vec.size(); }
-
-    MenuItem& getMenuItem(std::size_t index) override
-    {
-        if (index == vec.size())
-            return m_backItem;
-
-        return vec[index];
-    }
-
-    const MenuItem& getMenuItem(std::size_t index) const override
-    {
-        if (index == vec.size())
-            return m_backItem;
-
-        return vec[index];
-    }
-
-    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
-    {
-        for (auto &item : vec)
-            callback(item);
-        callback(m_backItem);
-    }
-
-    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
-    {
-        for (auto &item : vec)
-            callback(item);
-        callback(m_backItem);
-    }
-
 private:
-    makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>> m_backItem;
-
-    std::vector<makeComponent<MenuItem, ChangeableText, DummyAction>> vec;
-
    millis_t m_lastScanComplete;
+
+    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{vec.size()} + " found";
+    auto text = String{menuItemCount()-1} + " found";
    switch (WiFi.scanComplete())
    {
    case WIFI_SCAN_RUNNING: text += " (scanning)"; break;
@ -95,26 +69,40 @@ void WifiScanMenu::update()
    const auto n = WiFi.scanComplete();
    if (n >= 0)
    {
-        if (n != vec.size())
-        {
-            while (n > vec.size())
-            {
-                vec.emplace_back();
-                vec.back().start();
-            }
-
-            while (n < vec.size())
-            {
-                vec.back().stop();
-                vec.pop_back();
-            }
-        }
-
        const auto now = millis();
        if (!m_lastScanComplete)
        {
-            for (auto iter = std::begin(vec); iter != std::end(vec); iter++)
-                iter->setTitle(WiFi.SSID(std::distance(std::begin(vec), iter)));
+            auto backButton = takeLastMenuItem();
+
+            for (std::size_t i = 0; i < n; i++)
+            {
+                const auto ssid = WiFi.SSID(i);
+                if (menuItemCount() <= i)
+                {
+                    if (m_reusableItems.empty())
+                    {
+                        auto &item = constructMenuItem<makeComponent<MenuItem, ChangeableText, DummyAction>>();
+                        item.setTitle(ssid);
+                    }
+                    else
+                    {
+                        std::unique_ptr<makeComponent<MenuItem, ChangeableText, DummyAction>> ptr = std::move(m_reusableItems.back());
+                        m_reusableItems.pop_back();
+                        ptr->setTitle(ssid);
+                        emplaceMenuItem(std::move(ptr));
+                    }
+                }
+                else
+                {
+                    auto &item = *(makeComponent<MenuItem, ChangeableText, DummyAction>*)(&getMenuItem(i));
+                    item.setTitle(ssid);
+                }
+            }
+
+            while (menuItemCount() > n)
+                m_reusableItems.emplace_back((makeComponent<MenuItem, ChangeableText, DummyAction>*)takeLastMenuItem().release());
+
+            emplaceMenuItem(std::move(backButton));

            m_lastScanComplete = now;
        }
@ -132,4 +120,4 @@ void WifiScanMenu::stop()
 {
    WiFi.scanDelete();
 }
-}
+} // namespace
--- a/src/displays/menus/wifisettingsmenu.h
+++ b/src/displays/menus/wifisettingsmenu.h
@ -1,8 +1,8 @@
 #pragma once

+// local includes
 #include "changevaluedisplay.h"
 #include "menudisplay.h"
-#include "staticmenudefinition.h"
 #include "utils.h"
 #include "actions/switchscreenaction.h"
 #include "actions/toggleboolaction.h"
@ -12,13 +12,14 @@
 #include "texts.h"
 #include "settingsaccessors.h"

+// forward declares
 namespace {
 class GenericWifiSettingsMenu;
 class StationWifiSettingsMenu;
 class WifiScanMenu;
 class AccessPointWifiSettingsMenu;
 class SettingsMenu;
-}
+} // namespace

 namespace {
 class WifiSettingsMenu;
@ -34,15 +35,18 @@ using AutoWifiModeChangeDisplay = makeComponent<
 class WifiSettingsMenu :
    public MenuDisplay,
    public StaticText<TEXT_WIFISETTINGS>,
-    public BackActionInterface<SwitchScreenAction<SettingsMenu>>,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_AUTOWIFIMODE>,            SwitchScreenAction<AutoWifiModeChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_AUTOENABLEAP>,            ToggleBoolAction, CheckboxIcon, AutoEnableApAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_GENERICWIFISETTINGS>,     SwitchScreenAction<GenericWifiSettingsMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_STATIONWIFISETTINGS>,     SwitchScreenAction<StationWifiSettingsMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFISCAN>,                SwitchScreenAction<WifiScanMenu>, StaticMenuItemIcon<&icons::scan>>,
-        makeComponent<MenuItem, StaticText<TEXT_ACCESSPOINTWIFISETTINGS>, SwitchScreenAction<AccessPointWifiSettingsMenu>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,                    SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>
-    >
-{};
-}
+    public BackActionInterface<SwitchScreenAction<SettingsMenu>>
+{
+public:
+    WifiSettingsMenu()
+    {
+        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/globals.h
+++ b/src/globals.h
@ -1,7 +1,10 @@
 #pragma once

+// system includes
 #include <array>
+#include <memory>

+// Arduino includes
 #ifdef FEATURE_BLUETOOTH
 #include <BluetoothSerial.h>
 #endif
@ -9,6 +12,7 @@
 #include <TFT_eSPI.h>
 #include <SPI.h>

+// local includes
 #include "controller.h"
 #include "display.h"
 #include "modeinterface.h"
@ -67,7 +71,7 @@ TFT_eSPI tft = TFT_eSPI();

 ModeInterface *currentMode{};

-Display *currentDisplay{};
+std::unique_ptr<Display> currentDisplay;

 int rotated{};
 bool requestFullRedraw{};
--- 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
@ -12,7 +12,55 @@
 #include "globals.h"
 #include "modes/defaultmode.h"
 #include "modes/tempomatmode.h"
+#include "displays/menus/aboutmenu.h"
+#include "displays/menus/accesspointwifisettingsmenu.h"
+#ifdef FEATURE_BLUETOOTH
+#include "displays/menus/bluetoothsettingsmenu.h"
+#endif
+#include "displays/menus/bmsmenu.h"
+#include "displays/menus/buzzermenu.h"
+#include "displays/menus/commanddebugmenu.h"
+#include "displays/menus/debugmenu.h"
+#include "displays/menus/defaultmodesettingsmenu.h"
+#include "displays/menus/demosmenu.h"
+#include "displays/menus/dynamicdebugmenu.h"
+#include "displays/menus/enablemenu.h"
+#include "displays/menus/feedbackdebugmenu.h"
+#include "displays/menus/gametrakmodesettingsmenu.h"
+#include "displays/menus/genericwifisettingsmenu.h"
+#include "displays/menus/graphsmenu.h"
+#include "displays/menus/controllerhardwaresettingsmenu.h"
+#include "displays/menus/invertmenu.h"
+#include "displays/menus/larsmmodesettingsmenu.h"
+#include "displays/menus/limitssettingsmenu.h"
+#include "displays/menus/mainmenu.h"
+#include "displays/menus/tempomatmodesettingsmenu.h"
+#include "displays/menus/modessettingsmenu.h"
+#include "displays/menus/mosfetsmenu.h"
+#include "displays/menus/motorfeedbackdebugmenu.h"
+#include "displays/menus/motorstatedebugmenu.h"
+#include "displays/menus/profilesmenu.h"
+#include "displays/menus/presetsmenu.h"
+#include "displays/menus/boardcomputerhardwaresettingsmenu.h"
+#include "displays/menus/selectmodemenu.h"
+#include "displays/menus/settingsmenu.h"
+#include "displays/menus/stationwifisettingsmenu.h"
+#include "displays/menus/timersmenu.h"
+#include "displays/menus/wifiscanmenu.h"
+#include "displays/menus/wifisettingsmenu.h"
+#include "displays/bmsdisplay.h"
+#include "displays/calibratedisplay.h"
 #include "displays/dpad5wiredebugdisplay.h"
+#include "displays/gameoflifedisplay.h"
+#include "displays/gametrakcalibratedisplay.h"
+#include "displays/lockscreen.h"
+#include "displays/metersdisplay.h"
+#include "displays/pingpongdisplay.h"
+#include "displays/poweroffdisplay.h"
+#include "displays/spirodisplay.h"
+#include "displays/starfielddisplay.h"
+#include "displays/statusdisplay.h"
+#include "displays/updatedisplay.h"
 #include "screens.h"
 #include "dpad.h"
 #include "dpad3wire.h"
@ -40,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");
@ -92,9 +152,11 @@ void setup()
            loadSettings();
        }
    }
+    printMemoryStats("loadSettings()");

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

    bootLabel.redraw("deviceName");
    {
@ -102,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
    }
@ -142,6 +212,7 @@ void setup()
    {
        bootLabel.redraw("bluetooth begin");
        BluetoothBeginAction{}.triggered();
+        printMemoryStats("BluetoothBeginAction()");
    }
 #endif

@ -161,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>();
@ -181,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
@ -258,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
@ -2,56 +2,6 @@

 #include <optional>

-#include "displays/menus/aboutmenu.h"
-#include "displays/menus/accesspointwifisettingsmenu.h"
-#ifdef FEATURE_BLUETOOTH
-#include "displays/menus/bluetoothsettingsmenu.h"
-#endif
-#include "displays/menus/bmsmenu.h"
-#include "displays/menus/buzzermenu.h"
-#include "displays/menus/commanddebugmenu.h"
-#include "displays/menus/debugmenu.h"
-#include "displays/menus/defaultmodesettingsmenu.h"
-#include "displays/menus/demosmenu.h"
-#include "displays/menus/dynamicdebugmenu.h"
-#include "displays/menus/enablemenu.h"
-#include "displays/menus/feedbackdebugmenu.h"
-#include "displays/menus/gametrakmodesettingsmenu.h"
-#include "displays/menus/genericwifisettingsmenu.h"
-#include "displays/menus/graphsmenu.h"
-#include "displays/menus/controllerhardwaresettingsmenu.h"
-#include "displays/menus/invertmenu.h"
-#include "displays/menus/larsmmodesettingsmenu.h"
-#include "displays/menus/limitssettingsmenu.h"
-#include "displays/menus/mainmenu.h"
-#include "displays/menus/tempomatmodesettingsmenu.h"
-#include "displays/menus/modessettingsmenu.h"
-#include "displays/menus/mosfetsmenu.h"
-#include "displays/menus/motorfeedbackdebugmenu.h"
-#include "displays/menus/motorstatedebugmenu.h"
-#include "displays/menus/profilesmenu.h"
-#include "displays/menus/presetsmenu.h"
-#include "displays/menus/boardcomputerhardwaresettingsmenu.h"
-#include "displays/menus/selectmodemenu.h"
-#include "displays/menus/settingsmenu.h"
-#include "displays/menus/stationwifisettingsmenu.h"
-#include "displays/menus/timersmenu.h"
-#include "displays/menus/wifiscanmenu.h"
-#include "displays/menus/wifisettingsmenu.h"
-#include "displays/bmsdisplay.h"
-#include "displays/calibratedisplay.h"
-#include "displays/dpad5wiredebugdisplay.h"
-#include "displays/gameoflifedisplay.h"
-#include "displays/gametrakcalibratedisplay.h"
-#include "displays/lockscreen.h"
-#include "displays/metersdisplay.h"
-#include "displays/pingpongdisplay.h"
-#include "displays/poweroffdisplay.h"
-#include "displays/spirodisplay.h"
-#include "displays/starfielddisplay.h"
-#include "displays/statusdisplay.h"
-#include "displays/updatedisplay.h"
-
 #include "globals.h"
 #include "utils.h"
 #include "widgets/label.h"
@ -60,340 +10,12 @@
 namespace {
 Label bootLabel{32, 250};

-union X {
-    X() {}
-    ~X() { ((Display&)statusDisplay).~Display(); }
-
-    AboutMenu aboutMenu;
-    AccessPointWifiSettingsMenu accessPointWifiSettingsMenu;
-#ifdef FEATURE_BLUETOOTH
-    BluetoothSettingsMenu bluetoothSettingsMenu;
-#ifdef FEATURE_BMS
-    BmsMenu bmsMenu;
-#endif
-#endif
-    BuzzerMenu buzzerMenu;
-    FrontCommandDebugMenu frontCommandDebugMenu;
-    BackCommandDebugMenu backCommandDebugMenu;
-    ControllerHardwareSettingsMenu controllerHardwareSettingsMenu;
-    DebugMenu debugMenu;
-    DefaultModeSettingsMenu defaultModeSettingsMenu;
-    DemosMenu demosMenu;
-    DynamicDebugMenu dynamicDebugMenu;
-    EnableMenu enableMenu;
-    FrontFeedbackDebugMenu frontFeedbackDebugMenu;
-    BackFeedbackDebugMenu backFeedbackDebugMenu;
-#ifdef FEATURE_GAMETRAK
-    GametrakModeSettingsMenu gametrakModeSettingsMenu;
-#endif
-    GenericWifiSettingsMenu genericWifiSettingsMenu;
-    GraphsMenu graphsMenu;
-    InvertMenu invertMenu;
-    LarsmModeSettingsMenu larsmModeSettingsMenu;
-    LimitsSettingsMenu limitsSettingsMenu;
-    MainMenu mainMenu;
-    TempomatModeSettingsMenu tempomatModeSettingsMenu;
-    ModesSettingsMenu modesSettingsMenu;
-#ifdef FEATURE_MOSFETS
-    MosfetsMenu mosfetsMenu;
-#endif
-    FrontLeftMotorStateDebugMenu frontLeftMotorStateDebugMenu;
-    FrontRightMotorStateDebugMenu frontRightMotorStateDebugMenu;
-    BackLeftMotorStateDebugMenu backLeftMotorStateDebugMenu;
-    BackRightMotorStateDebugMenu backRightMotorStateDebugMenu;
-    FrontLeftMotorFeedbackDebugMenu frontLeftMotorFeedbackDebugMenu;
-    FrontRightMotorFeedbackDebugMenu frontRightMotorFeedbackDebugMenu;
-    BackLeftMotorFeedbackDebugMenu backLeftMotorFeedbackDebugMenu;
-    BackRightMotorFeedbackDebugMenu backRightMotorFeedbackDebugMenu;
-    BoardcomputerHardwareSettingsMenu boardcomputerHardwareSettingsMenu;
-    ProfilesMenu profilesMenu;
-    PresetsMenu presetsMenu;
-    SelectModeMenu selectModeMenu;
-    SettingsMenu settingsMenu;
-    StationWifiSettingsMenu stationWifiSettingsMenu;
-    TimersMenu timersMenu;
-    WifiScanMenu wifiScanMenu;
-    WifiSettingsMenu wifiSettingsMenu;
-
-#ifdef FEATURE_BMS
-    BmsDisplay bmsDisplay;
-#endif
-    CalibrateDisplay calibrateDisplay;
-#if defined(FEATURE_DPAD_5WIRESW) && defined(DPAD_5WIRESW_DEBUG)
-    DPad5WireDebugDisplay dPad5WireDebugDisplay;
-#endif
-    GameOfLifeDisplay gameOfLifeDisplay;
-#ifdef FEATURE_GAMETRAK
-    GametrakCalibrateDisplay gametrakCalibrateDisplay;
-#endif
-    Lockscreen lockScreen;
-    MetersDisplay metersDisplay;
-    PingPongDisplay pingPongDisplay;
-    PoweroffDisplay poweroffDisplay;
-    SpiroDisplay spiroDisplay;
-    StarfieldDisplay starFieldDisplay;
-    StatusDisplay statusDisplay;
-#ifdef FEATURE_OTA
-    UpdateDisplay updateDisplay;
-#endif
-
-    AutoWifiModeChangeDisplay autoWifiModeChangeDisplay;
-
-#ifdef FEATURE_BLUETOOTH
-    AutoBluetoothModeChangeDisplay autoBluetoothModeChangeDisplay;
-#endif
-
-    FrontFreqChangeScreen changeFrontFreq;
-    FrontPatternChangeScreen changeFrontPattern;
-    BackFreqChangeScreen changeBackFreq;
-    BackPatternChangeScreen changeBackPattern;
-    ReverseBeepFreq0ChangeScreen changeReverseBeepFreq0;
-    ReverseBeepFreq1ChangeScreen changeReverseBeepFreq1;
-    ReverseBeepDuration0ChangeScreen changeReverseBeepDuration0;
-    ReverseBeepDuration1ChangeScreen changeReverseBeepDuration1;
-
-    IMotMaxChangeScreen changeIMotMax;
-    IDcMaxChangeScreen changeIDcMax;
-    NMotMaxKmhChangeScreen changeNMotMaxKmh;
-    NMotMaxRpmChangeScreen changeNMotMaxRpm;
-    FieldWeakMaxChangeScreen changeFieldWeakMax;
-    PhaseAdvMaxChangeScreen changePhaseAdvMax;
-
-    WheelDiameterMmChangeScreen wheelDiameterMmChangeScreen;
-    WheelDiameterInchChangeScreen wheelDiameterInchChangeScreen;
-    NumMagnetPolesChangeScreen numMagnetPolesChangeScreen;
-
-    DefaultModeModelModeChangeDisplay changeDefaultModeModelMode;
-    DefaultModeSmoothingChangeDisplay changeDefaultModeSmoothing;
-    DefaultModeFrontPercentageChangeDisplay changeDefaultModeFrontPercentage;
-    DefaultModeBackPercentageChangeDisplay changeDefaultModeBackPercentage;
-    DefaultModeAddSchwelleChangeDisplay changeDefaultModeAddSchwelle;
-    DefaultModeGas1WertChangeDisplay changeDefaultModeGas1Wert;
-    DefaultModeGas2WertChangeDisplay changeDefaultModeGas2Wert;
-    DefaultModeBrems1WertChangeDisplay changeDefaultModeBrems1Wert;
-    DefaultModeBrems2WertChangeDisplay changeDefaultModeBrems2Wert;
-
-    TempomatModeModelModeChangeScreen changeManualModeModelMode;
-
-    LarsmModeModelModeChangeDisplay larsmModeModelModeChangeDisplay;
-    LarsmModeModeChangeDisplay larsmModeModeChangeDisplay;
-    LarsmModeIterationsChangeDisplay larsmModeIterationsChangeDisplay;
-
-    SampleCountChangeScreen sampleCountChangeScreen;
-    GasMinChangeScreen changeGasMin;
-    GasMaxChangeScreen changeGasMax;
-    BremsMinChangeScreen changeBremsMin;
-    BremsMaxChangeScreen changeBremsMax;
-#if defined(FEATURE_DPAD) || defined(FEATURE_DPAD_3WIRESW) || defined(FEATURE_DPAD_5WIRESW)
-    DPadDebounceChangeScreen dPadDebounceChangeScreen;
-#endif
-#ifdef FEATURE_GAMETRAK
-    GametrakXMinChangeScreen changeGametrakXMin;
-    GametrakXMaxChangeScreen changeGametrakXMax;
-    GametrakYMinChangeScreen changeGametrakYMin;
-    GametrakYMaxChangeScreen changeGametrakYMax;
-    GametrakDistMinChangeScreen changeGametrakDistMin;
-    GametrakDistMaxChangeScreen changeGametrakDistMax;
-#endif
-
-    PotiReadRateChangeDisplay potiReadRateChangeDisplay;
-    ModeUpdateRateChangeDisplay modeUpdateRateChangeDisplay;
-    StatsUpdateRateChangeDisplay statsUpdateRateChangeDisplay;
-    DisplayUpdateRateChangeDisplay displayUpdateRateChangeDisplay;
-    DisplayRedrawRateChangeDisplay displayRedrawRateChangeDisplay;
-
-    WifiModeChangeScreen wifiModeChangeScreen;
-    WifiTxPowerChangeScreen wifiTxPowerChangeScreen;
-
-    GasGraphDisplay gasGraphDisplay;
-    BremsGraphDisplay bremsGraphDisplay;
-    PotisGraphDisplay potisGraphDisplay;
-    PotisSplitGraphDisplay potisSplitGraphDisplay;
-    AvgSpeedGraphDisplay avgSpeedGraphDisplay;
-    AvgSpeedKmhGraphDisplay avgSpeedKmhGraphDisplay;
-    SumCurrentGraphDisplay sumCurrentGraphDisplay;
-    FrontVoltageGraphDisplay frontVoltageGraphDisplay;
-    BackVoltageGraphDisplay backVoltageGraphDisplay;
-    VoltagesGraphDisplay voltagesGraphDisplay;
-    VoltagesSplitGraphDisplay voltagesSplitGraphDisplay;
-#ifdef FEATURE_BMS
-    BmsVoltageGraphDisplay bmsVoltageGraphDisplay;
-    BmsCurrentGraphDisplay bmsCurrentGraphDisplay;
-    BmsPowerGraphDisplay bmsPowerGraphDisplay;
-    SumCurrentsComparisonGraphDisplay sumCurrentsComparisonGraphDisplay;
-#endif
-    MotorCurrentsGraphDisplay motorCurrentsGraphDisplay;
-} displays;
-
-template<typename T> T &getRefByType() = delete;
-template<> decltype(displays.aboutMenu)                                        &getRefByType<decltype(displays.aboutMenu)>()                                        { return displays.aboutMenu; }
-template<> decltype(displays.accessPointWifiSettingsMenu)                      &getRefByType<decltype(displays.accessPointWifiSettingsMenu)>()                      { return displays.accessPointWifiSettingsMenu; }
-#ifdef FEATURE_BLUETOOTH
-template<> decltype(displays.bluetoothSettingsMenu)                            &getRefByType<decltype(displays.bluetoothSettingsMenu)>()                            { return displays.bluetoothSettingsMenu; }
-#ifdef FEATURE_BMS
-template<> decltype(displays.bmsMenu)                                          &getRefByType<decltype(displays.bmsMenu)>()                                          { return displays.bmsMenu; }
-#endif
-#endif
-template<> decltype(displays.buzzerMenu)                                       &getRefByType<decltype(displays.buzzerMenu)>()                                       { return displays.buzzerMenu; }
-template<> decltype(displays.boardcomputerHardwareSettingsMenu)                &getRefByType<decltype(displays.boardcomputerHardwareSettingsMenu)>()                { return displays.boardcomputerHardwareSettingsMenu; }
-template<> decltype(displays.controllerHardwareSettingsMenu)                   &getRefByType<decltype(displays.controllerHardwareSettingsMenu)>()                   { return displays.controllerHardwareSettingsMenu; }
-template<> decltype(displays.frontCommandDebugMenu)                            &getRefByType<decltype(displays.frontCommandDebugMenu)>()                            { return displays.frontCommandDebugMenu; }
-template<> decltype(displays.backCommandDebugMenu)                             &getRefByType<decltype(displays.backCommandDebugMenu)>()                             { return displays.backCommandDebugMenu; }
-template<> decltype(displays.debugMenu)                                        &getRefByType<decltype(displays.debugMenu)>()                                        { return displays.debugMenu; }
-template<> decltype(displays.defaultModeSettingsMenu)                          &getRefByType<decltype(displays.defaultModeSettingsMenu)>()                          { return displays.defaultModeSettingsMenu; }
-template<> decltype(displays.demosMenu)                                        &getRefByType<decltype(displays.demosMenu)>()                                        { return displays.demosMenu; }
-template<> decltype(displays.dynamicDebugMenu)                                 &getRefByType<decltype(displays.dynamicDebugMenu)>()                                 { return displays.dynamicDebugMenu; }
-template<> decltype(displays.enableMenu)                                       &getRefByType<decltype(displays.enableMenu)>()                                       { return displays.enableMenu; }
-template<> decltype(displays.frontFeedbackDebugMenu)                           &getRefByType<decltype(displays.frontFeedbackDebugMenu)>()                           { return displays.frontFeedbackDebugMenu; }
-template<> decltype(displays.backFeedbackDebugMenu)                            &getRefByType<decltype(displays.backFeedbackDebugMenu)>()                            { return displays.backFeedbackDebugMenu; }
-#ifdef FEATURE_GAMETRAK
-template<> decltype(displays.gametrakModeSettingsMenu)                         &getRefByType<decltype(displays.gametrakModeSettingsMenu)>()                         { return displays.gametrakModeSettingsMenu; }
-#endif
-template<> decltype(displays.genericWifiSettingsMenu)                          &getRefByType<decltype(displays.genericWifiSettingsMenu)>()                          { return displays.genericWifiSettingsMenu; }
-template<> decltype(displays.graphsMenu)                                       &getRefByType<decltype(displays.graphsMenu)>()                                       { return displays.graphsMenu; }
-template<> decltype(displays.invertMenu)                                       &getRefByType<decltype(displays.invertMenu)>()                                       { return displays.invertMenu; }
-template<> decltype(displays.larsmModeSettingsMenu)                            &getRefByType<decltype(displays.larsmModeSettingsMenu)>()                            { return displays.larsmModeSettingsMenu; }
-template<> decltype(displays.limitsSettingsMenu)                               &getRefByType<decltype(displays.limitsSettingsMenu)>()                               { return displays.limitsSettingsMenu; }
-template<> decltype(displays.mainMenu)                                         &getRefByType<decltype(displays.mainMenu)>()                                         { return displays.mainMenu; }
-template<> decltype(displays.tempomatModeSettingsMenu)                         &getRefByType<decltype(displays.tempomatModeSettingsMenu)>()                         { return displays.tempomatModeSettingsMenu; }
-template<> decltype(displays.modesSettingsMenu)                                &getRefByType<decltype(displays.modesSettingsMenu)>()                                { return displays.modesSettingsMenu; }
-#ifdef FEATURE_MOSFETS
-template<> decltype(displays.mosfetsMenu)                                      &getRefByType<decltype(displays.mosfetsMenu)>()                                      { return displays.mosfetsMenu; }
-#endif
-template<> decltype(displays.frontLeftMotorStateDebugMenu)                     &getRefByType<decltype(displays.frontLeftMotorStateDebugMenu)>()                     { return displays.frontLeftMotorStateDebugMenu; }
-template<> decltype(displays.frontRightMotorStateDebugMenu)                    &getRefByType<decltype(displays.frontRightMotorStateDebugMenu)>()                    { return displays.frontRightMotorStateDebugMenu; }
-template<> decltype(displays.backLeftMotorStateDebugMenu)                      &getRefByType<decltype(displays.backLeftMotorStateDebugMenu)>()                      { return displays.backLeftMotorStateDebugMenu; }
-template<> decltype(displays.backRightMotorStateDebugMenu)                     &getRefByType<decltype(displays.backRightMotorStateDebugMenu)>()                     { return displays.backRightMotorStateDebugMenu; }
-template<> decltype(displays.frontLeftMotorFeedbackDebugMenu)                  &getRefByType<decltype(displays.frontLeftMotorFeedbackDebugMenu)>()                  { return displays.frontLeftMotorFeedbackDebugMenu; }
-template<> decltype(displays.frontRightMotorFeedbackDebugMenu)                 &getRefByType<decltype(displays.frontRightMotorFeedbackDebugMenu)>()                 { return displays.frontRightMotorFeedbackDebugMenu; }
-template<> decltype(displays.backLeftMotorFeedbackDebugMenu)                   &getRefByType<decltype(displays.backLeftMotorFeedbackDebugMenu)>()                   { return displays.backLeftMotorFeedbackDebugMenu; }
-template<> decltype(displays.backRightMotorFeedbackDebugMenu)                  &getRefByType<decltype(displays.backRightMotorFeedbackDebugMenu)>()                  { return displays.backRightMotorFeedbackDebugMenu; }
-template<> decltype(displays.profilesMenu)                                     &getRefByType<decltype(displays.profilesMenu)>()                                     { return displays.profilesMenu; }
-template<> decltype(displays.presetsMenu)                                      &getRefByType<decltype(displays.presetsMenu)>()                                      { return displays.presetsMenu; }
-template<> decltype(displays.selectModeMenu)                                   &getRefByType<decltype(displays.selectModeMenu)>()                                   { return displays.selectModeMenu; }
-template<> decltype(displays.settingsMenu)                                     &getRefByType<decltype(displays.settingsMenu)>()                                     { return displays.settingsMenu; }
-template<> decltype(displays.stationWifiSettingsMenu)                          &getRefByType<decltype(displays.stationWifiSettingsMenu)>()                          { return displays.stationWifiSettingsMenu; }
-
-template<> decltype(displays.timersMenu)                                       &getRefByType<decltype(displays.timersMenu)>()                                       { return displays.timersMenu; }
-template<> decltype(displays.wifiScanMenu)                                     &getRefByType<decltype(displays.wifiScanMenu)>()                                     { return displays.wifiScanMenu; }
-template<> decltype(displays.wifiSettingsMenu)                                 &getRefByType<decltype(displays.wifiSettingsMenu)>()                                 { return displays.wifiSettingsMenu; }
-
-#ifdef FEATURE_BMS
-template<> decltype(displays.bmsDisplay)                                       &getRefByType<decltype(displays.bmsDisplay)>()                                       { return displays.bmsDisplay; }
-#endif
-template<> decltype(displays.calibrateDisplay)                                 &getRefByType<decltype(displays.calibrateDisplay)>()                                 { return displays.calibrateDisplay; }
-#if defined(FEATURE_DPAD_5WIRESW) && defined(DPAD_5WIRESW_DEBUG)
-template<> decltype(displays.dPad5WireDebugDisplay)                            &getRefByType<decltype(displays.dPad5WireDebugDisplay)>()                            { return displays.dPad5WireDebugDisplay; }
-#endif
-template<> decltype(displays.gameOfLifeDisplay)                                &getRefByType<decltype(displays.gameOfLifeDisplay)>()                                { return displays.gameOfLifeDisplay; }
-#ifdef FEATURE_GAMETRAK
-template<> decltype(displays.gametrakCalibrateDisplay)                         &getRefByType<decltype(displays.gametrakCalibrateDisplay)>()                         { return displays.gametrakCalibrateDisplay; }
-#endif
-template<> decltype(displays.lockScreen)                                       &getRefByType<decltype(displays.lockScreen)>()                                       { return displays.lockScreen; }
-template<> decltype(displays.metersDisplay)                                    &getRefByType<decltype(displays.metersDisplay)>()                                    { return displays.metersDisplay; }
-template<> decltype(displays.pingPongDisplay)                                  &getRefByType<decltype(displays.pingPongDisplay)>()                                  { return displays.pingPongDisplay; }
-template<> decltype(displays.poweroffDisplay)                                  &getRefByType<decltype(displays.poweroffDisplay)>()                                  { return displays.poweroffDisplay; }
-template<> decltype(displays.spiroDisplay)                                     &getRefByType<decltype(displays.spiroDisplay)>()                                     { return displays.spiroDisplay; }
-template<> decltype(displays.starFieldDisplay)                                 &getRefByType<decltype(displays.starFieldDisplay)>()                                 { return displays.starFieldDisplay; }
-template<> decltype(displays.statusDisplay)                                    &getRefByType<decltype(displays.statusDisplay)>()                                    { return displays.statusDisplay; }
-#ifdef FEATURE_OTA
-template<> decltype(displays.updateDisplay)                                    &getRefByType<decltype(displays.updateDisplay)>()                                    { return displays.updateDisplay; }
-#endif
-
-template<> decltype(displays.autoWifiModeChangeDisplay)                        &getRefByType<decltype(displays.autoWifiModeChangeDisplay)>()                        { return displays.autoWifiModeChangeDisplay; }
-
-#ifdef FEATURE_BLUETOOTH
-template<> decltype(displays.autoBluetoothModeChangeDisplay)                   &getRefByType<decltype(displays.autoBluetoothModeChangeDisplay)>()                   { return displays.autoBluetoothModeChangeDisplay; }
-#endif
-
-template<> decltype(displays.changeFrontFreq)                                  &getRefByType<decltype(displays.changeFrontFreq)>()                                  { return displays.changeFrontFreq; }
-template<> decltype(displays.changeFrontPattern)                               &getRefByType<decltype(displays.changeFrontPattern)>()                               { return displays.changeFrontPattern; }
-template<> decltype(displays.changeBackFreq)                                   &getRefByType<decltype(displays.changeBackFreq)>()                                   { return displays.changeBackFreq; }
-template<> decltype(displays.changeBackPattern)                                &getRefByType<decltype(displays.changeBackPattern)>()                                { return displays.changeBackPattern; }
-template<> decltype(displays.changeReverseBeepFreq0)                           &getRefByType<decltype(displays.changeReverseBeepFreq0)>()                           { return displays.changeReverseBeepFreq0; }
-template<> decltype(displays.changeReverseBeepFreq1)                           &getRefByType<decltype(displays.changeReverseBeepFreq1)>()                           { return displays.changeReverseBeepFreq1; }
-template<> decltype(displays.changeReverseBeepDuration0)                       &getRefByType<decltype(displays.changeReverseBeepDuration0)>()                       { return displays.changeReverseBeepDuration0; }
-template<> decltype(displays.changeReverseBeepDuration1)                       &getRefByType<decltype(displays.changeReverseBeepDuration1)>()                       { return displays.changeReverseBeepDuration1; }
-
-template<> decltype(displays.changeIMotMax)                                    &getRefByType<decltype(displays.changeIMotMax)>()                                    { return displays.changeIMotMax; }
-template<> decltype(displays.changeIDcMax)                                     &getRefByType<decltype(displays.changeIDcMax)>()                                     { return displays.changeIDcMax; }
-template<> decltype(displays.changeNMotMaxKmh)                                 &getRefByType<decltype(displays.changeNMotMaxKmh)>()                                 { return displays.changeNMotMaxKmh; }
-template<> decltype(displays.changeNMotMaxRpm)                                 &getRefByType<decltype(displays.changeNMotMaxRpm)>()                                 { return displays.changeNMotMaxRpm; }
-template<> decltype(displays.changeFieldWeakMax)                               &getRefByType<decltype(displays.changeFieldWeakMax)>()                               { return displays.changeFieldWeakMax; }
-template<> decltype(displays.changePhaseAdvMax)                                &getRefByType<decltype(displays.changePhaseAdvMax)>()                                { return displays.changePhaseAdvMax; }
-
-template<> decltype(displays.wheelDiameterMmChangeScreen)                      &getRefByType<decltype(displays.wheelDiameterMmChangeScreen)>()                      { return displays.wheelDiameterMmChangeScreen; }
-template<> decltype(displays.wheelDiameterInchChangeScreen)                    &getRefByType<decltype(displays.wheelDiameterInchChangeScreen)>()                    { return displays.wheelDiameterInchChangeScreen; }
-template<> decltype(displays.numMagnetPolesChangeScreen)                       &getRefByType<decltype(displays.numMagnetPolesChangeScreen)>()                       { return displays.numMagnetPolesChangeScreen; }
-
-template<> decltype(displays.changeDefaultModeModelMode)                       &getRefByType<decltype(displays.changeDefaultModeModelMode)>()                       { return displays.changeDefaultModeModelMode; }
-template<> decltype(displays.changeDefaultModeSmoothing)                       &getRefByType<decltype(displays.changeDefaultModeSmoothing)>()                       { return displays.changeDefaultModeSmoothing; }
-template<> decltype(displays.changeDefaultModeFrontPercentage)                 &getRefByType<decltype(displays.changeDefaultModeFrontPercentage)>()                 { return displays.changeDefaultModeFrontPercentage; }
-template<> decltype(displays.changeDefaultModeBackPercentage)                  &getRefByType<decltype(displays.changeDefaultModeBackPercentage)>()                  { return displays.changeDefaultModeBackPercentage; }
-template<> decltype(displays.changeDefaultModeAddSchwelle)                     &getRefByType<decltype(displays.changeDefaultModeAddSchwelle)>()                     { return displays.changeDefaultModeAddSchwelle; }
-template<> decltype(displays.changeDefaultModeGas1Wert)                        &getRefByType<decltype(displays.changeDefaultModeGas1Wert)>()                        { return displays.changeDefaultModeGas1Wert; }
-template<> decltype(displays.changeDefaultModeGas2Wert)                        &getRefByType<decltype(displays.changeDefaultModeGas2Wert)>()                        { return displays.changeDefaultModeGas2Wert; }
-template<> decltype(displays.changeDefaultModeBrems1Wert)                      &getRefByType<decltype(displays.changeDefaultModeBrems1Wert)>()                      { return displays.changeDefaultModeBrems1Wert; }
-template<> decltype(displays.changeDefaultModeBrems2Wert)                      &getRefByType<decltype(displays.changeDefaultModeBrems2Wert)>()                      { return displays.changeDefaultModeBrems2Wert; }
-
-template<> decltype(displays.changeManualModeModelMode)                        &getRefByType<decltype(displays.changeManualModeModelMode)>()                        { return displays.changeManualModeModelMode; }
-
-template<> decltype(displays.larsmModeModelModeChangeDisplay)                  &getRefByType<decltype(displays.larsmModeModelModeChangeDisplay)>()                  { return displays.larsmModeModelModeChangeDisplay; }
-template<> decltype(displays.larsmModeModeChangeDisplay)                       &getRefByType<decltype(displays.larsmModeModeChangeDisplay)>()                       { return displays.larsmModeModeChangeDisplay; }
-template<> decltype(displays.larsmModeIterationsChangeDisplay)                 &getRefByType<decltype(displays.larsmModeIterationsChangeDisplay)>()                 { return displays.larsmModeIterationsChangeDisplay; }
-
-template<> decltype(displays.sampleCountChangeScreen)                          &getRefByType<decltype(displays.sampleCountChangeScreen)>()                          { return displays.sampleCountChangeScreen; }
-template<> decltype(displays.changeGasMin)                                     &getRefByType<decltype(displays.changeGasMin)>()                                     { return displays.changeGasMin; }
-template<> decltype(displays.changeGasMax)                                     &getRefByType<decltype(displays.changeGasMax)>()                                     { return displays.changeGasMax; }
-template<> decltype(displays.changeBremsMin)                                   &getRefByType<decltype(displays.changeBremsMin)>()                                   { return displays.changeBremsMin; }
-template<> decltype(displays.changeBremsMax)                                   &getRefByType<decltype(displays.changeBremsMax)>()                                   { return displays.changeBremsMax; }
-#if defined(FEATURE_DPAD) || defined(FEATURE_DPAD_3WIRESW) || defined(FEATURE_DPAD_5WIRESW)
-template<> decltype(displays.dPadDebounceChangeScreen)                         &getRefByType<decltype(displays.dPadDebounceChangeScreen)>()                         { return displays.dPadDebounceChangeScreen; }
-#endif
-#ifdef FEATURE_GAMETRAK
-template<> decltype(displays.changeGametrakXMin)                               &getRefByType<decltype(displays.changeGametrakXMin)>()                               { return displays.changeGametrakXMin; }
-template<> decltype(displays.changeGametrakXMax)                               &getRefByType<decltype(displays.changeGametrakXMax)>()                               { return displays.changeGametrakXMax; }
-template<> decltype(displays.changeGametrakYMin)                               &getRefByType<decltype(displays.changeGametrakYMin)>()                               { return displays.changeGametrakYMin; }
-template<> decltype(displays.changeGametrakYMax)                               &getRefByType<decltype(displays.changeGametrakYMax)>()                               { return displays.changeGametrakYMax; }
-template<> decltype(displays.changeGametrakDistMin)                            &getRefByType<decltype(displays.changeGametrakDistMin)>()                            { return displays.changeGametrakDistMin; }
-template<> decltype(displays.changeGametrakDistMax)                            &getRefByType<decltype(displays.changeGametrakDistMax)>()                            { return displays.changeGametrakDistMax; }
-#endif
-
-template<> decltype(displays.potiReadRateChangeDisplay)                        &getRefByType<decltype(displays.potiReadRateChangeDisplay)>()                        { return displays.potiReadRateChangeDisplay; }
-template<> decltype(displays.modeUpdateRateChangeDisplay)                      &getRefByType<decltype(displays.modeUpdateRateChangeDisplay)>()                      { return displays.modeUpdateRateChangeDisplay; }
-template<> decltype(displays.statsUpdateRateChangeDisplay)                     &getRefByType<decltype(displays.statsUpdateRateChangeDisplay)>()                     { return displays.statsUpdateRateChangeDisplay; }
-template<> decltype(displays.displayUpdateRateChangeDisplay)                   &getRefByType<decltype(displays.displayUpdateRateChangeDisplay)>()                   { return displays.displayUpdateRateChangeDisplay; }
-template<> decltype(displays.displayRedrawRateChangeDisplay)                   &getRefByType<decltype(displays.displayRedrawRateChangeDisplay)>()                   { return displays.displayRedrawRateChangeDisplay; }
-
-template<> decltype(displays.wifiModeChangeScreen)                             &getRefByType<decltype(displays.wifiModeChangeScreen)>()                             { return displays.wifiModeChangeScreen; }
-template<> decltype(displays.wifiTxPowerChangeScreen)                          &getRefByType<decltype(displays.wifiTxPowerChangeScreen)>()                          { return displays.wifiTxPowerChangeScreen; }
-
-template<> decltype(displays.gasGraphDisplay)                                  &getRefByType<decltype(displays.gasGraphDisplay)>()                                  { return displays.gasGraphDisplay; }
-template<> decltype(displays.bremsGraphDisplay)                                &getRefByType<decltype(displays.bremsGraphDisplay)>()                                { return displays.bremsGraphDisplay; }
-template<> decltype(displays.potisGraphDisplay)                                &getRefByType<decltype(displays.potisGraphDisplay)>()                                { return displays.potisGraphDisplay; }
-template<> decltype(displays.potisSplitGraphDisplay)                           &getRefByType<decltype(displays.potisSplitGraphDisplay)>()                           { return displays.potisSplitGraphDisplay; }
-template<> decltype(displays.avgSpeedGraphDisplay)                             &getRefByType<decltype(displays.avgSpeedGraphDisplay)>()                             { return displays.avgSpeedGraphDisplay; }
-template<> decltype(displays.avgSpeedKmhGraphDisplay)                          &getRefByType<decltype(displays.avgSpeedKmhGraphDisplay)>()                          { return displays.avgSpeedKmhGraphDisplay; }
-template<> decltype(displays.sumCurrentGraphDisplay)                           &getRefByType<decltype(displays.sumCurrentGraphDisplay)>()                           { return displays.sumCurrentGraphDisplay; }
-template<> decltype(displays.frontVoltageGraphDisplay)                         &getRefByType<decltype(displays.frontVoltageGraphDisplay)>()                         { return displays.frontVoltageGraphDisplay; }
-template<> decltype(displays.backVoltageGraphDisplay)                          &getRefByType<decltype(displays.backVoltageGraphDisplay)>()                          { return displays.backVoltageGraphDisplay; }
-template<> decltype(displays.voltagesGraphDisplay)                             &getRefByType<decltype(displays.voltagesGraphDisplay)>()                             { return displays.voltagesGraphDisplay; }
-template<> decltype(displays.voltagesSplitGraphDisplay)                        &getRefByType<decltype(displays.voltagesSplitGraphDisplay)>()                        { return displays.voltagesSplitGraphDisplay; }
-#ifdef FEATURE_BMS
-template<> decltype(displays.bmsVoltageGraphDisplay)                           &getRefByType<decltype(displays.bmsVoltageGraphDisplay)>()                           { return displays.bmsVoltageGraphDisplay; }
-template<> decltype(displays.bmsCurrentGraphDisplay)                           &getRefByType<decltype(displays.bmsCurrentGraphDisplay)>()                           { return displays.bmsCurrentGraphDisplay; }
-template<> decltype(displays.bmsPowerGraphDisplay)                             &getRefByType<decltype(displays.bmsPowerGraphDisplay)>()                             { return displays.bmsPowerGraphDisplay; }
-template<> decltype(displays.sumCurrentsComparisonGraphDisplay)                &getRefByType<decltype(displays.sumCurrentsComparisonGraphDisplay)>()                { return displays.sumCurrentsComparisonGraphDisplay; }
-#endif
-template<> decltype(displays.motorCurrentsGraphDisplay)                        &getRefByType<decltype(displays.motorCurrentsGraphDisplay)>()                        { return displays.motorCurrentsGraphDisplay; }
-
-
 void deconstructScreen()
 {
    if (currentDisplay)
    {
        currentDisplay->stop();
-        currentDisplay->~Display();
+        //currentDisplay->~Display();
        currentDisplay = nullptr;
    }
 }
@ -403,13 +25,12 @@ void switchScreenImpl(Args&&... args)
 {
    deconstructScreen();

-    T &ref = getRefByType<T>();
-    new (&ref) T{std::forward<Args>(args)...};
-    currentDisplay = &ref;
-    ref.start();
-    ref.initScreen();
-    ref.update();
-    ref.redraw();
+    std::unique_ptr<T> ptr = std::make_unique<T>(std::forward<Args>(args)...);
+    currentDisplay = std::move(ptr);
+    currentDisplay->start();
+    currentDisplay->initScreen();
+    currentDisplay->update();
+    currentDisplay->redraw();
 }

 std::function<void()> changeScreenCallback;
@ -429,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();
--- a/src/staticmenudefinition.h
+++ b/src/staticmenudefinition.h
@ -1,84 +0,0 @@
-#pragma once
-
-#include "menudefinitioninterface.h"
-
-namespace {
-template<typename ...T>
-class StaticMenuDefinition;
-
-template<typename T>
-class StaticMenuDefinition<T> : public virtual MenuDefinitionInterface
-{
-public:
-    std::size_t size() const override { return 1; }
-
-    MenuItem& getMenuItem(std::size_t index) override
-    {
-        if (index == 0)
-            return item;
-
-        throw "aua";
-    }
-
-    const MenuItem& getMenuItem(std::size_t index) const override
-    {
-        if (index == 0)
-            return item;
-
-        throw "aua";
-    }
-
-    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
-    {
-        callback(item);
-    }
-
-    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
-    {
-        callback(item);
-    }
-
-private:
-    T item;
-};
-
-template<typename T, typename ...Tmore>
-class StaticMenuDefinition<T, Tmore...> : public virtual StaticMenuDefinition<Tmore...>
-{
-    using Base = StaticMenuDefinition<Tmore...>;
-
-public:
-    std::size_t size() const override { return 1 + sizeof...(Tmore); }
-
-    MenuItem& getMenuItem(std::size_t index) override
-    {
-        if (index == 0)
-            return item;
-
-        return Base::getMenuItem(index - 1);
-    }
-
-    const MenuItem& getMenuItem(std::size_t index) const override
-    {
-        if (index == 0)
-            return item;
-
-        return Base::getMenuItem(index - 1);
-    }
-
-    void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
-    {
-        callback(item);
-        Base::runForEveryMenuItem(std::move(callback));
-    }
-
-    void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
-    {
-        callback(item);
-        Base::runForEveryMenuItem(std::move(callback));
-    }
-
-private:
-    T item;
-};
-}