Add widget functionality into the library

src/BaseItemManyWidgets.h

@@ -0,0 +1,162 @@
+// Creator: @ShishkinDmitriy
+#ifndef BASE_ITEM_MANY_WIDGETS_H
+#define BASE_ITEM_MANY_WIDGETS_H
+
+#include "LcdMenu.h"
+#include "MenuItem.h"
+#include "widget/BaseWidget.h"
+#include <utils/utils.h>
+
+class BaseItemManyWidgets : public MenuItem {
+  protected:
+    BaseWidget** widgets = nullptr;
+    const uint8_t size = 0;
+    uint8_t activeWidget = 0;
+
+  public:
+    BaseItemManyWidgets(const char* text, BaseWidget** widgets, const uint8_t size, uint8_t activeWidget = 0)
+        : MenuItem(text), widgets(widgets), size(size), activeWidget(constrain(activeWidget, 0, size)) {}
+
+    uint8_t getActiveWidget() const { return activeWidget; }
+    void setActiveWidget(const uint8_t activeWidget) {
+        if (activeWidget < size) {
+            this->activeWidget = activeWidget;
+        }
+    }
+
+    virtual ~BaseItemManyWidgets() {
+        for (uint8_t i = 0; i < size; ++i)
+            delete widgets[i];
+        delete[] widgets;
+    }
+
+  protected:
+    virtual void handleCommit() = 0;
+    /**
+     * @brief Reset the active widget to the first widget.
+     */
+    void reset() { activeWidget = 0; }
+
+    /**
+     * @brief Draws the menu item using the provided renderer.
+     *
+     * This function is responsible for rendering the menu item and its associated widgets.
+     * It iterates through each widget, drawing them into a buffer, and then uses the renderer
+     * to display the combined result. If the renderer is in edit mode, it also handles the
+     * cursor positioning for editing.
+     *
+     * @param renderer A pointer to the MenuRenderer object used for drawing the item.
+     *
+     * The function performs the following steps:
+     * 1. Initializes a buffer to hold the drawn content and variables for indexing and cursor positioning.
+     * 2. Iterates through each widget, drawing it into the buffer and updating the index.
+     * 3. If the active widget is being edited, it draws the item using the renderer and calculates the cursor position.
+     * 4. Draws the final item using the renderer.
+     * 5. If in edit mode, moves the cursor to the appropriate position for editing.
+     */
+    void draw(MenuRenderer* renderer) override {
+        char buf[ITEM_DRAW_BUFFER_SIZE];
+
+        uint8_t index = 0;
+        uint8_t cursorCol = 0;
+
+        for (uint8_t i = 0; i < size; i++) {
+            index += widgets[i]->draw(buf, index);
+            if (i == activeWidget && renderer->isInEditMode()) {
+                renderer->drawItem(text, buf, i == size - 1);
+                cursorCol = renderer->getCursorCol() - 1 - widgets[i]->cursorOffset;
+            }
+        }
+        renderer->drawItem(text, buf);
+
+        if (renderer->isInEditMode()) {
+            renderer->moveCursor(cursorCol, renderer->getCursorRow());
+        }
+    }
+
+    /**
+     * @brief Processes a command for the active widget in the menu.
+     *
+     * This function handles the processing of commands for the active widget in the menu.
+     * It first attempts to process the command using the active widget. If the widget
+     * processes the command successfully, it redraws the menu and returns true.
+     *
+     * If the renderer is in edit mode, it handles navigation commands (ENTER, RIGHT, LEFT, BACK)
+     * to navigate through the widgets or exit edit mode.
+     *
+     * When the ENTER command is received while the renderer is in edit mode and the active widget
+     * is not the last widget, it moves to the next widget. If the active widget is the last widget,
+     * it exits edit mode and calls the handleCommit function to commit the changes.
+     *
+     * If the renderer is not in edit mode and the ENTER command is received, it sets the renderer
+     * to edit mode, redraws the menu, and draws a blinker.
+     *
+     * @param menu Pointer to the LcdMenu object.
+     * @param command The command to be processed.
+     * @return true if the command was processed successfully, false otherwise.
+     */
+    bool process(LcdMenu* menu, const unsigned char command) override {
+        MenuRenderer* renderer = menu->getRenderer();
+        if (widgets[activeWidget]->process(menu, command)) {
+            draw(renderer);
+            return true;
+        }
+        if (renderer->isInEditMode()) {
+            switch (command) {
+                case ENTER:
+                    if (activeWidget < this->size - 1) {
+                        right(renderer);
+                    } else {
+                        back(renderer);
+                    }
+                    return true;
+                case RIGHT:
+                    right(renderer);
+                    return true;
+                case LEFT:
+                    left(renderer);
+                    return true;
+                case BACK:
+                    back(renderer);
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        if (command == ENTER) {
+            renderer->setEditMode(true);
+            draw(renderer);
+            renderer->drawBlinker();
+            LOG(F("ItemWidget::enterEditMode"), this->text);
+            return true;
+        }
+        return false;
+    }
+
+    void left(MenuRenderer* renderer) {
+        if (activeWidget == 0) {
+            activeWidget = this->size - 1;
+        } else {
+            activeWidget--;
+        }
+        draw(renderer);
+        LOG(F("ItemWidget::left"), activeWidget);
+    }
+
+    void right(MenuRenderer* renderer) {
+        activeWidget = (activeWidget + 1) % this->size;
+        draw(renderer);
+        LOG(F("ItemWidget::right"), activeWidget);
+    }
+
+    void back(MenuRenderer* renderer) {
+        renderer->setEditMode(false);
+        reset();
+        handleCommit();
+        renderer->clearBlinker();
+        draw(renderer);
+        LOG(F("ItemWidget::exitEditMode"), this->text);
+    }
+};
+
+#endif

src/BaseItemZeroWidget.h

@@ -0,0 +1,45 @@
+// Creator: @ShishkinDmitriy
+#ifndef BASE_ITEM_ZERO_WIDGET_H
+#define BASE_ITEM_ZERO_WIDGET_H
+
+#include "MenuItem.h"
+
+/**
+ * @class BaseItemZeroWidget
+ * @brief A base class for menu items that either require custom commit handling or no commit handling.
+ *
+ * This class extends the MenuItem class and provides a framework for menu items
+ * that either need no commit handling or need to handle commit actions in a specific way.
+ * It requires derived classes to implement the `handleCommit` method for custom commit handling.
+ *
+ * @note This class is intended to be used as a base class for other menu items.
+ *       It should not be instantiated directly.
+ */
+class BaseItemZeroWidget : public MenuItem {
+  public:
+    virtual ~BaseItemZeroWidget() = default;
+    /**
+     * @brief Construct a new BaseItemZeroWidget object.
+     *
+     * @param text The text to display for the menu item.
+     */
+    explicit BaseItemZeroWidget(const char* text) : MenuItem(text) {}
+
+  protected:
+    virtual void handleCommit(LcdMenu* menu) = 0;
+
+    void draw(MenuRenderer* renderer) override {
+        renderer->drawItem(text, nullptr);
+    }
+
+    bool process(LcdMenu* menu, const unsigned char command) override {
+        if (command == ENTER) {
+            handleCommit(menu);
+            LOG(F("ItemWidget::enter"), text);
+            return true;
+        }
+        return false;
+    }
+};
+
+#endif

src/ItemWidget.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include "BaseItemManyWidgets.h"
+#include "widget/BaseWidgetValue.h"
+
+// Custom index_sequence implementation for C++11
+template <size_t... Is>
+struct index_sequence {};
+
+/**
+ * @brief Custom implementation of index_sequence and make_index_sequence for C++11 compatibility on Arduino.
+ *
+ * This template struct generates a compile-time sequence of integers, which is useful for template metaprogramming.
+ * The implementation is necessary because the standard library's std::index_sequence and std::make_index_sequence
+ * are not available in C++11, which is commonly used in Arduino projects.
+ *
+ * @tparam N The size of the sequence to generate.
+ * @tparam Is The sequence of integers generated so far.
+ */
+template <size_t N, size_t... Is>
+struct make_index_sequence : make_index_sequence<N - 1, N - 1, Is...> {};
+
+template <size_t... Is>
+struct make_index_sequence<0, Is...> {
+    using type = index_sequence<Is...>;
+};
+
+template <typename... Ts>
+class ItemWidget : public BaseItemManyWidgets {
+  public:
+    using CallbackType = void (*)(Ts...);
+
+  protected:
+    CallbackType callback = nullptr;
+
+    void handleCommit() override {
+        if (callback != nullptr) {
+            invokeCallback(typename make_index_sequence<sizeof...(Ts)>::type{});
+        }
+    }
+
+    template <size_t... Is>
+    void invokeCallback(index_sequence<Is...>) {
+        callback(static_cast<BaseWidgetValue<Ts>*>(widgets[Is])->getValue()...);
+    }
+
+  public:
+    // Constructor for one or more widgets
+    ItemWidget(const char* text, BaseWidgetValue<Ts>*... widgetPtrs, CallbackType callback = nullptr)
+        : BaseItemManyWidgets(
+              text,
+              // clang-format off
+              new BaseWidget* [sizeof...(Ts)] { widgetPtrs... },
+              // clang-format on
+              sizeof...(Ts)),
+          callback(callback) {}
+
+    void setValues(Ts... values) {
+        setValuesImpl(typename make_index_sequence<sizeof...(Ts)>::type{}, values...);
+    }
+
+  private:
+    template <size_t... Is>
+    void setValuesImpl(index_sequence<Is...>, Ts... values) {
+        // Using a dummy array to expand the parameter pack and call setValue on each widget
+        int dummy[] = {(static_cast<BaseWidgetValue<Ts>*>(widgets[Is])->setValue(values), 0)...};
+        static_cast<void>(dummy);  // Avoid unused variable warning
+    }
+};
+
+template <typename... Ts>
+/**
+ * @brief Create an ItemWidget object
+ *
+ * @param text the text of the item
+ * @param callback reference to callback function to call when the value of the item is changed
+ * @param widgetPtrs pointers to the widgets associated with this item
+ */
+inline MenuItem* ITEM_WIDGET(
+    const char* text,
+    typename ItemWidget<Ts...>::CallbackType callback,
+    BaseWidgetValue<Ts>*... widgetPtrs) {
+    return new ItemWidget<Ts...>(text, widgetPtrs..., callback);
+}

src/renderer/CharacterDisplayRenderer.cpp

@@ -21,7 +21,7 @@ void CharacterDisplayRenderer::begin() {
     static_cast<CharacterDisplayInterface*>(display)->createChar(2, downArrow);
 }
 
-void CharacterDisplayRenderer::drawItem(const char* text, const char* value) {
+void CharacterDisplayRenderer::drawItem(const char* text, const char* value, bool paddWithBlanks) {
     uint8_t cursorCol = 0;
     display->setCursor(cursorCol, cursorRow);
 
@@ -49,9 +49,11 @@ void CharacterDisplayRenderer::drawItem(const char* text, const char* value) {
 
     uint8_t cursorColEnd = cursorCol;
 
-    // Fill remaining space with white spaces
-    for (; cursorCol < availableColumns; cursorCol++) {
-        display->draw(' ');
+    // Fill remaining space with whitespace only when paddWithBlanks is true
+    if (paddWithBlanks) {
+        for (; cursorCol < availableColumns; cursorCol++) {
+            display->draw(' ');
+        }
     }
 
     // Draw up and down arrows if present

src/renderer/CharacterDisplayRenderer.h

@@ -90,8 +90,9 @@ class CharacterDisplayRenderer : public MenuRenderer {
      *
      * @param text The text of the menu item to be drawn.
      * @param value The value of the menu item to be drawn.
+     * @param paddWithBlanks A flag indicating whether to pad the text with spaces.
      */
-    void drawItem(const char* text, const char* value) override;
+    void drawItem(const char* text, const char* value, bool paddWithBlanks) override;
     void draw(uint8_t byte) override;
     void drawBlinker() override;
     void clearBlinker() override;

src/renderer/MenuRenderer.h

@@ -75,8 +75,9 @@ class MenuRenderer {
      * @brief Draws an item on the display.
      * @param text Text of the item to be drawn.
      * @param value Value of the item to be drawn.
+     * @param paddWithBlanks Flag indicating whether to pad the text with spaces.
      */
-    virtual void drawItem(const char* text, const char* value) = 0;
+    virtual void drawItem(const char* text, const char* value, bool paddWithBlanks = true) = 0;
 
     /**
      * @brief Function to clear the blinker from the display.