implement VALUE SettingType and SettingInfo static constructors

src/CrossPointSettings.cpp

@@ -213,18 +213,3 @@ int CrossPointSettings::getReaderFontId() const {
       }
   }
 }
-
-int CrossPointSettings::getReaderScreenMargin() const {
-  switch (screenMargin) {
-    case SMALL:
-      return 5;
-    case MEDIUM:
-      return 10;
-    case LARGE:
-      return 20;
-    case EXTRA_LARGE:
-      return 40;
-    default:
-      return 5;
-  }
-}

src/CrossPointSettings.h

@@ -76,7 +76,7 @@ class CrossPointSettings {
   uint8_t refreshFrequency = REFRESH_15;
 
   // Reader screen margin settings
-  uint8_t screenMargin = SMALL;
+  uint8_t screenMargin = 5;
 
   ~CrossPointSettings() = default;
 

src/activities/reader/EpubReaderActivity.cpp

@@ -251,9 +251,9 @@ void EpubReaderActivity::renderScreen() {
   int orientedMarginTop, orientedMarginRight, orientedMarginBottom, orientedMarginLeft;
   renderer.getOrientedViewableTRBL(&orientedMarginTop, &orientedMarginRight, &orientedMarginBottom,
                                    &orientedMarginLeft);
-  orientedMarginTop += SETTINGS.getReaderScreenMargin();
+  orientedMarginTop += SETTINGS.screenMargin;
-  orientedMarginLeft += SETTINGS.getReaderScreenMargin();
+  orientedMarginLeft += SETTINGS.screenMargin;
-  orientedMarginRight += SETTINGS.getReaderScreenMargin();
+  orientedMarginRight += SETTINGS.screenMargin;
   orientedMarginBottom += statusBarMargin;
 
   if (!section) {

src/activities/settings/SettingsActivity.cpp

@@ -1,6 +1,7 @@
 #include "SettingsActivity.h"
 
 #include <GfxRenderer.h>
+#include <HardwareSerial.h>
 
 #include "CrossPointSettings.h"
 #include "MappedInputManager.h"
@@ -12,43 +13,28 @@ namespace {
 constexpr int settingsCount = 15;
 const SettingInfo settingsList[settingsCount] = {
     // Should match with SLEEP_SCREEN_MODE
-    {"Sleep Screen", SettingType::ENUM, &CrossPointSettings::sleepScreen, {"Dark", "Light", "Custom", "Cover"}},
+    SettingInfo::Enum("Sleep Screen", &CrossPointSettings::sleepScreen, {"Dark", "Light", "Custom", "Cover"}),
-    {"Status Bar", SettingType::ENUM, &CrossPointSettings::statusBar, {"None", "No Progress", "Full"}},
+    SettingInfo::Enum("Status Bar", &CrossPointSettings::statusBar, {"None", "No Progress", "Full"}),
-    {"Extra Paragraph Spacing", SettingType::TOGGLE, &CrossPointSettings::extraParagraphSpacing, {}},
+    SettingInfo::Toggle("Extra Paragraph Spacing", &CrossPointSettings::extraParagraphSpacing),
-    {"Short Power Button Click", SettingType::TOGGLE, &CrossPointSettings::shortPwrBtn, {}},
+    SettingInfo::Toggle("Short Power Button Click", &CrossPointSettings::shortPwrBtn),
-    {"Reading Orientation",
+    SettingInfo::Enum("Reading Orientation", &CrossPointSettings::orientation,
-     SettingType::ENUM,
+                      {"Portrait", "Landscape CW", "Inverted", "Landscape CCW"}),
-     &CrossPointSettings::orientation,
+    SettingInfo::Enum("Front Button Layout", &CrossPointSettings::frontButtonLayout,
-     {"Portrait", "Landscape CW", "Inverted", "Landscape CCW"}},
+                      {"Bck, Cnfrm, Lft, Rght", "Lft, Rght, Bck, Cnfrm", "Lft, Bck, Cnfrm, Rght"}),
-    {"Front Button Layout",
+    SettingInfo::Enum("Side Button Layout (reader)", &CrossPointSettings::sideButtonLayout,
-     SettingType::ENUM,
+                      {"Prev, Next", "Next, Prev"}),
-     &CrossPointSettings::frontButtonLayout,
+    SettingInfo::Enum("Reader Font Family", &CrossPointSettings::fontFamily,
-     {"Bck, Cnfrm, Lft, Rght", "Lft, Rght, Bck, Cnfrm", "Lft, Bck, Cnfrm, Rght"}},
+                      {"Bookerly", "Noto Sans", "Open Dyslexic"}),
-    {"Side Button Layout (reader)",
+    SettingInfo::Enum("Reader Font Size", &CrossPointSettings::fontSize, {"Small", "Medium", "Large", "X Large"}),
-     SettingType::ENUM,
+    SettingInfo::Enum("Reader Line Spacing", &CrossPointSettings::lineSpacing, {"Tight", "Normal", "Wide"}),
-     &CrossPointSettings::sideButtonLayout,
+    SettingInfo::Value("Reader Screen Margin", &CrossPointSettings::screenMargin, 5, 50),
-     {"Prev, Next", "Next, Prev"}},
+    SettingInfo::Enum("Reader Paragraph Alignment", &CrossPointSettings::paragraphAlignment,
-    {"Reader Font Family",
+                      {"Justify", "Left", "Center", "Right"}),
-     SettingType::ENUM,
+    SettingInfo::Enum("Time to Sleep", &CrossPointSettings::sleepTimeout,
-     &CrossPointSettings::fontFamily,
+                      {"1 min", "5 min", "10 min", "15 min", "30 min"}),
-     {"Bookerly", "Noto Sans", "Open Dyslexic"}},
+    SettingInfo::Enum("Refresh Frequency", &CrossPointSettings::refreshFrequency,
-    {"Reader Font Size", SettingType::ENUM, &CrossPointSettings::fontSize, {"Small", "Medium", "Large", "X Large"}},
+                      {"1 page", "5 pages", "10 pages", "15 pages", "30 pages"}),
-    {"Reader Line Spacing", SettingType::ENUM, &CrossPointSettings::lineSpacing, {"Tight", "Normal", "Wide"}},
+    SettingInfo::Action("Check for updates")};
-    {"Reader Screen Margin", SettingType::ENUM, &CrossPointSettings::screenMargin, {"5", "10", "20", "40"}},
-    {"Reader Paragraph Alignment",
-     SettingType::ENUM,
-     &CrossPointSettings::paragraphAlignment,
-     {"Justify", "Left", "Center", "Right"}},
-    {"Time to Sleep",
-     SettingType::ENUM,
-     &CrossPointSettings::sleepTimeout,
-     {"1 min", "5 min", "10 min", "15 min", "30 min"}},
-    {"Refresh Frequency",
-     SettingType::ENUM,
-     &CrossPointSettings::refreshFrequency,
-     {"1 page", "5 pages", "10 pages", "15 pages", "30 pages"}},
-    {"Check for updates", SettingType::ACTION, nullptr, {}},
-};
 }  // namespace
 
 void SettingsActivity::taskTrampoline(void* param) {
@@ -58,7 +44,6 @@ void SettingsActivity::taskTrampoline(void* param) {
 
 void SettingsActivity::onEnter() {
   Activity::onEnter();
-
   renderingMutex = xSemaphoreCreateMutex();
 
   // Reset selection to first item
@@ -138,6 +123,14 @@ void SettingsActivity::toggleCurrentSetting() {
   } else if (setting.type == SettingType::ENUM && setting.valuePtr != nullptr) {
     const uint8_t currentValue = SETTINGS.*(setting.valuePtr);
     SETTINGS.*(setting.valuePtr) = (currentValue + 1) % static_cast<uint8_t>(setting.enumValues.size());
+  } else if (setting.type == SettingType::VALUE && setting.valuePtr != nullptr) {
+    const int8_t currentValue = SETTINGS.*(setting.valuePtr);
+    // Wrap to minValue if exceeding setting value boundary
+    if (currentValue == setting.maxValue) {
+      SETTINGS.*(setting.valuePtr) = setting.minValue;
+    } else {
+      SETTINGS.*(setting.valuePtr) = currentValue + 1;
+    }
   } else if (setting.type == SettingType::ACTION) {
     if (std::string(setting.name) == "Check for updates") {
       xSemaphoreTake(renderingMutex, portMAX_DELAY);
@@ -196,6 +189,8 @@ void SettingsActivity::render() const {
     } else if (settingsList[i].type == SettingType::ENUM && settingsList[i].valuePtr != nullptr) {
       const uint8_t value = SETTINGS.*(settingsList[i].valuePtr);
       valueText = settingsList[i].enumValues[value];
+    } else if (settingsList[i].type == SettingType::VALUE && settingsList[i].valuePtr != nullptr) {
+      valueText = std::to_string(SETTINGS.*(settingsList[i].valuePtr));
     }
     const auto width = renderer.getTextWidth(UI_10_FONT_ID, valueText.c_str());
     renderer.drawText(UI_10_FONT_ID, pageWidth - 20 - width, settingY, valueText.c_str(), i != selectedSettingIndex);

src/activities/settings/SettingsActivity.h

@@ -11,14 +11,33 @@
 
 class CrossPointSettings;
 
-enum class SettingType { TOGGLE, ENUM, ACTION };
+enum class SettingType { TOGGLE, ENUM, ACTION, VALUE };
 
 // Structure to hold setting information
 struct SettingInfo {
   const char* name;                        // Display name of the setting
   SettingType type;                        // Type of setting
-  uint8_t CrossPointSettings::* valuePtr;  // Pointer to member in CrossPointSettings (for TOGGLE/ENUM)
+  uint8_t CrossPointSettings::* valuePtr;  // Pointer to member in CrossPointSettings (for TOGGLE/ENUM/VALUE)
   std::vector<std::string> enumValues;
+
+  // Bounds for VALUE type settings
+  int8_t minValue;
+  uint8_t maxValue;
+
+  // Static constructors
+  static SettingInfo Toggle(const char* name, uint8_t CrossPointSettings::* ptr) {
+    return {name, SettingType::TOGGLE, ptr, {}, 0, 0};
+  }
+
+  static SettingInfo Enum(const char* name, uint8_t CrossPointSettings::* ptr, std::vector<std::string> values) {
+    return {name, SettingType::ENUM, ptr, std::move(values), 0, 0};
+  }
+
+  static SettingInfo Action(const char* name) { return {name, SettingType::ACTION, nullptr, {}, 0, 0}; }
+
+  static SettingInfo Value(const char* name, uint8_t CrossPointSettings::* ptr, int8_t minValue, uint8_t maxValue) {
+    return {name, SettingType::VALUE, ptr, {}, minValue, maxValue};
+  }
 };
 
 class SettingsActivity final : public ActivityWithSubactivity {