add settings for reader screen margin (#223)

## Summary

* **What is the goal of this PR?** 
* This PR adds a setting to control the top left and right margins of
the reader screen in 4 sizes (5, 10, 20, 40 pt?) and defaults to `SMALL`
which is equivalent to the fixed margin of 5 that was already in use
before.
* **What changes are included?**

## Additional Context

* Add any other information that might be helpful for the reviewer
(e.g., performance implications, potential risks, specific areas to
focus on).

---------

Co-authored-by: Dave Allie <dave@daveallie.com>

src/CrossPointSettings.cpp

@@ -12,7 +12,7 @@ CrossPointSettings CrossPointSettings::instance;
 namespace {
 constexpr uint8_t SETTINGS_FILE_VERSION = 1;
 // Increment this when adding new persisted settings fields
-constexpr uint8_t SETTINGS_COUNT = 13;
+constexpr uint8_t SETTINGS_COUNT = 14;
 constexpr char SETTINGS_FILE[] = "/.crosspoint/settings.bin";
 }  // namespace
 
@@ -40,6 +40,8 @@ bool CrossPointSettings::saveToFile() const {
   serialization::writePod(outputFile, paragraphAlignment);
   serialization::writePod(outputFile, sleepTimeout);
   serialization::writePod(outputFile, refreshFrequency);
+  serialization::writePod(outputFile, screenMargin);
+
   outputFile.close();
 
   Serial.printf("[%lu] [CPS] Settings saved to file\n", millis());
@@ -92,6 +94,9 @@ bool CrossPointSettings::loadFromFile() {
     if (++settingsRead >= fileSettingsCount) break;
     serialization::readPod(inputFile, refreshFrequency);
     if (++settingsRead >= fileSettingsCount) break;
+    serialization::readPod(inputFile, screenMargin);
+    if (++settingsRead >= fileSettingsCount) break;
+
   } while (false);
 
   inputFile.close();

src/CrossPointSettings.h

@@ -75,6 +75,9 @@ class CrossPointSettings {
   // E-ink refresh frequency (default 15 pages)
   uint8_t refreshFrequency = REFRESH_15;
 
+  // Reader screen margin settings
+  uint8_t screenMargin = 5;
+
   ~CrossPointSettings() = default;
 
   // Get singleton instance
@@ -89,6 +92,7 @@ class CrossPointSettings {
   float getReaderLineCompression() const;
   unsigned long getSleepTimeoutMs() const;
   int getRefreshFrequency() const;
+  int getReaderScreenMargin() const;
 };
 
 // Helper macro to access settings

src/activities/reader/EpubReaderActivity.cpp

@@ -16,8 +16,6 @@ namespace {
 // pagesPerRefresh now comes from SETTINGS.getRefreshFrequency()
 constexpr unsigned long skipChapterMs = 700;
 constexpr unsigned long goHomeMs = 1000;
-constexpr int topPadding = 5;
-constexpr int horizontalPadding = 5;
 constexpr int statusBarMargin = 19;
 }  // namespace
 
@@ -253,9 +251,9 @@ void EpubReaderActivity::renderScreen() {
   int orientedMarginTop, orientedMarginRight, orientedMarginBottom, orientedMarginLeft;
   renderer.getOrientedViewableTRBL(&orientedMarginTop, &orientedMarginRight, &orientedMarginBottom,
                                    &orientedMarginLeft);
-  orientedMarginTop += topPadding;
+  orientedMarginTop += SETTINGS.screenMargin;
-  orientedMarginLeft += horizontalPadding;
+  orientedMarginLeft += SETTINGS.screenMargin;
-  orientedMarginRight += horizontalPadding;
+  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"
@@ -9,45 +10,31 @@
 
 // Define the static settings list
 namespace {
-constexpr int settingsCount = 14;
+constexpr int settingsCount = 15;
 const SettingInfo settingsList[settingsCount] = {
     // Should match with SLEEP_SCREEN_MODE
-    {"Sleep Screen", SettingType::ENUM, &CrossPointSettings::sleepScreen, {"Dark", "Light", "Custom", "Cover", "None"}},
+    SettingInfo::Enum("Sleep Screen", &CrossPointSettings::sleepScreen, {"Dark", "Light", "Custom", "Cover", "None"}),
-    {"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, 40, 5}),
-     {"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 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) {
@@ -57,7 +44,6 @@ void SettingsActivity::taskTrampoline(void* param) {
 
 void SettingsActivity::onEnter() {
   Activity::onEnter();
-
   renderingMutex = xSemaphoreCreateMutex();
 
   // Reset selection to first item
@@ -67,7 +53,7 @@ void SettingsActivity::onEnter() {
   updateRequired = true;
 
   xTaskCreate(&SettingsActivity::taskTrampoline, "SettingsActivityTask",
-              2048,               // Stack size
+              4096,               // Stack size
               this,               // Parameters
               1,                  // Priority
               &displayTaskHandle  // Task handle
@@ -135,6 +121,15 @@ 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) {
+    // Decreasing would also be nice for large ranges I think but oh well can't have everything
+    const int8_t currentValue = SETTINGS.*(setting.valuePtr);
+    // Wrap to minValue if exceeding setting value boundary
+    if (currentValue + setting.valueRange.step > setting.valueRange.max) {
+      SETTINGS.*(setting.valuePtr) = setting.valueRange.min;
+    } else {
+      SETTINGS.*(setting.valuePtr) = currentValue + setting.valueRange.step;
+    }
   } else if (setting.type == SettingType::ACTION) {
     if (std::string(setting.name) == "Check for updates") {
       xSemaphoreTake(renderingMutex, portMAX_DELAY);
@@ -193,6 +188,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,37 @@
 
 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;
+
+  struct ValueRange {
+    uint8_t min;
+    uint8_t max;
+    uint8_t step;
+  };
+  // Bounds/step for VALUE type settings
+  ValueRange valueRange;
+
+  // Static constructors
+  static SettingInfo Toggle(const char* name, uint8_t CrossPointSettings::* ptr) {
+    return {name, SettingType::TOGGLE, ptr};
+  }
+
+  static SettingInfo Enum(const char* name, uint8_t CrossPointSettings::* ptr, std::vector<std::string> values) {
+    return {name, SettingType::ENUM, ptr, std::move(values)};
+  }
+
+  static SettingInfo Action(const char* name) { return {name, SettingType::ACTION, nullptr}; }
+
+  static SettingInfo Value(const char* name, uint8_t CrossPointSettings::* ptr, const ValueRange valueRange) {
+    return {name, SettingType::VALUE, ptr, {}, valueRange};
+  }
 };
 
 class SettingsActivity final : public ActivityWithSubactivity {