some more widgets

Signed-off-by: Peter Siegmund <developer@mars3142.org>

.github/workflows/esp32_build.yml

@@ -1,4 +1,4 @@
-name: Lolin ESP32-S3 Mini
+name: ESP-IDF Build
 
 permissions:
   contents: read

components/justus/include/common/Common.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <functional>
+
+enum class ButtonType { NONE, UP, DOWN, LEFT, RIGHT, SELECT, BACK };
+
+typedef std::function<void(uint8_t, ButtonType)> ButtonCallback;

components/justus/include/common/PSMenu.h

@@ -2,37 +2,38 @@
 
 #include <functional>
 
+#include "Common.h"
 #include "MenuOptions.h"
 #include "Widget.h"
 #include "data/MenuItem.h"
 
-typedef std::function<void(uint8_t)> MenuCallback;
-
 class PSMenu : public Widget
 {
-  public:
+public:
     explicit PSMenu(menu_options_t *options);
     ~PSMenu() override;
 
+    void addText(uint8_t id, const std::string &text, const ButtonCallback &callback);
+    void addSelection(uint8_t id, const std::string &text, std::string &value, const std::vector<std::string>& values,
+                      const ButtonCallback &callback);
+    void addNumber(uint8_t id, const std::string &text, std::string &value, const ButtonCallback &callback);
+    void addToggle(uint8_t id, const std::string &text, bool selected, const ButtonCallback &callback);
+
+private:
     void render() override;
     void onButtonClicked(uint8_t button) override;
 
-    void addText(const std::string &text, const MenuCallback &callback);
-    void addSwitch(const std::string &text, std::string &value, const MenuCallback &callback);
-    void addNumber(const std::string &text, std::string &value, const MenuCallback &callback);
-
-  private:
     void onPressedDown();
     void onPressedUp();
-    void onPressedLeft();
+    void onPressedLeft() const;
-    void onPressedRight();
+    void onPressedRight() const;
     void onPressedSelect() const;
     void onPressedBack() const;
 
     void drawScrollBar() const;
     void drawSelectionBox() const;
 
-    void renderWidget(uint8_t type, const uint8_t *font, int x, int y, const char *text) const;
+    void renderWidget(const MenuItem *item, const uint8_t *font, int x, int y) const;
 
     size_t m_selected_item = 0;
     std::vector<MenuItem> m_items;

components/justus/include/common/Widget.h

@@ -6,7 +6,7 @@
 
 class Widget
 {
-  public:
+public:
     explicit Widget(u8g2_t *u8g2);
 
     virtual ~Widget() = default;
@@ -17,6 +17,6 @@ class Widget
 
     virtual void onButtonClicked(uint8_t button);
 
-  protected:
+protected:
     u8g2_t *u8g2;
 };

components/justus/include/data/MenuItem.h

@@ -1,24 +1,31 @@
 #pragma once
 
-#include <cstdint>
 #include <functional>
 #include <string>
 
+#include "common/Common.h"
+
 class MenuItem
 {
-  public:
+public:
-    MenuItem(uint8_t type, std::string text, std::function<void(uint8_t)> callback);
+    MenuItem(uint8_t id, uint8_t type, std::string text, ButtonCallback callback);
-    MenuItem(uint8_t type, std::string text, std::string value, std::function<void(uint8_t)> callback);
+    MenuItem(uint8_t id, uint8_t type, std::string text, std::string value, ButtonCallback callback);
+    MenuItem(uint8_t id, uint8_t type, std::string text, std::string value, std::vector<std::string> values,
+             ButtonCallback callback);
+    MenuItem(uint8_t id, uint8_t type, std::string text, bool selected, ButtonCallback callback);
+    [[nodiscard]] uint8_t getId() const;
     [[nodiscard]] uint8_t getType() const;
     [[nodiscard]] const std::string &getText() const;
     [[nodiscard]] const std::string &getValue() const;
     void setValue(const std::string &value);
-    void callback(uint8_t id) const;
+    void onButtonPressed(uint8_t id, ButtonType button) const;
     [[nodiscard]] bool hasCallback() const;
 
-  private:
+private:
+    uint8_t m_id;
     uint8_t m_type;
     std::string m_text;
     std::string m_value;
-    std::function<void(uint8_t)> m_callback;
+    std::vector<std::string> m_values;
+    ButtonCallback m_callback;
 };

components/justus/include/ui/LightMenu.h

@@ -2,8 +2,13 @@
 
 #include "common/PSMenu.h"
 
-class LightMenu : public PSMenu
+class LightMenu final : public PSMenu
 {
   public:
     explicit LightMenu(menu_options_t *options);
+
+private:
+    void onButtonPressed(uint8_t id, ButtonType button) const;
+
+    menu_options_t *m_options;
 };

components/justus/include/ui/MainMenu.h

@@ -4,11 +4,11 @@
 
 class MainMenu final : public PSMenu
 {
-  public:
+public:
     explicit MainMenu(menu_options_t *options);
 
-  private:
+private:
-    void onSelect(uint8_t id) const;
+    void onButtonPressed(uint8_t id, ButtonType button) const;
 
     menu_options_t *m_options;
 };

components/justus/include/ui/SettingsMenu.h

@@ -2,7 +2,7 @@
 
 #include "common/PSMenu.h"
 
-class SettingsMenu : public PSMenu
+class SettingsMenu final : public PSMenu
 {
   public:
     explicit SettingsMenu(menu_options_t *options);

components/justus/src/common/PSMenu.cpp

@@ -6,7 +6,9 @@
 
 PSMenu::PSMenu(menu_options_t *options) : Widget(options->u8g2), m_options(options)
 {
-    m_options->onButtonClicked = [this](const uint8_t button) { onButtonClicked(button); };
+    m_options->onButtonClicked = [this](const uint8_t button) {
+        onButtonClicked(button);
+    };
 }
 
 PSMenu::~PSMenu()
@@ -31,35 +33,54 @@ void PSMenu::render()
 
     int x = 8; // sure?
     auto widget = m_items.at(m_selected_item);
-    renderWidget(widget.getType(), u8g2_font_helvB08_tr, x, u8g2->height / 2 + 3, widget.getText().c_str());
+    renderWidget(&widget, u8g2_font_helvB08_tr, x, u8g2->height / 2 + 3);
 
     if (m_selected_item > 0)
     {
         auto item = m_items.at(m_selected_item - 1);
-        renderWidget(item.getType(), u8g2_font_haxrcorp4089_tr, x, 14, item.getText().c_str());
+        renderWidget(&item, u8g2_font_haxrcorp4089_tr, x, 14);
     }
     if (m_selected_item < m_items.size() - 1)
     {
         auto item = m_items.at(m_selected_item + 1);
-        renderWidget(item.getType(), u8g2_font_haxrcorp4089_tr, x, u8g2->height - 10, item.getText().c_str());
+        renderWidget(&item, u8g2_font_haxrcorp4089_tr, x, u8g2->height - 10);
     }
 }
 
-void PSMenu::renderWidget(const uint8_t type, const uint8_t *font, const int x, const int y, const char *text) const
+void PSMenu::renderWidget(const MenuItem *item, const uint8_t *font, const int x, const int y) const
 {
-    switch (type)
+    u8g2_SetFont(u8g2, font);
+    u8g2_DrawStr(u8g2, x, y, item->getText().c_str());
+    switch (item->getType())
     {
-    case 0: // text
+    case 1: // Selection
-        u8g2_SetFont(u8g2, font);
+    {
-        u8g2_DrawStr(u8g2, x, y, text);
+        std::string value = "< ";
+        value += item->getValue();
+        value += " >";
+        const u8g2_uint_t w = u8g2_GetStrWidth(u8g2, value.c_str());
+        u8g2_DrawStr(u8g2, u8g2->width - w - 10, y, value.c_str());
         break;
+    }
+
+    case 3: // toggle
+    {
+        u8g2_DrawFrame(u8g2, u8g2->width - 24, y - 11, 14, 14);
+        if (strcmp(item->getValue().c_str(), "true") == 0)
+        {
+            u8g2_DrawLine(u8g2, u8g2->width - 22, y - 9, u8g2->width - 13, y);
+            u8g2_DrawLine(u8g2, u8g2->width - 22, y, u8g2->width - 13, y - 9);
+        }
+        break;
+    }
 
     default:
-        break;
+
+
     }
 }
 
-void PSMenu::onButtonClicked(uint8_t button)
+void PSMenu::onButtonClicked(const uint8_t button)
 {
     switch (button)
     {
@@ -116,19 +137,22 @@ void PSMenu::onPressedUp()
     }
 }
 
-void PSMenu::onPressedLeft()
+void PSMenu::onPressedLeft() const
 {
-    //
+    const auto item = m_items.at(m_selected_item);
+    item.onButtonPressed(item.getId(), ButtonType::LEFT);
 }
 
-void PSMenu::onPressedRight()
+void PSMenu::onPressedRight() const
 {
-    ///
+    const auto item = m_items.at(m_selected_item);
+    item.onButtonPressed(item.getId(), ButtonType::RIGHT);
 }
 
 void PSMenu::onPressedSelect() const
 {
-    m_items.at(m_selected_item).callback(m_selected_item);
+    const auto item = m_items.at(m_selected_item);
+    item.onButtonPressed(item.getId(), ButtonType::SELECT);
 }
 
 void PSMenu::onPressedBack() const
@@ -139,19 +163,26 @@ void PSMenu::onPressedBack() const
     }
 }
 
-void PSMenu::addText(const std::string &text, const MenuCallback &callback)
+void PSMenu::addText(uint8_t id, const std::string &text, const ButtonCallback &callback)
 {
-    m_items.emplace_back(0, text, callback);
+    m_items.emplace_back(id, 0, text, callback);
 }
 
-void PSMenu::addSwitch(const std::string &text, std::string &value, const MenuCallback &callback)
+void PSMenu::addSelection(uint8_t id, const std::string &text, std::string &value,
+                          const std::vector<std::string> &values,
+                          const ButtonCallback &callback)
 {
-    m_items.emplace_back(1, text, value, callback);
+    m_items.emplace_back(id, 1, text, value, values, callback);
 }
 
-void PSMenu::addNumber(const std::string &text, std::string &value, const MenuCallback &callback)
+void PSMenu::addNumber(uint8_t id, const std::string &text, std::string &value, const ButtonCallback &callback)
 {
-    m_items.emplace_back(2, text, value, callback);
+    m_items.emplace_back(id, 2, text, value, callback);
+}
+
+void PSMenu::addToggle(uint8_t id, const std::string &text, bool selected, const ButtonCallback &callback)
+{
+    m_items.emplace_back(id, 3, text, selected, callback);
 }
 
 void PSMenu::drawScrollBar() const

components/justus/src/data/MenuItem.cpp

@@ -1,15 +1,36 @@
 #include "data/MenuItem.h"
 
-MenuItem::MenuItem(const uint8_t type, std::string text, std::function<void(uint8_t)> callback)
+MenuItem::MenuItem(const uint8_t id, const uint8_t type, std::string text, ButtonCallback callback)
-    : m_type(type), m_text(std::move(text)), m_callback(std::move(callback))
+    : m_id(id), m_type(type), m_text(std::move(text)), m_callback(std::move(callback))
 {
 }
 
-MenuItem::MenuItem(const uint8_t type, std::string text, std::string value, std::function<void(uint8_t)> callback)
+MenuItem::MenuItem(const uint8_t id, const uint8_t type, std::string text, std::string value,
-    : m_type(type), m_text(std::move(text)), m_value(std::move(value)), m_callback(std::move(callback))
+                   ButtonCallback callback)
+    : m_id(id), m_type(type), m_text(std::move(text)), m_value(std::move(value)), m_callback(std::move(callback))
 {
 }
 
+MenuItem::MenuItem(const uint8_t id, const uint8_t type, std::string text, std::string value,
+                   std::vector<std::string> values,
+                   ButtonCallback callback)
+    : m_id(id), m_type(type), m_text(std::move(text)), m_value(std::move(value)), m_values(std::move(values)),
+      m_callback(std::move(callback))
+{
+}
+
+MenuItem::MenuItem(const uint8_t id, const uint8_t type, std::string text, const bool selected,
+                   ButtonCallback callback)
+    : m_id(id), m_type(type), m_text(std::move(text)), m_value(selected ? "true" : "false"),
+      m_callback(std::move(callback))
+{
+}
+
+uint8_t MenuItem::getId() const
+{
+    return m_id;
+}
+
 uint8_t MenuItem::getType() const
 {
     return m_type;
@@ -30,15 +51,11 @@ void MenuItem::setValue(const std::string &value)
     m_value = value;
 }
 
-void MenuItem::callback(const uint8_t id) const
+void MenuItem::onButtonPressed(const uint8_t id, const ButtonType button) const
 {
     if (m_callback)
     {
-        m_callback(id);
+        m_callback(id, button);
-    }
-    else
-    {
-        ///
     }
 }
 

components/justus/src/ui/LightMenu.cpp

@@ -1,12 +1,36 @@
 #include "ui/LightMenu.h"
 
-void demoL(uint8_t id)
+LightMenu::LightMenu(menu_options_t *options) : PSMenu(options), m_options(options)
 {
-    //
+    std::vector<std::string> values;
+    values.emplace_back("Tag");
+    values.emplace_back("Nacht");
+    addSelection(1, "Modus", values.front(), values, [this](const uint8_t id, const ButtonType button) {
+        onButtonPressed(id, button);
+    });
+
+    addText(2, "LED Einstellungen", [this](const uint8_t id, const ButtonType button) {
+        onButtonPressed(id, button);
+    });
+
+    addToggle(3, "Toggle", false, nullptr);
 }
 
-LightMenu::LightMenu(menu_options_t *options) : PSMenu(options)
+void LightMenu::onButtonPressed(const uint8_t id, const ButtonType button) const
 {
-    addText("Tag/Nacht", nullptr);
+    std::shared_ptr<Widget> widget;
-    addText("LED Einstellungen", demoL);
+    switch (id)
+    {
+    case 2:
+        widget = std::make_shared<LightMenu>(m_options);
+        break;
+
+    default:
+        break;
+    }
+
+    if (m_options && m_options->pushScreen)
+    {
+        m_options->pushScreen(widget);
+    }
 }

components/justus/src/ui/MainMenu.cpp

@@ -6,22 +6,33 @@
 
 MainMenu::MainMenu(menu_options_t *options) : PSMenu(options), m_options(options)
 {
-    addText("Lichtsteuerung", [this](const uint8_t button) { onSelect(button); });
+    addText(1, "Lichtsteuerung", [this](const uint8_t id, const ButtonType button) {
-    addText("Einstellungen", [this](const uint8_t button) { onSelect(button); });
+        onButtonPressed(id, button);
+    });
+    addText(2, "externe Geraete", [this](const uint8_t id, const ButtonType button) {
+        onButtonPressed(id, button);
+    });
+    addText(3, "Einstellungen", [this](const uint8_t id, const ButtonType button) {
+        onButtonPressed(id, button);
+    });
 }
 
-void MainMenu::onSelect(const uint8_t id) const
+void MainMenu::onButtonPressed(const uint8_t id, const ButtonType button) const
 {
     std::shared_ptr<Widget> widget;
     switch (id)
     {
-    case 0:
+    case 1:
         widget = std::make_shared<LightMenu>(m_options);
         break;
-    case 1:
+
+    case 3:
         widget = std::make_shared<SettingsMenu>(m_options);
         break;
+    default:
+        break;
     }
+
     if (m_options && m_options->pushScreen)
     {
         m_options->pushScreen(widget);

components/justus/src/ui/SettingsMenu.cpp

@@ -1,11 +1,11 @@
 #include "ui/SettingsMenu.h"
 
-void demo(uint8_t id)
+void demo(uint8_t id, ButtonType button)
 {
     ///
 }
 
 SettingsMenu::SettingsMenu(menu_options_t *options) : PSMenu(options)
 {
-    addText("OTA Einspielen", demo);
+    addText(1, "OTA Einspielen", demo);
 }