feedc0de/bobbycar-boardcomputer-firmware
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Checkboxes now show an error message if saving fails

Browse Source
This commit is contained in:
0xFEEDC0DE64
2021-12-30 00:57:53 +01:00
parent 81701b4096
commit d5b9c1142f
36 changed files with 414 additions and 361 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
components/esp-gui-lib

Submodule components/esp-gui-lib updated: c5933152e1...8914f2cc3b

1
main/CMakeLists.txt
View File

@ -8,6 +8,7 @@ set(headers
bluetoothtexthelpers.h
bmsutils.h
bobbybuttons.h
bobbycheckbox.h
bobbyerrorhandler.h
buildserver.h
buttons.h

1
main/accessors/wifistaconfigaccessors.h
View File

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

15
main/bobbycheckbox.h Normal file
View File

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

5
main/displays/calibratevoltagedisplay.cpp
View File

@ -2,12 +2,11 @@
// 3rdparty lib includes
#include <fmt/core.h>
#include <actions/toggleboolaction.h>
#include <checkboxicon.h>
// local includes
#include "displays/menus/batterymenu.h"
#include "accessors/settingsaccessors.h"
#include "bobbycheckbox.h"
namespace {
class Save30VCalibrationAction : public virtual espgui::ActionInterface
@ -63,7 +62,7 @@ CalibrateVoltageDisplay::CalibrateVoltageDisplay()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGECALIBRATION_30V>, Save30VCalibrationAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGECALIBRATION_50V>, Save50VCalibrationAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_APPLYCALIB>, ToggleBoolAction, CheckboxIcon, BatteryApplyCalibrationAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_APPLYCALIB>, BobbyCheckbox, BatteryApplyCalibrationAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<BatteryMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>>();

13
main/displays/menus/blesettingsmenu.cpp
View File

@ -1,14 +1,15 @@
#include "blesettingsmenu.h"
// 3rdparty lib includes
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
#include "icons/back.h"
// local includes
#include "accessors/settingsaccessors.h"
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "bletexthelpers.h"
#include "checkboxicon.h"
#include "displays/menus/settingsmenu.h"
#include "icons/back.h"
#include "bobbycheckbox.h"
#include "texts.h"
#ifdef FEATURE_BLE
@ -17,7 +18,7 @@ using namespace espgui;
BleSettingsMenu::BleSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLEENABLED>, ToggleBoolAction, CheckboxIcon, BleEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLEENABLED>, BobbyCheckbox, BleEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, BleServerPeerDevicesText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, BleCharacSubscribedText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();

2
main/displays/menus/boardcomputerhardwaresettingsmenu.cpp
View File

@ -5,9 +5,7 @@
#include <changevaluedisplay.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <actions/toggleboolaction.h>
#include <icons/back.h>
#include <checkboxicon.h>
#include <textwithvaluehelper.h>
// local includes

5
main/displays/menus/buzzermenu.cpp
View File

@ -4,8 +4,6 @@
#include "changevaluedisplay.h"
#include "menuitem.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "checkboxicon.h"
#include "icons/back.h"
// local includes
@ -14,6 +12,7 @@
#include "globals.h"
#include "accessors/settingsaccessors.h"
#include "displays/menus/settingsmenu.h"
#include "bobbycheckbox.h"
namespace {
struct FrontFreqAccessor : public espgui::RefAccessor<uint8_t> { uint8_t &getRef() const override { return controllers.front.command.buzzer.freq; } };
@ -90,7 +89,7 @@ BuzzerMenu::BuzzerMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTPATTERN>, SwitchScreenAction<FrontPatternChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKFREQ>, SwitchScreenAction<BackFreqChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKPATTERN>, SwitchScreenAction<BackPatternChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEP>, ToggleBoolAction, CheckboxIcon, ReverseBeepAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEP>, BobbyCheckbox, ReverseBeepAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ0>, SwitchScreenAction<ReverseBeepFreq0ChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ1>, SwitchScreenAction<ReverseBeepFreq1ChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPDURATION0>, SwitchScreenAction<ReverseBeepDuration0ChangeScreen>>>();

5
main/displays/menus/cloudsettingsmenu.cpp
View File

@ -5,9 +5,7 @@
#include "menuitem.h"
#include "changevaluedisplay.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "actions/dummyaction.h"
#include "checkboxicon.h"
#include "icons/back.h"
// local includes
@ -16,6 +14,7 @@
#include "accessors/settingsaccessors.h"
#include "cloud.h"
#include "displays/menus/settingsmenu.h"
#include "bobbycheckbox.h"
#ifdef FEATURE_CLOUD
namespace {
@ -58,7 +57,7 @@ using namespace espgui;
CloudSettingsMenu::CloudSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CLOUDENABLED>, ToggleBoolAction, CheckboxIcon, CloudEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CLOUDENABLED>, BobbyCheckbox, CloudEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CLOUDTRANSMITTIMEOUT>, SwitchScreenAction<CloudTransmitTimeoutChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, CloudCreatedText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, CloudStartedText, DisabledColor, DummyAction>>();

14
main/displays/menus/commanddebugmenu.h
View File

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

9
main/displays/menus/controllerhardwaresettingsmenu.cpp
View File

@ -5,9 +5,7 @@
// 3rdparty lib includes
#include "changevaluedisplay.h"
#include "actions/toggleboolaction.h"
#include "actions/switchscreenaction.h"
#include "checkboxicon.h"
#include "icons/back.h"
// local includes
@ -18,6 +16,7 @@
#include "displays/menus/enablemenu.h"
#include "displays/menus/invertmenu.h"
#include "displays/menus/settingsmenu.h"
#include "bobbycheckbox.h"
namespace {
using WheelDiameterMmChangeScreen = espgui::makeComponent<
@ -69,10 +68,10 @@ ControllerHardwareSettingsMenu::ControllerHardwareSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERMM>, SwitchScreenAction<WheelDiameterMmChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERINCH>, SwitchScreenAction<WheelDiameterInchChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_NUMMAGNETPOLES>, SwitchScreenAction<NumMagnetPolesChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SWAPFRONTBACK>, ToggleBoolAction, CheckboxIcon, SwapFrontBackAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SWAPFRONTBACK>, BobbyCheckbox, SwapFrontBackAccessor>>();
#ifdef FEATURE_CAN
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTSENDCAN>, ToggleBoolAction, CheckboxIcon, SendFrontCanCmdAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKSENDCAN>, ToggleBoolAction, CheckboxIcon, SendBackCanCmdAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTSENDCAN>, BobbyCheckbox, SendFrontCanCmdAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKSENDCAN>, BobbyCheckbox, SendBackCanCmdAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CANTRANSMITTIMEOUT>, SwitchScreenAction<CanTransmitTimeoutChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CANRECEIVETIMEOUT>, SwitchScreenAction<CanReceiveTimeoutChangeScreen>>>();
#endif

55
main/displays/menus/debugmenu.cpp
View File

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

17
main/displays/menus/defaultmodesettingsmenu.cpp
View File

@ -3,10 +3,8 @@
// 3rdparty lib includes
#include <changevaluedisplay.h>
#include <menuitem.h>
#include <actions/toggleboolaction.h>
#include <actions/switchscreenaction.h>
#include <actions/dummyaction.h>
#include <checkboxicon.h>
#include <icons/back.h>
#include <textwithvaluehelper.h>
@ -17,6 +15,7 @@
#include "accessors/settingsaccessors.h"
#include "displays/menus/handbremssettingsmenu.h"
#include "displays/menus/modessettingsmenu.h"
#include "bobbycheckbox.h"
namespace {
using DefaultModeModelModeChangeDisplay = espgui::makeComponent<
@ -120,13 +119,13 @@ DefaultModeSettingsMenu::DefaultModeSettingsMenu()
if (diff < 20) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LIMITS_TO_NEAR>, StaticFont<2>, StaticColor<TFT_RED>, DummyAction>>(); }
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MODELMODE>, SwitchScreenAction<DefaultModeModelModeChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HYBRIDMODE>, SwitchScreenAction<DefaultModeHybridModelModeChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREGAS>, ToggleBoolAction, CheckboxIcon, DefaultModeSquareGasAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREBREMS>, ToggleBoolAction, CheckboxIcon, DefaultModeSquareBremsAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHINGUP>, ToggleBoolAction, CheckboxIcon, DefaultModeEnableSmoothingUpAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHINGDOWN>, ToggleBoolAction, CheckboxIcon, DefaultModeEnableSmoothingDownAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFWSMOOTHINGUP>, ToggleBoolAction, CheckboxIcon, DefaultModeEnableFieldWeakSmoothingUpAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFWSMOOTHINGDOWN>, ToggleBoolAction, CheckboxIcon, DefaultModeEnableFieldWeakSmoothingDownAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HYBRIDENABLE>, ToggleBoolAction, CheckboxIcon, DefaultModeEnableHybridAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREGAS>, BobbyCheckbox, DefaultModeSquareGasAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREBREMS>, BobbyCheckbox, DefaultModeSquareBremsAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHINGUP>, BobbyCheckbox, DefaultModeEnableSmoothingUpAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHINGDOWN>, BobbyCheckbox, DefaultModeEnableSmoothingDownAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFWSMOOTHINGUP>, BobbyCheckbox, DefaultModeEnableFieldWeakSmoothingUpAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFWSMOOTHINGDOWN>, BobbyCheckbox, DefaultModeEnableFieldWeakSmoothingDownAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HYBRIDENABLE>, BobbyCheckbox, DefaultModeEnableHybridAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE>, SwitchScreenAction<HandbremsSettingsMenu>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_FWSMOOTHING_LIMIT, DefaultModeEnableFieldWeakSmoothingLowerLimitAccessor>, SwitchScreenAction<DefaultModeFwSmoothingLowerLimitChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_SMOOTHINGVAL, DefaultModeSmoothingAccessor>, SwitchScreenAction<DefaultModeSmoothingChangeDisplay>>>();

203
main/displays/menus/dynamicdebugmenu.cpp
View File

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

148
main/displays/menus/dynamicdebugmenu.h
View File

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

19
main/displays/menus/enablemenu.cpp
View File

@ -1,19 +1,20 @@
#include "enablemenu.h"
// local includes
#include "accessors/settingsaccessors.h"
// 3rdparty lib includes
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "checkboxicon.h"
#include "displays/menus/controllerhardwaresettingsmenu.h"
#include "icons/back.h"
// local includes
#include "displays/menus/controllerhardwaresettingsmenu.h"
#include "accessors/settingsaccessors.h"
#include "bobbycheckbox.h"
EnableMenu::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_ENABLEFRONTLEFT>, BobbyCheckbox, FrontLeftEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTRIGHT>, BobbyCheckbox, FrontRightEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKLEFT>, BobbyCheckbox, BackLeftEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKRIGHT>, BobbyCheckbox, BackRightEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}

10
main/displays/menus/espnowmenu.cpp
View File

@ -1,15 +1,17 @@
#include "espnowmenu.h"
#ifdef FEATURE_ESPNOW
// 3rdparty lib includes
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "checkboxicon.h"
#include "icons/back.h"
// local includes
#include "icons/settings.h"
#include "icons/time.h"
#include "displays/menus/espnowsettingsmenu.h"
#include "displays/menus/settingsmenu.h"
#include "bobbycheckbox.h"
using namespace espgui;
@ -18,8 +20,8 @@ namespace espnowmenu {
EspNowMenu::EspNowMenu() {
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SENDTSMSG>, espnowmenu::SendBobbycarTimesyncMessageAction, StaticMenuItemIcon<&bobbyicons::time>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETS>, ToggleBoolAction, CheckboxIcon, espnowmenu::ReceiveTimeStampAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETSFROMBOBBY>, ToggleBoolAction, CheckboxIcon, espnowmenu::ReceiveTsFromOtherBobbycarsAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETS>, BobbyCheckbox, espnowmenu::ReceiveTimeStampAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETSFROMBOBBY>, BobbyCheckbox, espnowmenu::ReceiveTsFromOtherBobbycarsAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SETTINGS>, SwitchScreenAction<EspNowSettingsMenu>, StaticMenuItemIcon<&bobbyicons::settings>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}

14
main/displays/menus/espnowsettingsmenu.cpp
View File

@ -1,14 +1,16 @@
#include "espnowsettingsmenu.h"
#ifdef FEATURE_ESPNOW
#include "accessors/settingsaccessors.h"
// 3rdparty lib includes
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "checkboxicon.h"
#include "icons/back.h"
// local includes
#include "accessors/settingsaccessors.h"
#include "icons/time.h"
#include "espnowmenu.h"
#include "bobbycheckbox.h"
using namespace espgui;
@ -16,9 +18,9 @@ namespace espnowsettingsmenu {
} // namespace
EspNowSettingsMenu::EspNowSettingsMenu() {
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCTIME>, ToggleBoolAction, CheckboxIcon, ESPNowSyncTimeEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCWITHOTHERS>, ToggleBoolAction, CheckboxIcon, ESPNowSyncTimeWithOthersEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCBLINK>, ToggleBoolAction, CheckboxIcon, ESPNowSyncBlinkEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCTIME>, BobbyCheckbox, ESPNowSyncTimeEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCWITHOTHERS>, BobbyCheckbox, ESPNowSyncTimeWithOthersEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCBLINK>, BobbyCheckbox, ESPNowSyncBlinkEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<EspNowMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}

14
main/displays/menus/feedbackdebugmenu.h
View File

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

11
main/displays/menus/greenpassmenu.cpp
View File

@ -6,18 +6,17 @@
// 3rdparty lib includes
#include <fmt/core.h>
#include "actions/switchscreenaction.h"
#include "actions/dummyaction.h"
#include "icons/back.h"
// local includes
#include "actions/switchscreenaction.h"
#include "actions/qraction.h"
#include "actions/dummyaction.h"
#include "actions/toggleboolaction.h"
#include "displays/menus/mainmenu.h"
#include "displays/qrdisplay.h"
#include "displays/qrimportdisplay.h"
#include "icons/back.h"
#include "checkboxicon.h"
#include "qrimport.h"
#include "bobbycheckbox.h"
using namespace espgui;
@ -84,7 +83,7 @@ GreenPassMenu::GreenPassMenu()
constructMenuItem<makeComponentArgs<MenuItem, SwitchQrImportDisplayAction, StaticText<TEXT_ADDCERT>>>(nvs_key);
}
}
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DELCERT>, ToggleBoolAction, CheckboxIcon, DeleteModeAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DELCERT>, BobbyCheckbox, DeleteModeAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}

9
main/displays/menus/handbremssettingsmenu.cpp
View File

@ -3,9 +3,7 @@
// 3rd party libs
#include <fmt/core.h>
#include <actions/switchscreenaction.h>
#include <actions/toggleboolaction.h>
#include <changevaluedisplay.h>
#include <checkboxicon.h>
#include <icons/back.h>
#include <textwithvaluehelper.h>
@ -15,6 +13,7 @@
#include "changevaluedisplay_handbremsmode.h"
#include "displays/menus/defaultmodesettingsmenu.h"
#include "texts.h"
#include "bobbycheckbox.h"
namespace {
using HandBremsTriggerTimeoutChangeValueDisplay = espgui::makeComponent<
@ -44,9 +43,9 @@ public:
HandbremsSettingsMenu::HandbremsSettingsMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_ENABLE>, ToggleBoolAction, CheckboxIcon, HandbremsEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_AUTOMATIC>, ToggleBoolAction, CheckboxIcon, HandbremsAutomaticAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_VISUALIZE>, ToggleBoolAction, CheckboxIcon, HandbremsVisualizeAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_ENABLE>, BobbyCheckbox, HandbremsEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_AUTOMATIC>, BobbyCheckbox, HandbremsAutomaticAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_VISUALIZE>, BobbyCheckbox, HandbremsVisualizeAccessor>>();
constructMenuItem<makeComponent<MenuItem, HandBremsModeText, SwitchScreenAction<HandBremsModeChangeValueDisplay>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_HANDBREMSE_TRIGGERTIMEOUT, HandbremsTimeoutAccessor>, SwitchScreenAction<HandBremsTriggerTimeoutChangeValueDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DefaultModeSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();

17
main/displays/menus/invertmenu.cpp
View File

@ -1,20 +1,21 @@
#include "invertmenu.h"
// 3rdparty lib includes
#include "actions/switchscreenaction.h"
#include "icons/back.h"
// local includes
#include "accessors/settingsaccessors.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "checkboxicon.h"
#include "displays/menus/controllerhardwaresettingsmenu.h"
#include "icons/back.h"
#include "bobbycheckbox.h"
InvertMenu::InvertMenu()
{
using namespace espgui;
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_INVERTFRONTLEFT>, BobbyCheckbox, FrontLeftInvertedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTRIGHT>, BobbyCheckbox, FrontRightInvertedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKLEFT>, BobbyCheckbox, BackLeftInvertedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKRIGHT>, BobbyCheckbox, BackRightInvertedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}

15
main/displays/menus/ledstripmenu.cpp
View File

@ -5,9 +5,7 @@
#include <FastLED.h>
#include <actioninterface.h>
#include <actions/switchscreenaction.h>
#include <actions/toggleboolaction.h>
#include <changevaluedisplay.h>
#include <checkboxicon.h>
#include <icons/back.h>
#include <menuitem.h>
#include <textwithvaluehelper.h>
@ -22,6 +20,7 @@
#include "ledstrip.h"
#include "ledstripselectanimationmenu.h"
#include "ledstripselectblinkmenu.h"
#include "bobbycheckbox.h"
// clang-format off
@ -115,13 +114,13 @@ LedstripMenu::LedstripMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIPCOLORMENU>, espgui::SwitchScreenAction<LedstripColorsDisplay>>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDANIMATION>, ToggleBoolAction, CheckboxIcon, EnableLedAnimationAccessor>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BRAKELIGHTS>, ToggleBoolAction, CheckboxIcon, EnableBrakeLightsAccessor>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BLINKBEEP>, ToggleBoolAction, CheckboxIcon, EnableBeepWhenBlinkAccessor>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_FULLBLINK>, ToggleBoolAction, CheckboxIcon, EnableFullBlinkAccessor>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDANIMATION>, BobbyCheckbox, EnableLedAnimationAccessor>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BRAKELIGHTS>, BobbyCheckbox, EnableBrakeLightsAccessor>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BLINKBEEP>, BobbyCheckbox, EnableBeepWhenBlinkAccessor>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_FULLBLINK>, BobbyCheckbox, EnableFullBlinkAccessor>>();
if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_STVO>, ToggleBoolAction, CheckboxIcon, EnableLedstripStVOAccessor>>(); }
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_STVO_ENABLEFRONTLIGHT>, ToggleBoolAction, CheckboxIcon, EnableLedstripStVOFrontlight>>();
if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_STVO>, BobbyCheckbox, EnableLedstripStVOAccessor>>(); }
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_STVO_ENABLEFRONTLIGHT>, BobbyCheckbox, EnableLedstripStVOFrontlight>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_ALLCUSTOMOFF>, AllCustomLedsOffAction>>();
if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_STVO_FRONTOFFSET, LedsStVOFrontOffsetAccessor>, espgui::SwitchScreenAction<StVOOffsetChangeScreen>>>(); }
if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_STVO_FRONTLENGTH, LedsStVOFrontLengthAccessor>, espgui::SwitchScreenAction<StVOLengthChangeScreen>>>(); }

16
main/displays/menus/ledstripselectblinkmenu.cpp
View File

@ -1,16 +1,18 @@
#include "ledstripselectblinkmenu.h"
#ifdef FEATURE_LEDSTRIP
// Local includes
#include "accessors/settingsaccessors.h"
// 3rdparty lib includes
#include "actions/dummyaction.h"
#include "actions/ledstripblinkactions.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "checkboxicon.h"
#include "displays/menus/ledstripmenu.h"
#include "icons/back.h"
// local includes
#include "accessors/settingsaccessors.h"
#include "actions/ledstripblinkactions.h"
#include "displays/menus/ledstripmenu.h"
#include "bobbycheckbox.h"
using namespace espgui;
std::string currentSelectedBlinkAnimationText::text() const {
@ -42,7 +44,7 @@ LedstripSelectBlinkMenu::LedstripSelectBlinkMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ANIMATION_BLINKLEFT>, LedstripAnimationBlinkLeftAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ANIMATION_BLINKRIGHT>, LedstripAnimationBlinkRightAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ANIMATION_BLINKBOTH>, LedstripAnimationBlinkBothAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LEDSTRIP_EN_BLINK_ANIM>, ToggleBoolAction, CheckboxIcon, LedstripEnableBlinkAnimationAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LEDSTRIP_EN_BLINK_ANIM>, BobbyCheckbox, LedstripEnableBlinkAnimationAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<LedstripMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}

7
main/displays/menus/lockscreensettingsmenu.cpp
View File

@ -2,10 +2,8 @@
// 3rdparty lib includes
#include <menuitem.h>
#include <actions/toggleboolaction.h>
#include <actions/switchscreenaction.h>
#include <icons/back.h>
#include <checkboxicon.h>
#include <changevaluedisplay.h>
#include <textwithvaluehelper.h>
@ -14,6 +12,7 @@
#include "globals.h"
#include "accessors/settingsaccessors.h"
#include "displays/menus/boardcomputerhardwaresettingsmenu.h"
#include "bobbycheckbox.h"
namespace {
using LockscreenPinDigit0ChangeScreen = espgui::makeComponent<
@ -53,8 +52,8 @@ using namespace espgui;
LockscreenSettingsMenu::LockscreenSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ALLOWPRESETSWITCH>, ToggleBoolAction, CheckboxIcon, LockscreenAllowPresetSwitchAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_KEEPLOCKED>, ToggleBoolAction, CheckboxIcon, LockscreenKeepLockedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ALLOWPRESETSWITCH>, BobbyCheckbox, LockscreenAllowPresetSwitchAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_KEEPLOCKED>, BobbyCheckbox, LockscreenKeepLockedAccessor>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_PINDIGIT0, LockscreenPinDigitAccessor<0>>, SwitchScreenAction<LockscreenPinDigit0ChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_PINDIGIT1, LockscreenPinDigitAccessor<1>>, SwitchScreenAction<LockscreenPinDigit1ChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_PINDIGIT2, LockscreenPinDigitAccessor<2>>, SwitchScreenAction<LockscreenPinDigit2ChangeScreen>>>();

15
main/displays/menus/mosfetsmenu.cpp
View File

@ -1,20 +1,21 @@
#include "mosfetsmenu.h"
#ifdef FEATURE_MOSFETS
// 3rdparty lib includes
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "checkboxicon.h"
#include "displays/menus/mainmenu.h"
#include "icons/back.h"
// local includes
#include "displays/menus/mainmenu.h"
#include "bobbycheckbox.h"
using namespace espgui;
MosfetsMenu::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_MOSFET0>, BobbyCheckbox, Mosfet0Accessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET1>, BobbyCheckbox, Mosfet1Accessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET2>, BobbyCheckbox, Mosfet2Accessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}

9
main/displays/menus/motorfeedbackdebugmenu.h
View File

@ -37,11 +37,18 @@ public:
constructMenuItem<makeComponent<MenuItem, typename Ttexts::DcPhaCFixedText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, typename Ttexts::ChopsText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, typename Ttexts::HallText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
};
constexpr char TEXT_FRONTLEFTFEEDBACK[] = "Front left feedback";
using FrontLeftMotorFeedbackDebugMenu = MotorFeedbackDebugMenu<TEXT_FRONTLEFTFEEDBACK, FrontTexts::LeftFeedback, FrontFeedbackColor>;
constexpr char TEXT_FRONTRIGHTFEEDBACK[] = "Front right feedback";
using FrontRightMotorFeedbackDebugMenu = MotorFeedbackDebugMenu<TEXT_FRONTRIGHTFEEDBACK, FrontTexts::RightFeedback, FrontFeedbackColor>;
constexpr char TEXT_BACKLEFTFEEDBACK[] = "Back left feedback";
using BackLeftMotorFeedbackDebugMenu = MotorFeedbackDebugMenu<TEXT_BACKLEFTFEEDBACK, BackTexts::LeftFeedback, BackFeedbackColor>;
constexpr char TEXT_BACKRIGHTFEEDBACK[] = "Back right feedback";
using BackRightMotorFeedbackDebugMenu = MotorFeedbackDebugMenu<TEXT_BACKRIGHTFEEDBACK, BackTexts::RightFeedback, BackFeedbackColor>;

8
main/displays/menus/motorstatedebugmenu.h
View File

@ -10,7 +10,6 @@
#include "displays/bobbymenudisplay.h"
#include "debugmenu.h"
#include "utils.h"
#include "texts.h"
#include "debugtexthelpers.h"
template<const char *Ttext, typename Ttexts>
@ -38,7 +37,14 @@ public:
}
};
constexpr char TEXT_FRONTLEFTCOMMAND[] = "Front left command";
using FrontLeftMotorStateDebugMenu = MotorStateDebugMenu<TEXT_FRONTLEFTCOMMAND, FrontTexts::LeftCommand>;
constexpr char TEXT_FRONTRIGHTCOMMAND[] = "Front right command";
using FrontRightMotorStateDebugMenu = MotorStateDebugMenu<TEXT_FRONTRIGHTCOMMAND, FrontTexts::RightCommand>;
constexpr char TEXT_BACKLEFTCOMMAND[] = "Back left command";
using BackLeftMotorStateDebugMenu = MotorStateDebugMenu<TEXT_BACKLEFTCOMMAND, BackTexts::LeftCommand>;
constexpr char TEXT_BACKRIGHTCOMMAND[] = "Back right command";
using BackRightMotorStateDebugMenu = MotorStateDebugMenu<TEXT_BACKRIGHTCOMMAND, BackTexts::RightCommand>;

11
main/displays/menus/settingsmenu.cpp
View File

@ -4,9 +4,7 @@
#include <Arduino.h>
// 3rdparty lib includes
#include "actions/toggleboolaction.h"
#include "actions/switchscreenaction.h"
#include "checkboxicon.h"
#include "icons/back.h"
// local includes
@ -43,6 +41,7 @@
#include "displays/menus/crashmenu.h"
#include "displays/menus/aboutmenu.h"
#include "displays/menus/mainmenu.h"
#include "bobbycheckbox.h"
namespace {
#ifdef FEATURE_LEDBACKLIGHT
@ -61,7 +60,7 @@ using namespace espgui;
SettingsMenu::SettingsMenu()
{
#ifdef FEATURE_LEDBACKLIGHT
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKLIGHT>, ToggleBoolAction, CheckboxIcon, BacklightAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKLIGHT>, BobbyCheckbox, BacklightAccessor>>();
#endif
if (!simplified)
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LIMITSSETTINGS>, SwitchScreenAction<LimitsSettingsMenu>>>();
@ -90,11 +89,11 @@ SettingsMenu::SettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CONTROLLERHARDWARESETTINGS>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&bobbyicons::hardware>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BOARDCOMPUTERHARDWARESETTINGS>, SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&bobbyicons::hardware>>>();
#if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AUTOCONNECTBMS>, ToggleBoolAction, CheckboxIcon, AutoConnectBmsAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AUTOCONNECTBMS>, BobbyCheckbox, AutoConnectBmsAccessor>>();
#endif
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BUZZER>, SwitchScreenAction<BuzzerMenu>, StaticMenuItemIcon<&bobbyicons::buzzer>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLED>, ToggleBoolAction, CheckboxIcon, FrontLedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKLED>, ToggleBoolAction, CheckboxIcon, BackLedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLED>, BobbyCheckbox, FrontLedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKLED>, BobbyCheckbox, BackLedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CRASHMENU>, SwitchScreenAction<CrashMenu>, StaticMenuItemIcon<&bobbyicons::demos>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ABOUT>, SwitchScreenAction<AboutMenu>, StaticMenuItemIcon<&bobbyicons::info>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();

5
main/displays/menus/timesettingsmenu.cpp
View File

@ -8,10 +8,8 @@
#include "changevaluedisplay.h"
#include "changevaluedisplay_daylightsavingmode.h"
#include "changevaluedisplay_sntp_sync_mode_t.h"
#include "actions/toggleboolaction.h"
#include "actions/switchscreenaction.h"
#include "actions/dummyaction.h"
#include "checkboxicon.h"
#include "icons/back.h"
#include "espstrutils.h"
@ -20,6 +18,7 @@
#include "utils.h"
#include "accessors/settingsaccessors.h"
#include "displays/menus/settingsmenu.h"
#include "bobbycheckbox.h"
namespace {
class CurrentUtcDateTimeText : public virtual espgui::TextInterface
@ -97,7 +96,7 @@ TimeSettingsMenu::TimeSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_OFFSET>, SwitchScreenAction<TimezoneOffsetChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DAYLIGHTSAVINGMODE>, SwitchScreenAction<DaylightSavingModeChangeDisplay>>>();
#ifdef FEATURE_NTP
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_NTPENABLED>, ToggleBoolAction, CheckboxIcon, TimeServerEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_NTPENABLED>, BobbyCheckbox, TimeServerEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_NTPSERVER>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_NTPMODE>, SwitchScreenAction<TimeSyncModeChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_NTPINTERVAL>, SwitchScreenAction<TimeSyncIntervalChangeDisplay>>>();

7
main/displays/menus/udpcloudsettingsmenu.cpp
View File

@ -5,15 +5,14 @@
#include "menuitem.h"
#include "changevaluedisplay.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "actions/dummyaction.h"
#include "checkboxicon.h"
#include "icons/back.h"
// local includes
#include "displays/bobbychangevaluedisplay.h"
#include "accessors/settingsaccessors.h"
#include "displays/menus/settingsmenu.h"
#include "bobbycheckbox.h"
#ifdef FEATURE_UDPCLOUD
namespace {
@ -30,8 +29,8 @@ using namespace espgui;
UdpCloudSettingsMenu::UdpCloudSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_UDPCLOUDENABLED>, ToggleBoolAction, CheckboxIcon, UdpCloudEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_UDPUSESTRING>, ToggleBoolAction, CheckboxIcon, UdpUseStdStringAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_UDPCLOUDENABLED>, BobbyCheckbox, UdpCloudEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_UDPUSESTRING>, BobbyCheckbox, UdpUseStdStringAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_UDPSENDRATE>, SwitchScreenAction<UdpCloudSendRateChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}

7
main/displays/menus/wifiapsettingsmenu.cpp
View File

@ -7,8 +7,6 @@
#include <menuitem.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <checkboxicon.h>
#include <actions/toggleboolaction.h>
#include <icons/back.h>
#include <screenmanager.h>
#include <espwifistack.h>
@ -23,6 +21,7 @@
#include "networksettingsmenu.h"
#include "accessors/wifiapconfigaccessors.h"
#include "texthelpers/wifiaptexthelpers.h"
#include "bobbycheckbox.h"
using namespace espgui;
@ -87,8 +86,8 @@ using ApAuthmodeChangeScreen = espgui::makeComponent<
WifiApSettingsMenu::WifiApSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLED>, ToggleBoolAction, CheckboxIcon, WifiApEnabledAccessor>>();
//constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISABLEWHENONLINE>, ToggleBoolAction, CheckboxIcon, WifiApDisableWhenOnlineAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLED>, BobbyCheckbox, WifiApEnabledAccessor>>();
//constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISABLEWHENONLINE>, BobbyCheckbox, WifiApDisableWhenOnlineAccessor>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_SSID_FORMATTED, WifiApSsidAccessor>, SwitchScreenAction<ApSsidChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_KEY_FORMATTED, WifiApKeyAccessor>, SwitchScreenAction<ApKeyChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, WifiApMacText, DummyAction>>();

7
main/displays/menus/wifistaconfigentrymenu.cpp
View File

@ -6,14 +6,13 @@
#include <actions/switchscreenaction.h>
#include <icons/back.h>
#include <screenmanager.h>
#include <actions/toggleboolaction.h>
#include <checkboxicon.h>
// local includes
#include "texthelpers/wifistaconfigtexthelpers.h"
#include "accessors/wifistaconfigaccessors.h"
#include "wifistaconfigsmenu.h"
#include "newsettings.h"
#include "bobbycheckbox.h"
using namespace espgui;
@ -40,11 +39,11 @@ WifiStaConfigEntryMenu::WifiStaConfigEntryMenu(int index) :
{
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigSsidText, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigKeyText, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigUseStaticIpAccessor, StaticText<TEXT_USESTATICIP>, ToggleBoolAction, CheckboxIcon>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigUseStaticIpAccessor, StaticText<TEXT_USESTATICIP>, BobbyCheckbox>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticIpText, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticSubnetText, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticGatewayText, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigUseStaticDnsAccessor, StaticText<TEXT_USESTATICDNS>, ToggleBoolAction, CheckboxIcon>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigUseStaticDnsAccessor, StaticText<TEXT_USESTATICDNS>, BobbyCheckbox>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticDns0Text, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticDns1Text, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticDns2Text, DummyAction>>(index);

21
main/displays/menus/wifistasettingsmenu.cpp
View File

@ -4,31 +4,45 @@
#include <menuitem.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <checkboxicon.h>
#include <actions/toggleboolaction.h>
#include <icons/back.h>
#include <screenmanager.h>
#include <changevaluedisplay.h>
#include <textwithvaluehelper.h>
// local includes
#include "displays/bobbychangevaluedisplay.h"
#include "wifistascanmenu.h"
#include "wifistaconfigsmenu.h"
#include "accessors/wifistaconfigaccessors.h"
#include "networksettingsmenu.h"
#include "texthelpers/wifistatexthelpers.h"
#include "bobbycheckbox.h"
using namespace espgui;
namespace {
constexpr char TEXT_ENABLED[] = "Enabled";
constexpr char TEXT_CONFIGURATIONS[] = "Configurations";
constexpr char TEXT_MIN_RSSI[] = "AP Min RSSI";
constexpr char TEXT_MIN_RSSI_FORMATTED[] = "&sMin RSSI: &f&2";
constexpr char TEXT_BACK[] = "Back";
using StaMinRssiChangeScreen = espgui::makeComponent<
BobbyChangeValueDisplay<int8_t>,
espgui::StaticText<TEXT_MIN_RSSI>,
WifiStaMinRssiAccessor,
espgui::ConfirmActionInterface<espgui::SwitchScreenAction<WifiStaSettingsMenu>>,
espgui::BackActionInterface<espgui::SwitchScreenAction<WifiStaSettingsMenu>>
>;
} // namespace
WifiStaSettingsMenu::WifiStaSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLED>, BobbyCheckbox, WifiStaEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, WifiStaStatusText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStaMacText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStaScanStatusText, SwitchScreenAction<WifiStaScanMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CONFIGURATIONS>, SwitchScreenAction<WifiStaConfigsMenu>>>();
constructMenuItem<makeComponent<MenuItem, WifiSsidText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiBssidText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiRssiText, DummyAction>>();
@ -41,8 +55,7 @@ WifiStaSettingsMenu::WifiStaSettingsMenu()
constructMenuItem<makeComponent<MenuItem, WifiStaHostnameText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStaIpv6LinklocalText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStaIpv6GlobalText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLED>, ToggleBoolAction, CheckboxIcon, WifiStaEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CONFIGURATIONS>, SwitchScreenAction<WifiStaConfigsMenu>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_MIN_RSSI_FORMATTED, WifiStaMinRssiAccessor>, SwitchScreenAction<StaMinRssiChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<NetworkSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}

27
main/texts.cpp
View File

@ -64,24 +64,6 @@ char TEXT_UDPUSESTRING[] = "Udp use std::string";
//char TEXT_BACK[] = "Back";
#endif
//DebugMenu
char TEXT_LOADSETTINGS[] = "Load settings";
char TEXT_SAVESETTINGS[] = "Save settings";
char TEXT_ERASENVS[] = "Erase NVS";
char TEXT_FRONTCOMMAND[] = "Front command";
char TEXT_BACKCOMMAND[] = "Back command";
char TEXT_FRONTLEFTCOMMAND[] = "Front left command";
char TEXT_FRONTRIGHTCOMMAND[] = "Front right command";
char TEXT_BACKLEFTCOMMAND[] = "Back left command";
char TEXT_BACKRIGHTCOMMAND[] = "Back right command";
char TEXT_FRONTFEEDBACK[] = "Front feedback";
char TEXT_BACKFEEDBACK[] = "Back feedback";
char TEXT_FRONTLEFTFEEDBACK[] = "Front left feedback";
char TEXT_FRONTRIGHTFEEDBACK[] = "Front right feedback";
char TEXT_BACKLEFTFEEDBACK[] = "Back left feedback";
char TEXT_BACKRIGHTFEEDBACK[] = "Back right feedback";
//char TEXT_BACK[] = "Back";
//MainMenu
char TEXT_MAINMENU[] = "Main menu";
char TEXT_STATUS[] = "Status";
@ -200,11 +182,6 @@ char TEXT_FIELDWEAKMAX[] = "fldWkMax";
char TEXT_PHASEADVMAX[] = "phsAdvMax";
//char TEXT_BACK[] = "Back";
//DebugMenu
//char TEXT_DEBUG[] = "Debug";
char TEXT_DYNAMICMENU[] = "Dynamic menu";
//char TEXT_BACK[] = "Back";
//DefaultModeSettingsMenu
//char TEXT_DEFAULTMODESETTINGS[] = "Default mode settings";
char TEXT_MODELMODE[] = "Model mode";
@ -237,10 +214,6 @@ char TEXT_HANDBREMSE_TRIGGERTIMEOUT[] = "Handbrems Timeout";
char TEXT_HANDBREMSE[] = "Handbremse";
//char TEXT_BACK[] = "Back";
//DynamicDebugMenu
//char TEXT_DYNAMICMENU[] = "Dynamic menu";
//char TEXT_BACK[] = "Back";
//EnableMenu
//char TEXT_SETENABLED[] = "Set enabled";
char TEXT_ENABLEFRONTLEFT[] = "Enable front left";

31
main/texts.h
View File

@ -1,3 +1,5 @@
#pragma once
namespace bobbytexts {
//AboutMenu
extern char TEXT_ABOUT[];
@ -63,24 +65,6 @@ extern char TEXT_UDPUSESTRING[];
//extern char TEXT_BACK[];
#endif
//DebugMenu
extern char TEXT_LOADSETTINGS[];
extern char TEXT_SAVESETTINGS[];
extern char TEXT_ERASENVS[];
extern char TEXT_FRONTCOMMAND[];
extern char TEXT_BACKCOMMAND[];
extern char TEXT_FRONTLEFTCOMMAND[];
extern char TEXT_FRONTRIGHTCOMMAND[];
extern char TEXT_BACKLEFTCOMMAND[];
extern char TEXT_BACKRIGHTCOMMAND[];
extern char TEXT_FRONTFEEDBACK[];
extern char TEXT_BACKFEEDBACK[];
extern char TEXT_FRONTLEFTFEEDBACK[];
extern char TEXT_FRONTRIGHTFEEDBACK[];
extern char TEXT_BACKLEFTFEEDBACK[];
extern char TEXT_BACKRIGHTFEEDBACK[];
//extern char TEXT_BACK[];
//MainMenu
extern char TEXT_MAINMENU[];
extern char TEXT_STATUS[];
@ -199,11 +183,6 @@ extern char TEXT_FIELDWEAKMAX[];
extern char TEXT_PHASEADVMAX[];
//extern char TEXT_BACK[];
//DebugMenu
//extern char TEXT_DEBUG[];
extern char TEXT_DYNAMICMENU[];
//extern char TEXT_BACK[];
//DefaultModeSettingsMenu
//extern char TEXT_DEFAULTMODESETTINGS[];
extern char TEXT_MODELMODE[];
@ -236,10 +215,6 @@ extern char TEXT_HANDBREMSE_TRIGGERTIMEOUT[];
extern char TEXT_HANDBREMSE[];
//extern char TEXT_BACK[];
//DynamicDebugMenu
//extern char TEXT_DYNAMICMENU[];
//extern char TEXT_BACK[];
//EnableMenu
//extern char TEXT_SETENABLED[];
extern char TEXT_ENABLEFRONTLEFT[];
@ -505,6 +480,6 @@ extern char TEXT_ESPNOW_SETTINGS[];
extern char TEXT_ESPNOW_SYNCTIME[];
extern char TEXT_ESPNOW_SYNCWITHOTHERS[];
extern char TEXT_ESPNOW_SYNCBLINK[];
} // namespace
} // namespace bobbytexts
using namespace bobbytexts;