diff --git a/src/actions/backproxyaction.h b/src/actions/backproxyaction.h
new file mode 100644
index 0000000..f168172
--- /dev/null
+++ b/src/actions/backproxyaction.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "actioninterface.h"
+
+namespace {
+class BackProxyAction : public virtual ActionInterface
+{
+public:
+    BackProxyAction(BackInterface &backInterface) :
+        m_backInterface{backInterface}
+    {
+    }
+
+    void triggered() override
+    {
+        m_backInterface.back();
+    }
+
+private:
+    BackInterface &m_backInterface;
+};
+}
diff --git a/src/actions/modesettingsaction.h b/src/actions/modesettingsaction.h
new file mode 100644
index 0000000..ef83b04
--- /dev/null
+++ b/src/actions/modesettingsaction.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <HardwareSerial.h>
+
+#include "actioninterface.h"
+#include "globals.h"
+#include "modes/defaultmode.h"
+#include "modes/tempomatmode.h"
+#include "modes/larsmmode.h"
+#include "modes/gametrakmode.h"
+#include "displays/menus/defaultmodesettingsmenu.h"
+#include "displays/menus/tempomatmodesettingsmenu.h"
+#include "displays/menus/larsmmodesettingsmenu.h"
+#include "displays/menus/gametrakmodesettingsmenu.h"
+
+namespace {
+class ModeSettingsAction : public virtual ActionInterface
+{
+public:
+    void triggered() override;
+};
+
+void ModeSettingsAction::triggered()
+{
+    if (currentMode == &modes::defaultMode)
+        switchScreen<DefaultModeSettingsMenu>();
+    else if (currentMode == &modes::tempomatMode)
+        switchScreen<TempomatModeSettingsMenu>();
+    else if (currentMode == &modes::larsmMode)
+        switchScreen<LarsmModeSettingsMenu>();
+#ifdef FEATURE_GAMETRAK
+    else if (currentMode == &modes::gametrakMode)
+        switchScreen<GametrakModeSettingsMenu>();
+#endif
+    else
+        Serial.println("Unknown mode, cannot open settings for it");
+}
+}
diff --git a/src/actions/setvalueaction.h b/src/actions/setvalueaction.h
new file mode 100644
index 0000000..a7a2781
--- /dev/null
+++ b/src/actions/setvalueaction.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "actioninterface.h"
+#include "accessorinterface.h"
+
+namespace {
+template<typename T>
+class SetValueAction : public virtual ActionInterface
+{
+public:
+    SetValueAction(T value, AccessorInterface<T> &accessorInterface, BackInterface &backInterface) :
+        m_value{value},
+        m_accessorInterface{accessorInterface},
+        m_backInterface{backInterface}
+    {
+    }
+
+    void triggered() override
+    {
+        m_accessorInterface.setValue(m_value);
+    }
+
+    T value() const { return m_value; }
+
+private:
+    const T m_value;
+    AccessorInterface<T> &m_accessorInterface;
+    BackInterface &m_backInterface;
+};
+}
diff --git a/src/bobby_webserver.h b/src/bobby_webserver.h
index 9112bf8..923b033 100644
--- a/src/bobby_webserver.h
+++ b/src/bobby_webserver.h
@@ -177,7 +177,13 @@ void initWebserver()
             return;
         }
 
-        menuDisplay->itemPressed(index);
+        if (index < 0 || index >= menuDisplay->size())
+        {
+            webServer.send(400, "text/plain", "index out of range");
+            return;
+        }
+
+        menuDisplay->getMenuItem(index).triggered();
 
         webServer.sendHeader("Connection", "close");
         webServer.sendHeader("Location", "/");
diff --git a/src/changevaluedisplay_bluetoothmode.h b/src/changevaluedisplay_bluetoothmode.h
index 4a8949d..953edaf 100644
--- a/src/changevaluedisplay_bluetoothmode.h
+++ b/src/changevaluedisplay_bluetoothmode.h
@@ -4,7 +4,8 @@
 #include "menudisplay.h"
 #include "staticmenudefinition.h"
 #include "utils.h"
-#include "actions/dummyaction.h"
+#include "actions/setvalueaction.h"
+#include "actions/backproxyaction.h"
 #include "icons/back.h"
 #include "texts.h"
 #include "bluetoothmode.h"
@@ -13,12 +14,6 @@ namespace {
 template<>
 class ChangeValueDisplay<BluetoothMode> :
     public MenuDisplay,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_OFF>,    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_MASTER>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_SLAVE>,  DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,   DummyAction, StaticMenuItemIcon<&icons::back>>
-    >,
     public virtual AccessorInterface<BluetoothMode>,
     public virtual ActionInterface
 {
@@ -27,35 +22,65 @@ class ChangeValueDisplay<BluetoothMode> :
 public:
     void start() override;
 
-    void itemPressed(int index) 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};
 };
 
 void ChangeValueDisplay<BluetoothMode>::start()
 {
     Base::start();
 
-    if (getValue() == BluetoothMode::Off)
-        setSelectedIndex(0);
-    else if (getValue() == BluetoothMode::Master)
-        setSelectedIndex(1);
-    else if (getValue() == BluetoothMode::Slave)
-        setSelectedIndex(2);
-    else
+    if (getValue() == m_offAction.value())    setSelectedIndex(0); else
+    if (getValue() == m_masterAction.value()) setSelectedIndex(1); else
+    if (getValue() == m_slaveAction.value())  setSelectedIndex(2); else
     {
         Serial.printf("Unknown BluetoothMode: %i", int(getValue()));
         setSelectedIndex(4);
     }
 }
-
-void ChangeValueDisplay<BluetoothMode>::itemPressed(int index)
-{
-    switch (index)
-    {
-    case 0: setValue(BluetoothMode::Off); break;
-    case 1: setValue(BluetoothMode::Master); break;
-    case 2: setValue(BluetoothMode::Slave); break;
-    }
-
-    triggered();
-}
 }
diff --git a/src/changevaluedisplay_bool.h b/src/changevaluedisplay_bool.h
index 9cf4ef7..977fb49 100644
--- a/src/changevaluedisplay_bool.h
+++ b/src/changevaluedisplay_bool.h
@@ -5,7 +5,8 @@
 #include "staticmenudefinition.h"
 #include "actioninterface.h"
 #include "utils.h"
-#include "actions/dummyaction.h"
+#include "actions/setvalueaction.h"
+#include "actions/backproxyaction.h"
 #include "icons/back.h"
 #include "texts.h"
 
@@ -13,11 +14,6 @@ namespace {
 template<>
 class ChangeValueDisplay<bool> :
     public MenuDisplay,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_TRUE>,  DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_FALSE>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,  DummyAction, StaticMenuItemIcon<&icons::back>>
-    >,
     public virtual AccessorInterface<bool>,
     public virtual ActionInterface
 {
@@ -26,27 +22,55 @@ class ChangeValueDisplay<bool> :
 public:
     void start() override;
 
-    void itemPressed(int index) 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};
 };
 
 void ChangeValueDisplay<bool>::start()
 {
     Base::start();
 
-    if (getValue() == true)
-        setSelectedIndex(0);
-    else if (getValue() == false)
-        setSelectedIndex(1);
-}
-
-void ChangeValueDisplay<bool>::itemPressed(int index)
-{
-    switch (index)
-    {
-    case 0: setValue(true); break;
-    case 1: setValue(false); break;
-    }
-
-    triggered();
+    if (getValue() == m_trueItem.value())  setSelectedIndex(0); else
+    if (getValue() == m_falseItem.value()) setSelectedIndex(1);
 }
 }
diff --git a/src/changevaluedisplay_controlmode.h b/src/changevaluedisplay_controlmode.h
index 19668d9..973a8b3 100644
--- a/src/changevaluedisplay_controlmode.h
+++ b/src/changevaluedisplay_controlmode.h
@@ -4,7 +4,8 @@
 #include "menudisplay.h"
 #include "staticmenudefinition.h"
 #include "utils.h"
-#include "actions/dummyaction.h"
+#include "actions/setvalueaction.h"
+#include "actions/backproxyaction.h"
 #include "icons/back.h"
 #include "texts.h"
 
@@ -12,13 +13,6 @@ namespace {
 template<>
 class ChangeValueDisplay<ControlMode> :
     public MenuDisplay,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_OPENMODE>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_VOLTAGE>,  DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_SPEED>,    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_TORQUE>,   DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,     DummyAction, StaticMenuItemIcon<&icons::back>>
-    >,
     public virtual AccessorInterface<ControlMode>,
     public virtual ActionInterface
 {
@@ -27,38 +21,71 @@ class ChangeValueDisplay<ControlMode> :
 public:
     void start() override;
 
-    void itemPressed(int index) 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;
 };
 
 void ChangeValueDisplay<ControlMode>::start()
 {
     Base::start();
 
-    if (getValue() == ControlMode::OpenMode)
-        setSelectedIndex(0);
-    else if (getValue() == ControlMode::Voltage)
-        setSelectedIndex(1);
-    else if (getValue() == ControlMode::Speed)
-        setSelectedIndex(2);
-    else if (getValue() == ControlMode::Torque)
-        setSelectedIndex(3);
-    else
+    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
     {
         Serial.printf("Unknown ControlMode: %i", int(getValue()));
         setSelectedIndex(4);
     }
 }
-
-void ChangeValueDisplay<ControlMode>::itemPressed(int index)
-{
-    switch (index)
-    {
-    case 0: setValue(ControlMode::OpenMode); break;
-    case 1: setValue(ControlMode::Voltage); break;
-    case 2: setValue(ControlMode::Speed); break;
-    case 3: setValue(ControlMode::Torque); break;
-    }
-
-    triggered();
-}
 }
diff --git a/src/changevaluedisplay_controltype.h b/src/changevaluedisplay_controltype.h
index 9050a8c..f9c8613 100644
--- a/src/changevaluedisplay_controltype.h
+++ b/src/changevaluedisplay_controltype.h
@@ -4,7 +4,8 @@
 #include "menudisplay.h"
 #include "staticmenudefinition.h"
 #include "utils.h"
-#include "actions/dummyaction.h"
+#include "actions/setvalueaction.h"
+#include "actions/backproxyaction.h"
 #include "icons/back.h"
 #include "texts.h"
 
@@ -12,12 +13,6 @@ namespace {
 template<>
 class ChangeValueDisplay<ControlType> :
     public MenuDisplay,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_COMMUTATION>,          DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_SINUSOIDAL>,           DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_FIELDORIENTEDCONTROL>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,                 DummyAction, StaticMenuItemIcon<&icons::back>>
-    >,
     public virtual AccessorInterface<ControlType>,
     public virtual ActionInterface
 {
@@ -26,35 +21,65 @@ class ChangeValueDisplay<ControlType> :
 public:
     void start() override;
 
-    void itemPressed(int index) 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};
 };
 
 void ChangeValueDisplay<ControlType>::start()
 {
     Base::start();
 
-    if (getValue() == ControlType::Commutation)
-        setSelectedIndex(0);
-    else if (getValue() == ControlType::Sinusoidal)
-        setSelectedIndex(1);
-    else if (getValue() == ControlType::FieldOrientedControl)
-        setSelectedIndex(2);
-    else
+    if (getValue() == m_commutationItem.value())          setSelectedIndex(0); else
+    if (getValue() == m_sinusoidalItem.value())           setSelectedIndex(1); else
+    if (getValue() == m_fieldOrientedControlItem.value()) setSelectedIndex(2); else
     {
         Serial.printf("Unknown ControlType: %i", int(getValue()));
         setSelectedIndex(3);
     }
 }
-
-void ChangeValueDisplay<ControlType>::itemPressed(int index)
-{
-    switch (index)
-    {
-    case 0: setValue(ControlType::Commutation); break;
-    case 1: setValue(ControlType::Sinusoidal); break;
-    case 2: setValue(ControlType::FieldOrientedControl); break;
-    }
-
-    triggered();
-}
 }
diff --git a/src/changevaluedisplay_larsmmode_mode.h b/src/changevaluedisplay_larsmmode_mode.h
index 39504cf..cb8d19c 100644
--- a/src/changevaluedisplay_larsmmode_mode.h
+++ b/src/changevaluedisplay_larsmmode_mode.h
@@ -4,7 +4,8 @@
 #include "menudisplay.h"
 #include "staticmenudefinition.h"
 #include "utils.h"
-#include "actions/dummyaction.h"
+#include "actions/setvalueaction.h"
+#include "actions/backproxyaction.h"
 #include "icons/back.h"
 #include "texts.h"
 #include "modes/larsmmode.h"
@@ -13,13 +14,6 @@ namespace {
 template<>
 class ChangeValueDisplay<LarsmModeMode> :
     public MenuDisplay,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_LARSMMODE1>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_LARSMMODE2>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_LARSMMODE3>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_LARSMMODE4>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,       DummyAction, StaticMenuItemIcon<&icons::back>>
-    >,
     public virtual AccessorInterface<LarsmModeMode>,
     public virtual ActionInterface
 {
@@ -28,38 +22,71 @@ class ChangeValueDisplay<LarsmModeMode> :
 public:
     void start() override;
 
-    void itemPressed(int index) 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};
 };
 
 void ChangeValueDisplay<LarsmModeMode>::start()
 {
     Base::start();
 
-    if (getValue() == LarsmModeMode::Mode1)
-        setSelectedIndex(0);
-    else if (getValue() == LarsmModeMode::Mode2)
-        setSelectedIndex(1);
-    else if (getValue() == LarsmModeMode::Mode3)
-        setSelectedIndex(2);
-    else if (getValue() == LarsmModeMode::Mode4)
-        setSelectedIndex(3);
-    else
+    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
     {
         Serial.printf("Unknown LarsmModeMode: %i", int(getValue()));
         setSelectedIndex(4);
     }
 }
-
-void ChangeValueDisplay<LarsmModeMode>::itemPressed(int index)
-{
-    switch (index)
-    {
-    case 0: setValue(LarsmModeMode::Mode1); break;
-    case 1: setValue(LarsmModeMode::Mode2); break;
-    case 2: setValue(LarsmModeMode::Mode3); break;
-    case 3: setValue(LarsmModeMode::Mode4); break;
-    }
-
-    triggered();
-}
 }
diff --git a/src/changevaluedisplay_unifiedmodelmode.h b/src/changevaluedisplay_unifiedmodelmode.h
index 94d2bed..c6e8751 100644
--- a/src/changevaluedisplay_unifiedmodelmode.h
+++ b/src/changevaluedisplay_unifiedmodelmode.h
@@ -4,7 +4,8 @@
 #include "menudisplay.h"
 #include "staticmenudefinition.h"
 #include "utils.h"
-#include "actions/dummyaction.h"
+#include "actions/setvalueaction.h"
+#include "actions/backproxyaction.h"
 #include "icons/back.h"
 #include "texts.h"
 #include "unifiedmodelmode.h"
@@ -13,14 +14,6 @@ namespace {
 template<>
 class ChangeValueDisplay<UnifiedModelMode> :
     public MenuDisplay,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_COMMUTATION>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_SINUSOIDAL>,  DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_FOCVOLTAGE>,  DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_FOCSPEED>,    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_FOCTORQUE>,   DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,        DummyAction, StaticMenuItemIcon<&icons::back>>
-    >,
     public virtual AccessorInterface<UnifiedModelMode>,
     public virtual ActionInterface
 {
@@ -29,41 +22,77 @@ class ChangeValueDisplay<UnifiedModelMode> :
 public:
     void start() override;
 
-    void itemPressed(int index) 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};
 };
 
 void ChangeValueDisplay<UnifiedModelMode>::start()
 {
     Base::start();
 
-    if (getValue() == UnifiedModelMode::Commutation)
-        setSelectedIndex(0);
-    else if (getValue() == UnifiedModelMode::Sinusoidal)
-        setSelectedIndex(1);
-    else if (getValue() == UnifiedModelMode::FocVoltage)
-        setSelectedIndex(2);
-    else if (getValue() == UnifiedModelMode::FocSpeed)
-        setSelectedIndex(3);
-    else if (getValue() == UnifiedModelMode::FocTorque)
-        setSelectedIndex(4);
-    else
+    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
     {
         Serial.printf("Unknown UnifiedModelMode: %i", int(getValue()));
         setSelectedIndex(5);
     }
 }
-
-void ChangeValueDisplay<UnifiedModelMode>::itemPressed(int index)
-{
-    switch (index)
-    {
-    case 0: setValue(UnifiedModelMode::Commutation); break;
-    case 1: setValue(UnifiedModelMode::Sinusoidal); break;
-    case 2: setValue(UnifiedModelMode::FocVoltage); break;
-    case 3: setValue(UnifiedModelMode::FocSpeed); break;
-    case 4: setValue(UnifiedModelMode::FocTorque); break;
-    }
-
-    triggered();
-}
 }
diff --git a/src/changevaluedisplay_wifi_mode_t.h b/src/changevaluedisplay_wifi_mode_t.h
index 67e2ca9..74616fb 100644
--- a/src/changevaluedisplay_wifi_mode_t.h
+++ b/src/changevaluedisplay_wifi_mode_t.h
@@ -6,7 +6,8 @@
 #include "menudisplay.h"
 #include "staticmenudefinition.h"
 #include "utils.h"
-#include "actions/dummyaction.h"
+#include "actions/setvalueaction.h"
+#include "actions/backproxyaction.h"
 #include "icons/back.h"
 #include "texts.h"
 
@@ -14,13 +15,6 @@ namespace {
 template<>
 class ChangeValueDisplay<wifi_mode_t> :
     public MenuDisplay,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_MODE_NULL>,  DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_MODE_STA>,   DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_MODE_AP>,    DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_MODE_APSTA>, DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,            DummyAction, StaticMenuItemIcon<&icons::back>>
-    >,
     public virtual AccessorInterface<wifi_mode_t>,
     public virtual ActionInterface
 {
@@ -29,38 +23,71 @@ class ChangeValueDisplay<wifi_mode_t> :
 public:
     void start() override;
 
-    void itemPressed(int index) 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};
 };
 
 void ChangeValueDisplay<wifi_mode_t>::start()
 {
     Base::start();
 
-    if (getValue() == WIFI_MODE_NULL)
-        setSelectedIndex(0);
-    else if (getValue() == WIFI_MODE_STA)
-        setSelectedIndex(1);
-    else if (getValue() == WIFI_MODE_AP)
-        setSelectedIndex(2);
-    else if (getValue() == WIFI_MODE_APSTA)
-        setSelectedIndex(3);
-    else
+    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
     {
         Serial.printf("Unknown wifi_mode_t: %i", int(getValue()));
         setSelectedIndex(4);
     }
 }
-
-void ChangeValueDisplay<wifi_mode_t>::itemPressed(int index)
-{
-    switch (index)
-    {
-    case 0: setValue(WIFI_MODE_NULL); break;
-    case 1: setValue(WIFI_MODE_STA); break;
-    case 2: setValue(WIFI_MODE_AP); break;
-    case 3: setValue(WIFI_MODE_APSTA); break;
-    }
-
-    triggered();
-}
 }
diff --git a/src/changevaluedisplay_wifi_power_t.h b/src/changevaluedisplay_wifi_power_t.h
index a902f54..c135675 100644
--- a/src/changevaluedisplay_wifi_power_t.h
+++ b/src/changevaluedisplay_wifi_power_t.h
@@ -6,7 +6,8 @@
 #include "menudisplay.h"
 #include "staticmenudefinition.h"
 #include "utils.h"
-#include "actions/dummyaction.h"
+#include "actions/setvalueaction.h"
+#include "actions/backproxyaction.h"
 #include "icons/back.h"
 #include "texts.h"
 
@@ -14,21 +15,6 @@ namespace {
 template<>
 class ChangeValueDisplay<wifi_power_t> :
     public MenuDisplay,
-    public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_19_5dBm>,     DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_19dBm>,       DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_18_5dBm>,     DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_17dBm>,       DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_15dBm>,       DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_13dBm>,       DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_11dBm>,       DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_8_5dBm>,      DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_7dBm>,        DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_5dBm>,        DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_2dBm>,        DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_MINUS_1dBm>,  DummyAction>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,                   DummyAction, StaticMenuItemIcon<&icons::back>>
-    >,
     public virtual AccessorInterface<wifi_power_t>,
     public virtual ActionInterface
 {
@@ -37,62 +23,119 @@ class ChangeValueDisplay<wifi_power_t> :
 public:
     void start() override;
 
-    void itemPressed(int index) 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};
 };
 
 void ChangeValueDisplay<wifi_power_t>::start()
 {
     Base::start();
 
-    if (getValue() == WIFI_POWER_19_5dBm)
-        setSelectedIndex(0);
-    else if (getValue() == WIFI_POWER_19dBm)
-        setSelectedIndex(1);
-    else if (getValue() == WIFI_POWER_18_5dBm)
-        setSelectedIndex(2);
-    else if (getValue() == WIFI_POWER_17dBm)
-        setSelectedIndex(3);
-    else if (getValue() == WIFI_POWER_15dBm)
-        setSelectedIndex(4);
-    else if (getValue() == WIFI_POWER_13dBm)
-        setSelectedIndex(5);
-    else if (getValue() == WIFI_POWER_11dBm)
-        setSelectedIndex(6);
-    else if (getValue() == WIFI_POWER_8_5dBm)
-        setSelectedIndex(7);
-    else if (getValue() == WIFI_POWER_7dBm)
-        setSelectedIndex(8);
-    else if (getValue() == WIFI_POWER_5dBm)
-        setSelectedIndex(9);
-    else if (getValue() == WIFI_POWER_2dBm)
-        setSelectedIndex(10);
-    else if (getValue() == WIFI_POWER_MINUS_1dBm)
-        setSelectedIndex(11);
-    else
+    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
     {
         Serial.printf("Unknown wifi_power_t: %i", int(getValue()));
         setSelectedIndex(12);
     }
 }
-
-void ChangeValueDisplay<wifi_power_t>::itemPressed(int index)
-{
-    switch (index)
-    {
-    case 0: setValue(WIFI_POWER_19_5dBm); break;
-    case 1: setValue(WIFI_POWER_19dBm); break;
-    case 2: setValue(WIFI_POWER_18_5dBm); break;
-    case 3: setValue(WIFI_POWER_17dBm); break;
-    case 4: setValue(WIFI_POWER_15dBm); break;
-    case 5: setValue(WIFI_POWER_13dBm); break;
-    case 6: setValue(WIFI_POWER_11dBm); break;
-    case 7: setValue(WIFI_POWER_8_5dBm); break;
-    case 8: setValue(WIFI_POWER_7dBm); break;
-    case 9: setValue(WIFI_POWER_5dBm); break;
-    case 10: setValue(WIFI_POWER_2dBm); break;
-    case 11: setValue(WIFI_POWER_MINUS_1dBm); break;
-    }
-
-    triggered();
-}
 }
diff --git a/src/debugtexthelpers.h b/src/debugtexthelpers.h
index cdf0d2b..0a9d96c 100644
--- a/src/debugtexthelpers.h
+++ b/src/debugtexthelpers.h
@@ -16,37 +16,30 @@ struct ControllerTexts
     struct PoweroffText : public virtual TextInterface { public: String text() const override { return String{"poweroff: "} + toString(controller::get().command.poweroff); } };
     struct LedText : public virtual TextInterface { public: String text() const override { return String{"led: "} + toString(controller::get().command.led); } };
 
-    struct LeftCommand
-    {
-        LeftCommand() = delete;
-        ~LeftCommand() = delete;
+private:
+    struct LeftCommandGetter { static const MotorState &get() { return controller::get().command.left; } };
+    struct RightCommandGetter { static const MotorState &get() { return controller::get().command.right; } };
 
-        struct EnableText : public virtual TextInterface { public: String text() const override { return String{"enable: "} + toString(controller::get().command.left.enable); } };
-        struct PwmText : public virtual TextInterface { public: String text() const override { return String{"pwm: "} + toString(controller::get().command.left.pwm); } };
-        struct CtrlTypText : public virtual TextInterface { public: String text() const override { return String{"ctrlTyp: "} + toString(controller::get().command.left.ctrlTyp); } };
-        struct CtrlModText : public virtual TextInterface { public: String text() const override { return String{"ctrlMod: "} + toString(controller::get().command.left.ctrlMod); } };
-        struct IMotMaxText : public virtual TextInterface { public: String text() const override { return String{"iMotMax: "} + toString(controller::get().command.left.iMotMax); } };
-        struct IDcMaxText : public virtual TextInterface { public: String text() const override { return String{"iDcMax: "} + toString(controller::get().command.left.iDcMax); } };
-        struct NMotMaxText : public virtual TextInterface { public: String text() const override { return String{"nMotMax: "} + toString(controller::get().command.left.nMotMax); } };
-        struct FieldWeakMaxText : public virtual TextInterface { public: String text() const override { return String{"fieldWeakMax: "} + toString(controller::get().command.left.fieldWeakMax); } };
-        struct PhaseAdvMaxText : public virtual TextInterface { public: String text() const override { return String{"phaseAdvMax: "} + toString(controller::get().command.left.phaseAdvMax); } };
+    template<typename MotorStateGetter>
+    struct CommandTexts
+    {
+        CommandTexts() = delete;
+        ~CommandTexts() = delete;
+
+        struct EnableText : public virtual TextInterface { public: String text() const override { return String{"enable: "} + toString(MotorStateGetter::get().enable); } };
+        struct PwmText : public virtual TextInterface { public: String text() const override { return String{"pwm: "} + toString(MotorStateGetter::get().pwm); } };
+        struct CtrlTypText : public virtual TextInterface { public: String text() const override { return String{"ctrlTyp: "} + toString(MotorStateGetter::get().ctrlTyp); } };
+        struct CtrlModText : public virtual TextInterface { public: String text() const override { return String{"ctrlMod: "} + toString(MotorStateGetter::get().ctrlMod); } };
+        struct IMotMaxText : public virtual TextInterface { public: String text() const override { return String{"iMotMax: "} + toString(MotorStateGetter::get().iMotMax); } };
+        struct IDcMaxText : public virtual TextInterface { public: String text() const override { return String{"iDcMax: "} + toString(MotorStateGetter::get().iDcMax); } };
+        struct NMotMaxText : public virtual TextInterface { public: String text() const override { return String{"nMotMax: "} + toString(MotorStateGetter::get().nMotMax); } };
+        struct FieldWeakMaxText : public virtual TextInterface { public: String text() const override { return String{"fieldWeakMax: "} + toString(MotorStateGetter::get().fieldWeakMax); } };
+        struct PhaseAdvMaxText : public virtual TextInterface { public: String text() const override { return String{"phaseAdvMax: "} + toString(MotorStateGetter::get().phaseAdvMax); } };
     };
 
-    struct RightCommand
-    {
-        RightCommand() = delete;
-        ~RightCommand() = delete;
-
-        struct EnableText : public virtual TextInterface { public: String text() const override { return String{"enable: "} + toString(controller::get().command.right.enable); } };
-        struct PwmText : public virtual TextInterface { public: String text() const override { return String{"pwm: "} + toString(controller::get().command.right.pwm); } };
-        struct CtrlTypText : public virtual TextInterface { public: String text() const override { return String{"ctrlTyp: "} + toString(controller::get().command.right.ctrlTyp); } };
-        struct CtrlModText : public virtual TextInterface { public: String text() const override { return String{"ctrlMod: "} + toString(controller::get().command.right.ctrlMod); } };
-        struct IMotMaxText : public virtual TextInterface { public: String text() const override { return String{"iMotMax: "} + toString(controller::get().command.right.iMotMax); } };
-        struct IDcMaxText : public virtual TextInterface { public: String text() const override { return String{"iDcMax: "} + toString(controller::get().command.right.iDcMax); } };
-        struct NMotMaxText : public virtual TextInterface { public: String text() const override { return String{"nMotMax: "} + toString(controller::get().command.right.nMotMax); } };
-        struct FieldWeakMaxText : public virtual TextInterface { public: String text() const override { return String{"fieldWeakMax: "} + toString(controller::get().command.right.fieldWeakMax); } };
-        struct PhaseAdvMaxText : public virtual TextInterface { public: String text() const override { return String{"phaseAdvMax: "} + toString(controller::get().command.right.phaseAdvMax); } };
-    };
+public:
+    using LeftCommand = CommandTexts<LeftCommandGetter>;
+    using RightCommand = CommandTexts<LeftCommandGetter>;
 
     struct BatVoltageText : public virtual TextInterface { public: String text() const override { auto line = String{"batVoltage: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.batVoltage); return line; } };
     struct BatVoltageFixedText : public virtual TextInterface { public: String text() const override { auto line = String{"batVoltage: "}; if (controller::get().feedbackValid) line += toString(fixBatVoltage(controller::get().feedback.batVoltage)) + 'V'; return line; } };
@@ -54,35 +47,29 @@ struct ControllerTexts
     struct BoardTempFixedText : public virtual TextInterface { public: String text() const override { auto line = String{"boardTemp: "}; if (controller::get().feedbackValid) line += toString(fixBoardTemp(controller::get().feedback.boardTemp)) + 'C'; return line; } };
     struct TimeoutCntSerialText : public virtual TextInterface { public: String text() const override { auto line = String{"timeoutCntSerial: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.timeoutCntSerial); return line; } };
 
-    struct LeftFeedback
-    {
-        LeftFeedback() = delete;
-        ~LeftFeedback() = delete;
+private:
+    struct LeftFeedbackGetter { static const MotorFeedback &get() { return controller::get().feedback.left; } };
+    struct RightFeedbackGetter { static const MotorFeedback &get() { return controller::get().feedback.right; } };
 
-        struct AngleText : public virtual TextInterface { public: String text() const override { auto line = String{"angle: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.left.angle); return line; } };
-        struct SpeedText : public virtual TextInterface { public: String text() const override { auto line = String{"speed: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.left.speed); return line; } };
-        struct SpeedKmhText : public virtual TextInterface { public: String text() const override { auto line = String{"speed kmh: "}; if (controller::get().feedbackValid) line += toString(convertToKmh(controller::get().feedback.left.speed)); return line; } };
-        struct ErrorText : public virtual TextInterface { public: String text() const override { auto line = String{"error: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.left.error); return line; } };
-        struct CurrentText : public virtual TextInterface { public: String text() const override { auto line = String{"current: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.left.current); return line; } };
-        struct CurrentFixedText : public virtual TextInterface { public: String text() const override { auto line = String{"current: "}; if (controller::get().feedbackValid) line += toString(fixCurrent(controller::get().feedback.left.current)) + 'A'; return line; } };
-        struct ChopsText : public virtual TextInterface { public: String text() const override { auto line = String{"chops: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.left.chops); return line; } };
-        struct HallText : public virtual TextInterface { public: String text() const override { auto line = String{"hall: "}; if (controller::get().feedbackValid) line += hallString(controller::get().feedback.left); return line; } };
+    template<typename MotorFeedbackGetter>
+    struct FeedbackTexts
+    {
+        FeedbackTexts() = delete;
+        ~FeedbackTexts() = delete;
+
+        struct AngleText : public virtual TextInterface { public: String text() const override { auto line = String{"angle: "}; if (controller::get().feedbackValid) line += toString(MotorFeedbackGetter::get().angle); return line; } };
+        struct SpeedText : public virtual TextInterface { public: String text() const override { auto line = String{"speed: "}; if (controller::get().feedbackValid) line += toString(MotorFeedbackGetter::get().speed); return line; } };
+        struct SpeedKmhText : public virtual TextInterface { public: String text() const override { auto line = String{"speed kmh: "}; if (controller::get().feedbackValid) line += toString(convertToKmh(MotorFeedbackGetter::get().speed)); return line; } };
+        struct ErrorText : public virtual TextInterface { public: String text() const override { auto line = String{"error: "}; if (controller::get().feedbackValid) line += toString(MotorFeedbackGetter::get().error); return line; } };
+        struct CurrentText : public virtual TextInterface { public: String text() const override { auto line = String{"current: "}; if (controller::get().feedbackValid) line += toString(MotorFeedbackGetter::get().current); return line; } };
+        struct CurrentFixedText : public virtual TextInterface { public: String text() const override { auto line = String{"current: "}; if (controller::get().feedbackValid) line += toString(fixCurrent(MotorFeedbackGetter::get().current)) + 'A'; return line; } };
+        struct ChopsText : public virtual TextInterface { public: String text() const override { auto line = String{"chops: "}; if (controller::get().feedbackValid) line += toString(MotorFeedbackGetter::get().chops); return line; } };
+        struct HallText : public virtual TextInterface { public: String text() const override { auto line = String{"hall: "}; if (controller::get().feedbackValid) line += hallString(MotorFeedbackGetter::get()); return line; } };
     };
 
-    struct RightFeedback
-    {
-        RightFeedback() = delete;
-        ~RightFeedback() = delete;
-
-        struct AngleText : public virtual TextInterface { public: String text() const override { auto line = String{"angle: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.right.angle); return line; } };
-        struct SpeedText : public virtual TextInterface { public: String text() const override { auto line = String{"speed: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.right.speed); return line; } };
-        struct SpeedKmhText : public virtual TextInterface { public: String text() const override { auto line = String{"speed kmh: "}; if (controller::get().feedbackValid) line += toString(convertToKmh(controller::get().feedback.right.speed)); return line; } };
-        struct ErrorText : public virtual TextInterface { public: String text() const override { auto line = String{"error: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.right.error); return line; } };
-        struct CurrentText : public virtual TextInterface { public: String text() const override { auto line = String{"current: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.right.current); return line; } };
-        struct CurrentFixedText : public virtual TextInterface { public: String text() const override { auto line = String{"current: "}; if (controller::get().feedbackValid) line += toString(fixCurrent(controller::get().feedback.right.current)) + 'A'; return line; } };
-        struct ChopsText : public virtual TextInterface { public: String text() const override { auto line = String{"chops: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.right.chops); return line; } };
-        struct HallText : public virtual TextInterface { public: String text() const override { auto line = String{"hall: "}; if (controller::get().feedbackValid) line += hallString(controller::get().feedback.right); return line; } };
-    };
+public:
+    using LeftFeedback = FeedbackTexts<LeftFeedbackGetter>;
+    using RightFeedback = FeedbackTexts<RightFeedbackGetter>;
 };
 
 using FrontTexts = ControllerTexts<FrontControllerGetter>;
diff --git a/src/displays/menus/defaultmodesettingsmenu.h b/src/displays/menus/defaultmodesettingsmenu.h
index 538b52b..aba50a7 100644
--- a/src/displays/menus/defaultmodesettingsmenu.h
+++ b/src/displays/menus/defaultmodesettingsmenu.h
@@ -88,6 +88,8 @@ class DefaultModeSettingsMenu :
     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>>,
diff --git a/src/displays/menus/mainmenu.h b/src/displays/menus/mainmenu.h
index 753184f..e1374ef 100644
--- a/src/displays/menus/mainmenu.h
+++ b/src/displays/menus/mainmenu.h
@@ -4,6 +4,7 @@
 #include "staticmenudefinition.h"
 #include "menuitem.h"
 #include "actions/switchscreenaction.h"
+#include "actions/modesettingsaction.h"
 #include "actions/rebootaction.h"
 #include "texts.h"
 #include "icons/back.h"
@@ -37,22 +38,23 @@ class MainMenu :
     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_PRESETS>,     SwitchScreenAction<PresetsMenu>, StaticMenuItemIcon<&icons::presets>>,
-        makeComponent<MenuItem, StaticText<TEXT_GRAPHS>,      SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&icons::graph>>,
+        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_GRAPHS>,       SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&icons::graph>>,
 #ifdef FEATURE_BMS
-        makeComponent<MenuItem, StaticText<TEXT_BMS>,         SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&icons::bms>>,
+        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>>,
+        makeComponent<MenuItem, StaticText<TEXT_SETTINGS>,     SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::settings>>,
+        makeComponent<MenuItem, StaticText<TEXT_LOCKVEHICLE>,  SwitchScreenAction<Lockscreen>, StaticMenuItemIcon<&icons::lock>>,
 #ifdef FEATURE_MOSFETS
-        makeComponent<MenuItem, StaticText<TEXT_MOSFETS>,     SwitchScreenAction<MosfetsMenu>, StaticMenuItemIcon<&icons::lock>>, // TODO icon
+        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>>
+        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>>
     >
 {};
 };
diff --git a/src/displays/menus/presetsmenu.h b/src/displays/menus/presetsmenu.h
index 6ee8b46..8c28979 100644
--- a/src/displays/menus/presetsmenu.h
+++ b/src/displays/menus/presetsmenu.h
@@ -17,53 +17,59 @@ class MainMenu;
 }
 
 namespace {
-template<const Settings *preset>
 class ApplyPresetAction : public virtual ActionInterface
 {
 public:
-    void triggered() override { settings = *preset; saveSettings(); }
+    void triggered() override { saveSettings(); switchScreen<MainMenu>(); }
+};
+
+template<const Settings *preset>
+class ApplySettingsPresetAction : public virtual ApplyPresetAction
+{
+public:
+    void triggered() override { settings = *preset; ApplyPresetAction::triggered(); }
 };
 
 template<const Settings::Limits *preset>
-class ApplyLimitsPresetAction : public virtual ActionInterface
+class ApplyLimitsPresetAction : public virtual ApplyPresetAction
 {
 public:
-    void triggered() override { settings.limits = *preset; saveSettings(); }
+    void triggered() override { settings.limits = *preset; ApplyPresetAction::triggered(); }
 };
 
 template<const Settings::ControllerHardware *preset>
-class ApplyControllerHardwarePresetAction : public virtual ActionInterface
+class ApplyControllerHardwarePresetAction : public virtual ApplyPresetAction
 {
 public:
-    void triggered() override { settings.controllerHardware = *preset; saveSettings(); }
+    void triggered() override { settings.controllerHardware = *preset; ApplyPresetAction::triggered(); }
 };
 
 template<const Settings::BoardcomputerHardware *preset>
-class ApplyBoardcomputerHardwarePresetAction : public virtual ActionInterface
+class ApplyBoardcomputerHardwarePresetAction : public virtual ApplyPresetAction
 {
 public:
-    void triggered() override { settings.boardcomputerHardware = *preset; saveSettings(); }
+    void triggered() override { settings.boardcomputerHardware = *preset; ApplyPresetAction::triggered(); }
 };
 
 template<const Settings::DefaultMode *preset>
-class ApplyDefaultModePresetAction : public virtual ActionInterface
+class ApplyDefaultModePresetAction : public virtual ApplyPresetAction
 {
 public:
-    void triggered() override { settings.defaultMode = *preset; saveSettings(); }
+    void triggered() override { settings.defaultMode = *preset; ApplyPresetAction::triggered(); }
 };
 
 template<const Settings::TempomatMode *preset>
-class ApplyTempomatModePresetAction : public virtual ActionInterface
+class ApplyTempomatModePresetAction : public virtual ApplyPresetAction
 {
 public:
-    void triggered() override { settings.tempomatMode = *preset; saveSettings(); }
+    void triggered() override { settings.tempomatMode = *preset; ApplyPresetAction::triggered(); }
 };
 
 template<const Settings::LarsmMode *preset>
-class ApplyLarsmModePresetAction : public virtual ActionInterface
+class ApplyLarsmModePresetAction : public virtual ApplyPresetAction
 {
 public:
-    void triggered() override { settings.larsmMode = *preset; saveSettings(); }
+    void triggered() override { settings.larsmMode = *preset; ApplyPresetAction::triggered(); }
 };
 
 class PresetsMenu :
@@ -71,7 +77,7 @@ class PresetsMenu :
     public StaticText<TEXT_PRESETS>,
     public BackActionInterface<SwitchScreenAction<MainMenu>>,
     public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_DEFAULTEVERYTHING>,            ApplyPresetAction<&presets::defaultSettings>>,
+        makeComponent<MenuItem, StaticText<TEXT_DEFAULTEVERYTHING>,            ApplySettingsPresetAction<&presets::defaultSettings>>,
         makeComponent<MenuItem, StaticText<TEXT_DEFAULTLIMITS>,                ApplyLimitsPresetAction<&presets::defaultLimits>>,
         makeComponent<MenuItem, StaticText<TEXT_KIDSLIMITS>,                   ApplyLimitsPresetAction<&presets::kidsLimits>>,
         makeComponent<MenuItem, StaticText<TEXT_DEFAULTCONTROLLERHARDWARE>,    ApplyControllerHardwarePresetAction<&presets::defaultControllerHardware>>,
diff --git a/src/displays/menus/wifiscanmenu.h b/src/displays/menus/wifiscanmenu.h
index 09985ec..7ca7666 100644
--- a/src/displays/menus/wifiscanmenu.h
+++ b/src/displays/menus/wifiscanmenu.h
@@ -30,6 +30,24 @@ public:
     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)
diff --git a/src/feedbackparser.h b/src/feedbackparser.h
index b9a979a..037958e 100644
--- a/src/feedbackparser.h
+++ b/src/feedbackparser.h
@@ -24,7 +24,7 @@ public:
         while (m_serial.get().available())
         {
             m_incomingByte    = m_serial.get().read();                                // Read the incoming byte
-            m_bufStartFrame = ((uint16_t)(m_incomingBytePrev) << 8) +  m_incomingByte; // Construct the start frame
+            m_bufStartFrame = ((uint16_t)(m_incomingBytePrev) << 8) + m_incomingByte; // Construct the start frame
 
             //Serial.printf("received: %x\r\n", m_incomingByte);
 
diff --git a/src/globals.h b/src/globals.h
index 50fd733..3cba3d0 100644
--- a/src/globals.h
+++ b/src/globals.h
@@ -37,19 +37,14 @@ public:
         std::array<Controller, 2>{{
             Controller{Serial1, settings.controllerHardware.enableFrontLeft, settings.controllerHardware.enableFrontRight, settings.controllerHardware.invertFrontLeft, settings.controllerHardware.invertFrontRight},
             Controller{Serial2, settings.controllerHardware.enableBackLeft, settings.controllerHardware.enableBackRight, settings.controllerHardware.invertBackLeft, settings.controllerHardware.invertBackRight}
-        }},
-        front{getFront()},
-        back(getBack())
+        }}
     {}
+
     Controllers(const Controllers &) = delete;
     Controllers &operator=(const Controllers &) = delete;
 
-    Controller &front;
-    Controller &back;
-
-private:
-    Controller &getFront() { return operator[](0); }
-    Controller &getBack() { return operator[](1); }
+    Controller &front{operator[](0)};
+    Controller &back{operator[](1)};
 };
 
 Controllers controllers;
diff --git a/src/menudefinitioninterface.h b/src/menudefinitioninterface.h
index 6e6ebe6..cc08847 100644
--- a/src/menudefinitioninterface.h
+++ b/src/menudefinitioninterface.h
@@ -8,6 +8,11 @@ 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;
 };
diff --git a/src/menudisplay.h b/src/menudisplay.h
index b522330..84826a3 100644
--- a/src/menudisplay.h
+++ b/src/menudisplay.h
@@ -24,8 +24,6 @@ public:
     void rotate(int offset) override;
     void confirm() override;
 
-    virtual void itemPressed(int index);
-
     TextInterface *asTextInterface() override { return this; }
     const TextInterface *asTextInterface() const override { return this; }
 
@@ -104,11 +102,7 @@ void MenuDisplay::update()
         const auto offset = m_rotateOffset;
         m_rotateOffset = 0;
 
-        const auto itemCount = [&](){
-            int i{0};
-            runForEveryMenuItem([&](MenuItem&){ i++; });
-            return i;
-        }();
+        const auto itemCount = size();
 
         if (itemCount)
         {
@@ -141,7 +135,7 @@ void MenuDisplay::update()
     {
         m_pressed = false;
         if (m_selectedIndex >= 0)
-            itemPressed(m_selectedIndex);
+            getMenuItem(m_selectedIndex).triggered();
     }
 }
 
@@ -246,14 +240,4 @@ void MenuDisplay::confirm()
 {
     m_pressed = true;
 }
-
-void MenuDisplay::itemPressed(int index)
-{
-    int i{0};
-
-    runForEveryMenuItem([&](MenuItem &item){
-        if (i++ == index)
-            item.triggered();
-    });
-}
 }
diff --git a/src/modes/defaultmode.h b/src/modes/defaultmode.h
index 99ab987..f4756e4 100644
--- a/src/modes/defaultmode.h
+++ b/src/modes/defaultmode.h
@@ -38,7 +38,6 @@ void DefaultMode::update()
         else
             gas = 0;
     }
-    const auto gas_squared = (gas * gas) / 1000;
 
     if (waitForBremsLoslass)
     {
@@ -47,14 +46,16 @@ void DefaultMode::update()
         else
             brems = 0;
     }
-    const auto brems_squared = (brems * brems) / 1000;
+
+    const auto gas_processed = settings.defaultMode.squareGas ? (gas * gas) / 1000.f : gas;
+    const auto brems_processed = settings.defaultMode.squareBrems ? (brems * brems) / 1000 : brems;
 
     const auto now = millis();
 
     float pwm;
-    if (gas_squared >= settings.defaultMode.add_schwelle)
+    if (gas_processed >= settings.defaultMode.add_schwelle)
     {
-        pwm = (gas_squared/1000.*settings.defaultMode.gas1_wert) + (brems_squared/1000.*settings.defaultMode.brems1_wert);
+        pwm = (gas_processed/1000.*settings.defaultMode.gas1_wert) + (brems_processed/1000.*settings.defaultMode.brems1_wert);
 
         if (settings.defaultMode.enableSmoothing && (pwm > 1000. || lastPwm > 1000.))
         {
@@ -71,7 +72,7 @@ void DefaultMode::update()
         }
     }
     else
-        pwm = (gas_squared/1000.*settings.defaultMode.gas2_wert) - (brems_squared/1000.*settings.defaultMode.brems2_wert);
+        pwm = (gas_processed/1000.*settings.defaultMode.gas2_wert) - (brems_processed/1000.*settings.defaultMode.brems2_wert);
 
     lastPwm = pwm;
     lastTime = now;
diff --git a/src/presets.h b/src/presets.h
index a37da5f..0e5d61c 100644
--- a/src/presets.h
+++ b/src/presets.h
@@ -107,6 +107,8 @@ constexpr Settings::BoardcomputerHardware defaultBoardcomputerHardware {
 
 constexpr Settings::DefaultMode defaultDefaultMode {
     .modelMode = UnifiedModelMode::FocTorque,
+    .squareGas = true,
+    .squareBrems = true,
     .enableSmoothing = true,
     .smoothing = 20,
     .frontPercentage = 100,
@@ -120,6 +122,8 @@ constexpr Settings::DefaultMode defaultDefaultMode {
 
 constexpr Settings::DefaultMode sinusoidalDefaultMode {
     .modelMode = UnifiedModelMode::Sinusoidal,
+    .squareGas = true,
+    .squareBrems = true,
     .enableSmoothing = true,
     .smoothing = 20,
     .frontPercentage = 100,
diff --git a/src/settings.h b/src/settings.h
index b26902b..447b1f7 100644
--- a/src/settings.h
+++ b/src/settings.h
@@ -72,6 +72,8 @@ struct Settings
 
     struct DefaultMode {
         UnifiedModelMode modelMode;
+        bool squareGas;
+        bool squareBrems;
         bool enableSmoothing;
         int16_t smoothing;
         int16_t frontPercentage;
diff --git a/src/settingsaccessors.h b/src/settingsaccessors.h
index a619c6f..e130259 100644
--- a/src/settingsaccessors.h
+++ b/src/settingsaccessors.h
@@ -83,6 +83,8 @@ struct DisplayUpdateRateAccessor : public RefAccessorSaveSettings<int16_t> { int
 struct DisplayRedrawRateAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.boardcomputerHardware.timersSettings.displayRedrawRate; } };
 
 struct DefaultModeModelModeAccessor : public RefAccessorSaveSettings<UnifiedModelMode> { UnifiedModelMode &getRef() const override { return settings.defaultMode.modelMode; } };
+struct DefaultModeSquareGasAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.defaultMode.squareGas; } };
+struct DefaultModeSquareBremsAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.defaultMode.squareBrems; } };
 struct DefaultModeEnableSmoothingAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.defaultMode.enableSmoothing; } };
 struct DefaultModeSmoothingAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.defaultMode.smoothing; } };
 struct DefaultModeFrontPercentageAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.defaultMode.frontPercentage; } };
diff --git a/src/staticmenudefinition.h b/src/staticmenudefinition.h
index 6f3d189..83143ef 100644
--- a/src/staticmenudefinition.h
+++ b/src/staticmenudefinition.h
@@ -10,6 +10,24 @@ 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);
@@ -30,6 +48,24 @@ class StaticMenuDefinition<T, Tmore...> : public virtual StaticMenuDefinition<Tm
     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);
diff --git a/src/texts.h b/src/texts.h
index f62ea92..196e66c 100644
--- a/src/texts.h
+++ b/src/texts.h
@@ -54,6 +54,7 @@ constexpr char TEXT_BACKRIGHTFEEDBACK[] = "Back right feedback";
 constexpr char TEXT_MAINMENU[] = "Main menu";
 constexpr char TEXT_STATUS[] = "Status";
 constexpr char TEXT_SELECTMODE[] = "Select mode";
+constexpr char TEXT_MODESETTINGS[] = "Mode settings";
 constexpr char TEXT_PRESETS[] = "Presets";
 constexpr char TEXT_GRAPHS[] = "Graphs";
 //constexpr char TEXT_BMS[] = "BMS";
@@ -140,6 +141,8 @@ constexpr char TEXT_DYNAMICMENU[] = "Dynamic menu";
 //DefaultModeSettingsMenu
 //constexpr char TEXT_DEFAULTMODESETTINGS[] = "Default mode settings";
 constexpr char TEXT_SETMODELMODE[] = "Set model mode";
+constexpr char TEXT_SQUAREGAS[] = "Square gas";
+constexpr char TEXT_SQUAREBREMS[] = "Square brems";
 constexpr char TEXT_ENABLESMOOTHING[] = "Enable smoothing";
 constexpr char TEXT_SETSMOOTHING[] = "Set smoothing";
 constexpr char TEXT_SETFRONTPERCENTAGE[] = "Set front percentage";
diff --git a/src/utils.h b/src/utils.h
index 193ff93..3451039 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <algorithm>
+#include <utility>
 
 #include <ArduinoOTA.h>
 #include <WString.h>
@@ -22,6 +23,17 @@ template<typename ...T>
 class makeComponent : public T...
 {};
 
+template <typename T1, typename T2, typename ...T3>
+class makeComponentArgs : public T1, public T2, public T3...
+{
+public:
+    template<typename ...T>
+    makeComponentArgs(T&& ...args) :
+        T2{std::forward<T>(args)...}
+    {
+    }
+};
+
 template<typename T>
 T scaleBetween(T x, T in_min, T in_max, T out_min, T out_max) {
     if (x < std::min(in_min, in_max))