Parse cover image path from content.opf file (#24)

* white sleep screen

* quicker pwr button

* no extra spacing between paragraphs

* Added settings class with de/serialization and whiteSleepScreen setting to control inverting the sleep screen

* Added Settings screen for real, made settings a global singleton

* Added setting for extra paragraph spacing.

* fixed typo

* Rework after feedback

* Fixed type from bool to uint8

.github/workflows/ci.yml

@@ -1,5 +1,8 @@
 name: CI
-on: push
+'on':
+  push:
+    branches: [master]
+  pull_request:
 
 jobs:
   build:

lib/Epub/Epub.cpp

@@ -69,6 +69,9 @@ bool Epub::parseContentOpf(const std::string& contentOpfFilePath) {
 
   // Grab data from opfParser into epub
   title = opfParser.title;
+  if (!opfParser.coverItemId.empty() && opfParser.items.count(opfParser.coverItemId) > 0) {
+    coverImageItem = opfParser.items.at(opfParser.coverItemId);
+  }
 
   if (opfParser.items.count("ncx")) {
     tocNcxItem = opfParser.items.at("ncx");

lib/Epub/Epub/Section.cpp

@@ -9,7 +9,7 @@
 #include "Page.h"
 #include "parsers/ChapterHtmlSlimParser.h"
 
-constexpr uint8_t SECTION_FILE_VERSION = 4;
+constexpr uint8_t SECTION_FILE_VERSION = 5;
 
 void Section::onPageComplete(std::unique_ptr<Page> page) {
   const auto filePath = cachePath + "/page_" + std::to_string(pageCount) + ".bin";
@@ -24,7 +24,8 @@ void Section::onPageComplete(std::unique_ptr<Page> page) {
 }
 
 void Section::writeCacheMetadata(const int fontId, const float lineCompression, const int marginTop,
-                                 const int marginRight, const int marginBottom, const int marginLeft) const {
+                                 const int marginRight, const int marginBottom, const int marginLeft,
+                                 const bool extraParagraphSpacing) const {
   std::ofstream outputFile(("/sd" + cachePath + "/section.bin").c_str());
   serialization::writePod(outputFile, SECTION_FILE_VERSION);
   serialization::writePod(outputFile, fontId);
@@ -33,12 +34,14 @@ void Section::writeCacheMetadata(const int fontId, const float lineCompression,
   serialization::writePod(outputFile, marginRight);
   serialization::writePod(outputFile, marginBottom);
   serialization::writePod(outputFile, marginLeft);
+  serialization::writePod(outputFile, extraParagraphSpacing);
   serialization::writePod(outputFile, pageCount);
   outputFile.close();
 }
 
 bool Section::loadCacheMetadata(const int fontId, const float lineCompression, const int marginTop,
-                                const int marginRight, const int marginBottom, const int marginLeft) {
+                                const int marginRight, const int marginBottom, const int marginLeft,
+                                const bool extraParagraphSpacing) {
   if (!SD.exists(cachePath.c_str())) {
     return false;
   }
@@ -63,15 +66,18 @@ bool Section::loadCacheMetadata(const int fontId, const float lineCompression, c
 
     int fileFontId, fileMarginTop, fileMarginRight, fileMarginBottom, fileMarginLeft;
     float fileLineCompression;
+    bool fileExtraParagraphSpacing;
     serialization::readPod(inputFile, fileFontId);
     serialization::readPod(inputFile, fileLineCompression);
     serialization::readPod(inputFile, fileMarginTop);
     serialization::readPod(inputFile, fileMarginRight);
     serialization::readPod(inputFile, fileMarginBottom);
     serialization::readPod(inputFile, fileMarginLeft);
+    serialization::readPod(inputFile, fileExtraParagraphSpacing);
 
     if (fontId != fileFontId || lineCompression != fileLineCompression || marginTop != fileMarginTop ||
-        marginRight != fileMarginRight || marginBottom != fileMarginBottom || marginLeft != fileMarginLeft) {
+        marginRight != fileMarginRight || marginBottom != fileMarginBottom || marginLeft != fileMarginLeft ||
+        extraParagraphSpacing != fileExtraParagraphSpacing) {
       inputFile.close();
       Serial.printf("[%lu] [SCT] Deserialization failed: Parameters do not match\n", millis());
       clearCache();
@@ -107,7 +113,8 @@ bool Section::clearCache() const {
 }
 
 bool Section::persistPageDataToSD(const int fontId, const float lineCompression, const int marginTop,
-                                  const int marginRight, const int marginBottom, const int marginLeft) {
+                                  const int marginRight, const int marginBottom, const int marginLeft,
+                                  const bool extraParagraphSpacing) {
   const auto localPath = epub->getSpineItem(spineIndex);
 
   // TODO: Should we get rid of this file all together?
@@ -128,7 +135,7 @@ bool Section::persistPageDataToSD(const int fontId, const float lineCompression,
   const auto sdTmpHtmlPath = "/sd" + tmpHtmlPath;
 
   ChapterHtmlSlimParser visitor(sdTmpHtmlPath.c_str(), renderer, fontId, lineCompression, marginTop, marginRight,
-                                marginBottom, marginLeft,
+                                marginBottom, marginLeft, extraParagraphSpacing,
                                 [this](std::unique_ptr<Page> page) { this->onPageComplete(std::move(page)); });
   success = visitor.parseAndBuildPages();
 
@@ -138,7 +145,7 @@ bool Section::persistPageDataToSD(const int fontId, const float lineCompression,
     return false;
   }
 
-  writeCacheMetadata(fontId, lineCompression, marginTop, marginRight, marginBottom, marginLeft);
+  writeCacheMetadata(fontId, lineCompression, marginTop, marginRight, marginBottom, marginLeft, extraParagraphSpacing);
 
   return true;
 }

lib/Epub/Epub/Section.h

@@ -13,7 +13,7 @@ class Section {
   std::string cachePath;
 
   void writeCacheMetadata(int fontId, float lineCompression, int marginTop, int marginRight, int marginBottom,
-                          int marginLeft) const;
+                          int marginLeft, bool extraParagraphSpacing) const;
   void onPageComplete(std::unique_ptr<Page> page);
 
  public:
@@ -26,10 +26,10 @@ class Section {
   }
   ~Section() = default;
   bool loadCacheMetadata(int fontId, float lineCompression, int marginTop, int marginRight, int marginBottom,
-                         int marginLeft);
+                         int marginLeft, bool extraParagraphSpacing);
   void setupCacheDir() const;
   bool clearCache() const;
   bool persistPageDataToSD(int fontId, float lineCompression, int marginTop, int marginRight, int marginBottom,
-                           int marginLeft);
+                           int marginLeft, bool extraParagraphSpacing);
   std::unique_ptr<Page> loadPageFromSD() const;
 };

lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp

@@ -274,6 +274,8 @@ void ChapterHtmlSlimParser::makePages() {
   currentTextBlock->layoutAndExtractLines(
       renderer, fontId, marginLeft + marginRight,
       [this](const std::shared_ptr<TextBlock>& textBlock) { addLineToPage(textBlock); });
-  // Extra paragrpah spacing
+  // Extra paragraph spacing if enabled
-  currentPageNextY += lineHeight / 2;
+  if (extraParagraphSpacing) {
+    currentPageNextY += lineHeight / 2;
+  }
 }

lib/Epub/Epub/parsers/ChapterHtmlSlimParser.h

@@ -35,6 +35,7 @@ class ChapterHtmlSlimParser {
   int marginRight;
   int marginBottom;
   int marginLeft;
+  bool extraParagraphSpacing;
 
   void startNewTextBlock(TextBlock::BLOCK_STYLE style);
   void makePages();
@@ -46,7 +47,7 @@ class ChapterHtmlSlimParser {
  public:
   explicit ChapterHtmlSlimParser(const char* filepath, GfxRenderer& renderer, const int fontId,
                                  const float lineCompression, const int marginTop, const int marginRight,
-                                 const int marginBottom, const int marginLeft,
+                                 const int marginBottom, const int marginLeft, const bool extraParagraphSpacing,
                                  const std::function<void(std::unique_ptr<Page>)>& completePageFn)
       : filepath(filepath),
         renderer(renderer),
@@ -56,6 +57,7 @@ class ChapterHtmlSlimParser {
         marginRight(marginRight),
         marginBottom(marginBottom),
         marginLeft(marginLeft),
+        extraParagraphSpacing(extraParagraphSpacing),
         completePageFn(completePageFn) {}
   ~ChapterHtmlSlimParser() = default;
   bool parseAndBuildPages();

lib/Epub/Epub/parsers/ContentOpfParser.cpp

@@ -90,9 +90,23 @@ void XMLCALL ContentOpfParser::startElement(void* userData, const XML_Char* name
     return;
   }
 
-  // TODO: Support book cover
+  if (self->state == IN_METADATA && (strcmp(name, "meta") == 0 || strcmp(name, "opf:meta") == 0)) {
-  // if (self->state == IN_METADATA && (strcmp(name, "meta") == 0 || strcmp(name, "opf:meta") == 0)) {
+    bool isCover = false;
-  // }
+    std::string coverItemId;
+
+    for (int i = 0; atts[i]; i += 2) {
+      if (strcmp(atts[i], "name") == 0 && strcmp(atts[i + 1], "cover") == 0) {
+        isCover = true;
+      } else if (strcmp(atts[i], "content") == 0) {
+        coverItemId = atts[i + 1];
+      }
+    }
+
+    if (isCover) {
+      self->coverItemId = coverItemId;
+    }
+    return;
+  }
 
   if (self->state == IN_MANIFEST && (strcmp(name, "item") == 0 || strcmp(name, "opf:item") == 0)) {
     std::string itemId;

lib/Epub/Epub/parsers/ContentOpfParser.h

@@ -28,6 +28,7 @@ class ContentOpfParser final : public Print {
  public:
   std::string title;
   std::string tocNcxPath;
+  std::string coverItemId;
   std::map<std::string, std::string> items;
   std::vector<std::string> spineRefs;
 

lib/GfxRenderer/GfxRenderer.cpp

@@ -207,14 +207,20 @@ void GfxRenderer::renderChar(const EpdFontFamily& fontFamily, const uint32_t cp,
         if (is2Bit) {
           const uint8_t byte = bitmap[pixelPosition / 4];
           const uint8_t bit_index = (3 - pixelPosition % 4) * 2;
+          // the direct bit from the font is 0 -> white, 1 -> light gray, 2 -> dark gray, 3 -> black
+          // we swap this to better match the way images and screen think about colors:
+          // 0 -> black, 1 -> dark grey, 2 -> light grey, 3 -> white
+          const uint8_t bmpVal = 3 - (byte >> bit_index) & 0x3;
 
-          const uint8_t val = (byte >> bit_index) & 0x3;
+          if (renderMode == BW && bmpVal < 3) {
-          if (fontRenderMode == BW && val > 0) {
+            // Black (also paints over the grays in BW mode)
             drawPixel(screenX, screenY, pixelState);
-          } else if (fontRenderMode == GRAYSCALE_MSB && val == 1) {
+          } else if (renderMode == GRAYSCALE_MSB && (bmpVal == 1 || bmpVal == 2)) {
-            // TODO: Not sure how this anti-aliasing goes on black backgrounds
+            // Light gray (also mark the MSB if it's going to be a dark gray too)
+            // We have to flag pixels in reverse for the gray buffers, as 0 leave alone, 1 update
             drawPixel(screenX, screenY, false);
-          } else if (fontRenderMode == GRAYSCALE_LSB && val == 2) {
+          } else if (renderMode == GRAYSCALE_LSB && bmpVal == 1) {
+            // Dark gray
             drawPixel(screenX, screenY, false);
           }
         } else {

lib/GfxRenderer/GfxRenderer.h

@@ -7,17 +7,17 @@
 
 class GfxRenderer {
  public:
-  enum FontRenderMode { BW, GRAYSCALE_LSB, GRAYSCALE_MSB };
+  enum RenderMode { BW, GRAYSCALE_LSB, GRAYSCALE_MSB };
 
  private:
   EInkDisplay& einkDisplay;
-  FontRenderMode fontRenderMode;
+  RenderMode renderMode;
   std::map<int, EpdFontFamily> fontMap;
   void renderChar(const EpdFontFamily& fontFamily, uint32_t cp, int* x, const int* y, bool pixelState,
                   EpdFontStyle style) const;
 
  public:
-  explicit GfxRenderer(EInkDisplay& einkDisplay) : einkDisplay(einkDisplay), fontRenderMode(BW) {}
+  explicit GfxRenderer(EInkDisplay& einkDisplay) : einkDisplay(einkDisplay), renderMode(BW) {}
   ~GfxRenderer() = default;
 
   // Setup
@@ -41,15 +41,17 @@ class GfxRenderer {
   int getTextWidth(int fontId, const char* text, EpdFontStyle style = REGULAR) const;
   void drawCenteredText(int fontId, int y, const char* text, bool black = true, EpdFontStyle style = REGULAR) const;
   void drawText(int fontId, int x, int y, const char* text, bool black = true, EpdFontStyle style = REGULAR) const;
-  void setFontRenderMode(const FontRenderMode mode) { this->fontRenderMode = mode; }
   int getSpaceWidth(int fontId) const;
   int getLineHeight(int fontId) const;
 
+  // Grayscale functions
+  void setRenderMode(const RenderMode mode) { this->renderMode = mode; }
+  void copyGrayscaleLsbBuffers() const;
+  void copyGrayscaleMsbBuffers() const;
+  void displayGrayBuffer() const;
+
   // Low level functions
   uint8_t* getFrameBuffer() const;
   void swapBuffers() const;
   void grayscaleRevert() const;
-  void copyGrayscaleLsbBuffers() const;
-  void copyGrayscaleMsbBuffers() const;
-  void displayGrayBuffer() const;
 };

open-x4-sdk

@@ -1 +1 @@
-Subproject commit 7e0dce916706da7d80ec225fade191aea6b87fb6
+Subproject commit 4d0dcd5ff87fcd86eb2966a123e85b03284a03db

src/CrossPointSettings.cpp

@@ -0,0 +1,65 @@
+#include "CrossPointSettings.h"
+
+#include <HardwareSerial.h>
+#include <SD.h>
+#include <Serialization.h>
+
+#include <cstdint>
+#include <fstream>
+
+// Initialize the static instance
+CrossPointSettings CrossPointSettings::instance;
+
+constexpr uint8_t SETTINGS_FILE_VERSION = 1;
+constexpr uint8_t SETTINGS_COUNT = 2;
+constexpr char SETTINGS_FILE[] = "/sd/.crosspoint/settings.bin";
+
+bool CrossPointSettings::saveToFile() const {
+  // Make sure the directory exists
+  SD.mkdir("/.crosspoint");
+
+  std::ofstream outputFile(SETTINGS_FILE);
+  serialization::writePod(outputFile, SETTINGS_FILE_VERSION);
+  serialization::writePod(outputFile, SETTINGS_COUNT);
+  serialization::writePod(outputFile, whiteSleepScreen);
+  serialization::writePod(outputFile, extraParagraphSpacing);
+  outputFile.close();
+
+  Serial.printf("[%lu] [CPS] Settings saved to file\n", millis());
+  return true;
+}
+
+bool CrossPointSettings::loadFromFile() {
+  if (!SD.exists(SETTINGS_FILE + 3)) {  // +3 to skip "/sd" prefix
+    Serial.printf("[%lu] [CPS] Settings file does not exist, using defaults\n", millis());
+    return false;
+  }
+
+  std::ifstream inputFile(SETTINGS_FILE);
+
+  uint8_t version;
+  serialization::readPod(inputFile, version);
+  if (version != SETTINGS_FILE_VERSION) {
+    Serial.printf("[%lu] [CPS] Deserialization failed: Unknown version %u\n", millis(), version);
+    inputFile.close();
+    return false;
+  }
+
+  uint8_t fileSettingsCount = 0;
+  serialization::readPod(inputFile, fileSettingsCount);
+
+  // load settings that exist
+  switch (fileSettingsCount) {
+    case 1:
+      serialization::readPod(inputFile, whiteSleepScreen);
+      break;
+    case 2:
+      serialization::readPod(inputFile, whiteSleepScreen);
+      serialization::readPod(inputFile, extraParagraphSpacing);
+      break;
+  }
+
+  inputFile.close();
+  Serial.printf("[%lu] [CPS] Settings loaded from file\n", millis());
+  return true;
+}

src/CrossPointSettings.h

@@ -0,0 +1,34 @@
+#pragma once
+#include <cstdint>
+#include <iosfwd>
+
+class CrossPointSettings {
+ private:
+  // Private constructor for singleton
+  CrossPointSettings() = default;
+
+  // Static instance
+  static CrossPointSettings instance;
+
+ public:
+  // Delete copy constructor and assignment
+  CrossPointSettings(const CrossPointSettings&) = delete;
+  CrossPointSettings& operator=(const CrossPointSettings&) = delete;
+
+  // Sleep screen settings
+  uint8_t whiteSleepScreen = 0;
+
+  // Text rendering settings
+  uint8_t extraParagraphSpacing = 1;
+
+  ~CrossPointSettings() = default;
+
+  // Get singleton instance
+  static CrossPointSettings& getInstance() { return instance; }
+
+  bool saveToFile() const;
+  bool loadFromFile();
+};
+
+// Helper macro to access settings
+#define SETTINGS CrossPointSettings::getInstance()

src/main.cpp

@@ -14,12 +14,14 @@
 #include <builtinFonts/ubuntu_bold_10.h>
 
 #include "Battery.h"
+#include "CrossPointSettings.h"
 #include "CrossPointState.h"
 #include "config.h"
 #include "screens/BootLogoScreen.h"
 #include "screens/EpubReaderScreen.h"
 #include "screens/FileSelectionScreen.h"
 #include "screens/FullScreenMessageScreen.h"
+#include "screens/SettingsScreen.h"
 #include "screens/SleepScreen.h"
 
 #define SPI_FQ 40000000
@@ -58,9 +60,9 @@ EpdFontFamily ubuntuFontFamily(&ubuntu10Font, &ubuntuBold10Font);
 
 // Power button timing
 // Time required to confirm boot from sleep
-constexpr unsigned long POWER_BUTTON_WAKEUP_MS = 1000;
+constexpr unsigned long POWER_BUTTON_WAKEUP_MS = 500;
 // Time required to enter sleep mode
-constexpr unsigned long POWER_BUTTON_SLEEP_MS = 1000;
+constexpr unsigned long POWER_BUTTON_SLEEP_MS = 500;
 
 std::unique_ptr<Epub> loadEpub(const std::string& path) {
   if (!SD.exists(path.c_str())) {
@@ -165,9 +167,14 @@ void onSelectEpubFile(const std::string& path) {
   }
 }
 
+void onGoToSettings() {
+  exitScreen();
+  enterNewScreen(new SettingsScreen(renderer, inputManager, onGoHome));
+}
+
 void onGoHome() {
   exitScreen();
-  enterNewScreen(new FileSelectionScreen(renderer, inputManager, onSelectEpubFile));
+  enterNewScreen(new FileSelectionScreen(renderer, inputManager, onSelectEpubFile, onGoToSettings));
 }
 
 void setup() {
@@ -199,6 +206,7 @@ void setup() {
   // SD Card Initialization
   SD.begin(SD_SPI_CS, SPI, SPI_FQ);
 
+  SETTINGS.loadFromFile();
   appState.loadFromFile();
   if (!appState.openEpubPath.empty()) {
     auto epub = loadEpub(appState.openEpubPath);
@@ -212,7 +220,7 @@ void setup() {
   }
 
   exitScreen();
-  enterNewScreen(new FileSelectionScreen(renderer, inputManager, onSelectEpubFile));
+  enterNewScreen(new FileSelectionScreen(renderer, inputManager, onSelectEpubFile, onGoToSettings));
 
   // Ensure we're not still holding the power button before leaving setup
   waitForPowerRelease();

src/screens/EpubReaderScreen.cpp

@@ -5,6 +5,7 @@
 #include <SD.h>
 
 #include "Battery.h"
+#include "CrossPointSettings.h"
 #include "EpubReaderChapterSelectionScreen.h"
 #include "config.h"
 
@@ -204,8 +205,8 @@ void EpubReaderScreen::renderScreen() {
     const auto filepath = epub->getSpineItem(currentSpineIndex);
     Serial.printf("[%lu] [ERS] Loading file: %s, index: %d\n", millis(), filepath.c_str(), currentSpineIndex);
     section = std::unique_ptr<Section>(new Section(epub, currentSpineIndex, renderer));
-    if (!section->loadCacheMetadata(READER_FONT_ID, lineCompression, marginTop, marginRight, marginBottom,
+    if (!section->loadCacheMetadata(READER_FONT_ID, lineCompression, marginTop, marginRight, marginBottom, marginLeft,
-                                    marginLeft)) {
+                                    SETTINGS.extraParagraphSpacing)) {
       Serial.printf("[%lu] [ERS] Cache not found, building...\n", millis());
 
       {
@@ -228,7 +229,7 @@ void EpubReaderScreen::renderScreen() {
 
       section->setupCacheDir();
       if (!section->persistPageDataToSD(READER_FONT_ID, lineCompression, marginTop, marginRight, marginBottom,
-                                        marginLeft)) {
+                                        marginLeft, SETTINGS.extraParagraphSpacing)) {
         Serial.printf("[%lu] [ERS] Failed to persist page data to SD\n", millis());
         section.reset();
         return;
@@ -300,19 +301,19 @@ void EpubReaderScreen::renderContents(std::unique_ptr<Page> page) {
   // TODO: Only do this if font supports it
   {
     renderer.clearScreen(0x00);
-    renderer.setFontRenderMode(GfxRenderer::GRAYSCALE_LSB);
+    renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB);
     page->render(renderer, READER_FONT_ID);
     renderer.copyGrayscaleLsbBuffers();
 
     // Render and copy to MSB buffer
     renderer.clearScreen(0x00);
-    renderer.setFontRenderMode(GfxRenderer::GRAYSCALE_MSB);
+    renderer.setRenderMode(GfxRenderer::GRAYSCALE_MSB);
     page->render(renderer, READER_FONT_ID);
     renderer.copyGrayscaleMsbBuffers();
 
     // display grayscale part
     renderer.displayGrayBuffer();
-    renderer.setFontRenderMode(GfxRenderer::BW);
+    renderer.setRenderMode(GfxRenderer::BW);
   }
 }
 

src/screens/FileSelectionScreen.cpp

@@ -91,11 +91,16 @@ void FileSelectionScreen::handleInput() {
     } else {
       onSelect(basepath + files[selectorIndex]);
     }
-  } else if (inputManager.wasPressed(InputManager::BTN_BACK) && basepath != "/") {
+  } else if (inputManager.wasPressed(InputManager::BTN_BACK)) {
-    basepath = basepath.substr(0, basepath.rfind('/'));
+    if (basepath != "/") {
-    if (basepath.empty()) basepath = "/";
+      basepath = basepath.substr(0, basepath.rfind('/'));
-    loadFiles();
+      if (basepath.empty()) basepath = "/";
-    updateRequired = true;
+      loadFiles();
+      updateRequired = true;
+    } else {
+      // At root level, go to settings
+      onSettingsOpen();
+    }
   } else if (prevPressed) {
     selectorIndex = (selectorIndex + files.size() - 1) % files.size();
     updateRequired = true;
@@ -123,6 +128,9 @@ void FileSelectionScreen::render() const {
   const auto pageWidth = GfxRenderer::getScreenWidth();
   renderer.drawCenteredText(READER_FONT_ID, 10, "CrossPoint Reader", true, BOLD);
 
+  // Help text
+  renderer.drawText(SMALL_FONT_ID, 20, GfxRenderer::getScreenHeight() - 30, "Press BACK for Settings");
+
   if (files.empty()) {
     renderer.drawText(UI_FONT_ID, 20, 60, "No EPUBs found");
   } else {

src/screens/FileSelectionScreen.h

@@ -17,6 +17,7 @@ class FileSelectionScreen final : public Screen {
   int selectorIndex = 0;
   bool updateRequired = false;
   const std::function<void(const std::string&)> onSelect;
+  const std::function<void()> onSettingsOpen;
 
   static void taskTrampoline(void* param);
   [[noreturn]] void displayTaskLoop();
@@ -25,8 +26,9 @@ class FileSelectionScreen final : public Screen {
 
  public:
   explicit FileSelectionScreen(GfxRenderer& renderer, InputManager& inputManager,
-                               const std::function<void(const std::string&)>& onSelect)
+                               const std::function<void(const std::string&)>& onSelect,
-      : Screen(renderer, inputManager), onSelect(onSelect) {}
+                               const std::function<void()>& onSettingsOpen)
+      : Screen(renderer, inputManager), onSelect(onSelect), onSettingsOpen(onSettingsOpen) {}
   void onEnter() override;
   void onExit() override;
   void handleInput() override;

src/screens/SettingsScreen.cpp

@@ -0,0 +1,139 @@
+#include "SettingsScreen.h"
+
+#include <GfxRenderer.h>
+
+#include "CrossPointSettings.h"
+#include "config.h"
+
+// Define the static settings list
+
+const SettingInfo SettingsScreen::settingsList[SettingsScreen::settingsCount] = {
+    {"White Sleep Screen", &CrossPointSettings::whiteSleepScreen},
+    {"Extra Paragraph Spacing", &CrossPointSettings::extraParagraphSpacing}};
+
+void SettingsScreen::taskTrampoline(void* param) {
+  auto* self = static_cast<SettingsScreen*>(param);
+  self->displayTaskLoop();
+}
+
+void SettingsScreen::onEnter() {
+  renderingMutex = xSemaphoreCreateMutex();
+
+  // Reset selection to first item
+  selectedSettingIndex = 0;
+
+  // Trigger first update
+  updateRequired = true;
+
+  xTaskCreate(&SettingsScreen::taskTrampoline, "SettingsScreenTask",
+              2048,               // Stack size
+              this,               // Parameters
+              1,                  // Priority
+              &displayTaskHandle  // Task handle
+  );
+}
+
+void SettingsScreen::onExit() {
+  // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+  }
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+}
+
+void SettingsScreen::handleInput() {
+  // Check for Confirm button to toggle setting
+  if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
+    // Toggle the current setting
+    toggleCurrentSetting();
+
+    // Trigger a redraw of the entire screen
+    updateRequired = true;
+    return;  // Return early to prevent further processing
+  }
+
+  // Check for Back button to exit settings
+  if (inputManager.wasPressed(InputManager::BTN_BACK)) {
+    // Save settings and exit
+    SETTINGS.saveToFile();
+    onGoHome();
+    return;
+  }
+
+  // Handle UP/DOWN navigation for multiple settings
+  if (inputManager.wasPressed(InputManager::BTN_UP) || inputManager.wasPressed(InputManager::BTN_LEFT)) {
+    // Move selection up
+    if (selectedSettingIndex > 0) {
+      selectedSettingIndex--;
+      updateRequired = true;
+    }
+  } else if (inputManager.wasPressed(InputManager::BTN_DOWN) || inputManager.wasPressed(InputManager::BTN_RIGHT)) {
+    // Move selection down
+    if (selectedSettingIndex < settingsCount - 1) {
+      selectedSettingIndex++;
+      updateRequired = true;
+    }
+  }
+}
+
+void SettingsScreen::toggleCurrentSetting() {
+  // Validate index
+  if (selectedSettingIndex < 0 || selectedSettingIndex >= settingsCount) {
+    return;
+  }
+
+  // Toggle the boolean value using the member pointer
+  bool currentValue = SETTINGS.*(settingsList[selectedSettingIndex].valuePtr);
+  SETTINGS.*(settingsList[selectedSettingIndex].valuePtr) = !currentValue;
+
+  // Save settings when they change
+  SETTINGS.saveToFile();
+}
+
+void SettingsScreen::displayTaskLoop() {
+  while (true) {
+    if (updateRequired) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      render();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+void SettingsScreen::render() const {
+  renderer.clearScreen();
+
+  const auto pageWidth = GfxRenderer::getScreenWidth();
+  const auto pageHeight = GfxRenderer::getScreenHeight();
+
+  // Draw header
+  renderer.drawCenteredText(READER_FONT_ID, 10, "Settings", true, BOLD);
+
+  // We always have at least one setting
+
+  // Draw all settings
+  for (int i = 0; i < settingsCount; i++) {
+    const int settingY = 60 + i * 30;  // 30 pixels between settings
+
+    // Draw selection indicator for the selected setting
+    if (i == selectedSettingIndex) {
+      renderer.drawText(UI_FONT_ID, 5, settingY, ">");
+    }
+
+    // Draw setting name and value
+    renderer.drawText(UI_FONT_ID, 20, settingY, settingsList[i].name);
+    bool value = SETTINGS.*(settingsList[i].valuePtr);
+    renderer.drawText(UI_FONT_ID, pageWidth - 80, settingY, value ? "ON" : "OFF");
+  }
+
+  // Draw help text
+  renderer.drawText(SMALL_FONT_ID, 20, pageHeight - 30, "Press OK to toggle, BACK to save & exit");
+
+  // Always use standard refresh for settings screen
+  renderer.displayBuffer();
+}

src/screens/SettingsScreen.h

@@ -0,0 +1,42 @@
+#pragma once
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "Screen.h"
+
+class CrossPointSettings;
+
+// Structure to hold setting information
+struct SettingInfo {
+  const char* name;                        // Display name of the setting
+  uint8_t CrossPointSettings::* valuePtr;  // Pointer to member in CrossPointSettings
+};
+
+class SettingsScreen final : public Screen {
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  bool updateRequired = false;
+  int selectedSettingIndex = 0;  // Currently selected setting
+  const std::function<void()> onGoHome;
+
+  // Static settings list
+  static constexpr int settingsCount = 2;  // Number of settings
+  static const SettingInfo settingsList[settingsCount];
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void render() const;
+  void toggleCurrentSetting();
+
+ public:
+  explicit SettingsScreen(GfxRenderer& renderer, InputManager& inputManager, const std::function<void()>& onGoHome)
+      : Screen(renderer, inputManager), onGoHome(onGoHome) {}
+  void onEnter() override;
+  void onExit() override;
+  void handleInput() override;
+};

src/screens/SleepScreen.cpp

@@ -2,6 +2,7 @@
 
 #include <GfxRenderer.h>
 
+#include "CrossPointSettings.h"
 #include "config.h"
 #include "images/CrossLarge.h"
 
@@ -13,6 +14,11 @@ void SleepScreen::onEnter() {
   renderer.drawImage(CrossLarge, (pageWidth - 128) / 2, (pageHeight - 128) / 2, 128, 128);
   renderer.drawCenteredText(UI_FONT_ID, pageHeight / 2 + 70, "CrossPoint", true, BOLD);
   renderer.drawCenteredText(SMALL_FONT_ID, pageHeight / 2 + 95, "SLEEPING");
-  renderer.invertScreen();
+
+  // Apply white screen if enabled in settings
+  if (!SETTINGS.whiteSleepScreen) {
+    renderer.invertScreen();
+  }
+
   renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
 }