Add and refactor LyraCarouselTheme by zgredex

src/components/UITheme.h

@@ -18,6 +18,7 @@ class UITheme {
 
   const ThemeMetrics& getMetrics() const { return *currentMetrics; }
   const BaseTheme& getTheme() const { return *currentTheme; }
+  BaseTheme& getMutableTheme() { return *currentTheme; }
   void reload();
   void setTheme(CrossPointSettings::UI_THEME type);
   static int getNumberOfItemsPerPage(const GfxRenderer& renderer, bool hasHeader, bool hasTabBar, bool hasButtonHints,

src/components/themes/BaseTheme.h

@@ -4,9 +4,13 @@
 #include <cstdint>
 #include <functional>
 #include <string>
+#include <utility>
 #include <vector>
 
 class GfxRenderer;
+class Epub;
+class Txt;
+class Xtc;
 struct RecentBook;
 
 struct Rect {
@@ -48,6 +52,8 @@ struct ThemeMetrics {
   int homeCoverHeight;
   int homeCoverTileHeight;
   int homeRecentBooksCount;
+  bool homeContinueReadingInMenu = false;
+  int homeMenuTopOffset = 0;
 
   int buttonHintsHeight;
   int sideButtonHintsWidth;
@@ -67,12 +73,15 @@ struct ThemeMetrics {
   int keyboardVerticalOffset;
   int keyboardTextFieldWidthPercent;
   int keyboardWidthPercent;
+  int keyboardKeyCornerRadius = 0;
 };
 
 enum UIIcon { Folder, Text, Image, Book, File, Recent, Settings, Transfer, Library, Wifi, Hotspot, Weather };
 
 enum class KeyboardKeyType { Normal, Shift, Mode, Reveal, Space, Del, Ok, Disabled };
 
+enum class HomeNavigation { Linear, Carousel };
+
 // Default theme implementation (Classic Theme)
 // Additional themes can inherit from this and override methods as needed
 
@@ -159,9 +168,32 @@ class BaseTheme {
                                const char* secondaryLabel = nullptr, KeyboardKeyType keyType = KeyboardKeyType::Normal,
                                bool inactiveSelection = false) const;
   virtual bool showsFileIcons() const { return false; }
-  virtual void drawCarouselBorder(GfxRenderer& renderer, Rect coverRect, bool inCarouselRow) const {}
 
-  // Shared constants and helpers for battery drawing (used by all themes)
+  // ---- Home screen navigation / rendering contract ----
+
+  // Return Carousel to opt in to left/right book navigation and tryFastHomeRender().
+  virtual HomeNavigation getHomeNavigation() const { return HomeNavigation::Linear; }
+
+  // Return the cover thumbnail sizes this theme needs for its home screen.
+  // HomeActivity calls generateThumbBmp() for each pair. Empty = use height-only path.
+  virtual std::vector<std::pair<int, int>> getCoverThumbSizes(int coverHeight) const { return {}; }
+
+  // Attempt a full home-screen render from pre-cached state.
+  // Return true if the theme handled the render (HomeActivity must not draw anything else).
+  // Return false to fall through to the standard slow-path render in HomeActivity.
+  virtual bool tryFastHomeRender(GfxRenderer& renderer, const std::vector<RecentBook>& recentBooks, int selectorIndex,
+                                 int menuCount, const std::function<std::string(int)>& menuLabel,
+                                 const std::function<UIIcon(int)>& menuIcon, const char* hintBtn1, const char* hintBtn2,
+                                 const char* hintBtn3, const char* hintBtn4) const {
+    return false;
+  }
+
+  // Called by readers just before releasing the book object. Themes that cache
+  // cover thumbnails can generate them here while the book is still loaded.
+  // Only one of epub/xtc/txt will be non-null depending on the reader.
+  virtual void onBookWillClose(const std::string& path, Epub* epub, Xtc* xtc, Txt* txt) {}
+
+  // ---- Shared constants and helpers for battery drawing (used by all themes) ----
   static constexpr int batteryPercentSpacing = 4;
   static void drawBatteryOutline(const GfxRenderer& renderer, int x, int y, int battWidth, int rectHeight);
   static void drawBatteryLightningBolt(const GfxRenderer& renderer, int boltX, int boltY);

src/components/themes/lyra/LyraCarouselTheme.cpp

@@ -1,9 +1,17 @@
 #include "LyraCarouselTheme.h"
 
 #include <Bitmap.h>
+#include <Epub.h>
+#include <FsHelpers.h>
 #include <GfxRenderer.h>
 #include <HalStorage.h>
+#include <I18n.h>
+#include <Logging.h>
+#include <Txt.h>
+#include <Xtc.h>
 
+#include <algorithm>
+#include <cstring>
 #include <string>
 #include <vector>
 
@@ -70,6 +78,23 @@ const uint8_t* iconBitmapFor(UIIcon icon) {
       return nullptr;
   }
 }
+// ---------------------------------------------------------------------------
+// Static frame cache — survives HomeActivity re-creation so that returning to
+// home after settings doesn't re-read covers from SD.
+// Freed explicitly via invalidateFrameCache() before entering the reader.
+// ---------------------------------------------------------------------------
+constexpr int kFrameCount = 3;
+uint8_t* gCachedFrames[kFrameCount] = {};
+int gCachedFrameBookIdx[kFrameCount] = {-1, -1, -1};
+int gCachedFrameCount = 0;
+std::string gCacheKey;
+
+int findFrameSlot(int bookIdx) {
+  for (int i = 0; i < kFrameCount; ++i) {
+    if (gCachedFrameBookIdx[i] == bookIdx && gCachedFrames[i] != nullptr) return i;
+  }
+  return -1;
+}
 }  // namespace
 
 // ---------------------------------------------------------------------------
@@ -77,13 +102,159 @@ const uint8_t* iconBitmapFor(UIIcon icon) {
 // ---------------------------------------------------------------------------
 void LyraCarouselTheme::setPreRenderIndex(int idx) { lastCarouselSelectorIndex = idx; }
 
-void LyraCarouselTheme::drawCarouselBorder(GfxRenderer& renderer, Rect coverRect, bool inCarouselRow) const {
-  if (!inCarouselRow) return;
-  const int screenW = renderer.getScreenWidth();
-  const int centerX = (screenW - kCenterCoverMaxW) / 2;
-  const int centerTileY = coverRect.y + kCoverTopPad;
-  renderer.drawRoundedRect(centerX, centerTileY, kCenterCoverMaxW, kCenterCoverMaxH, kSelectionLineW, kCornerRadius,
-                           true);
+void LyraCarouselTheme::invalidateFrameCache() const {
+  for (int i = 0; i < kFrameCount; ++i) {
+    if (gCachedFrames[i]) {
+      free(gCachedFrames[i]);
+      gCachedFrames[i] = nullptr;
+    }
+    gCachedFrameBookIdx[i] = -1;
+  }
+  gCachedFrameCount = 0;
+  gCacheKey.clear();
+}
+
+void LyraCarouselTheme::onBookWillClose(const std::string& /*path*/, Epub* epub, Xtc* xtc, Txt* /*txt*/) {
+  if (epub) {
+    epub->generateThumbBmp(kCenterCoverW, kCenterCoverH);
+    epub->generateThumbBmp(kSideCoverW, kSideCoverH);
+  }
+  if (xtc) {
+    xtc->generateThumbBmp(kCenterCoverW, kCenterCoverH);
+    xtc->generateThumbBmp(kSideCoverW, kSideCoverH);
+  }
+  // txt files have no cover image — nothing to generate
+  invalidateFrameCache();
+}
+
+// ---------------------------------------------------------------------------
+// tryFastHomeRender — pre-renders carousel frames and composites them
+// ---------------------------------------------------------------------------
+namespace {
+void renderOneCarouselFrame(GfxRenderer& renderer, const std::vector<RecentBook>& recentBooks, int bookIdx, int slotIdx,
+                            const ThemeMetrics& metrics) {
+  if (!gCachedFrames[slotIdx]) return;
+  const int pageWidth = renderer.getScreenWidth();
+  const int bookCount = static_cast<int>(recentBooks.size());
+  bool d1 = false, d2 = false, d3 = false;
+
+  lastCarouselSelectorIndex = bookIdx;
+  renderer.clearScreen();
+  UITheme::getInstance().getTheme().drawHeader(renderer, Rect{0, metrics.topPadding, pageWidth, metrics.homeTopPadding},
+                                               nullptr);
+  UITheme::getInstance().getTheme().drawRecentBookCover(
+      renderer, Rect{0, metrics.homeTopPadding, pageWidth, metrics.homeCoverTileHeight}, recentBooks, bookCount, d1, d2,
+      d3, []() { return true; });
+
+  memcpy(gCachedFrames[slotIdx], renderer.getFrameBuffer(), renderer.getBufferSize());
+  gCachedFrameBookIdx[slotIdx] = bookIdx;
+}
+
+void updateSlidingWindow(GfxRenderer& renderer, const std::vector<RecentBook>& recentBooks, int centerIdx,
+                         const ThemeMetrics& metrics) {
+  const int bookCount = static_cast<int>(recentBooks.size());
+  if (bookCount <= kFrameCount || gCachedFrameCount == 0) return;
+
+  const int prevIdx = (centerIdx + bookCount - 1) % bookCount;
+  const int nextIdx = (centerIdx + 1) % bookCount;
+  const bool hasPrev = findFrameSlot(prevIdx) >= 0;
+  const bool hasNext = findFrameSlot(nextIdx) >= 0;
+  if (hasPrev && hasNext) return;
+
+  const int missingIdx = !hasPrev ? prevIdx : nextIdx;
+  int evictSlot = -1, maxDist = -1;
+  for (int i = 0; i < kFrameCount; ++i) {
+    if (!gCachedFrames[i]) continue;
+    const int b = gCachedFrameBookIdx[i];
+    if (b == centerIdx || (hasPrev && b == prevIdx) || (hasNext && b == nextIdx)) continue;
+    const int diff = std::abs(b - centerIdx);
+    const int dist = std::min(diff, bookCount - diff);
+    if (dist > maxDist) {
+      maxDist = dist;
+      evictSlot = i;
+    }
+  }
+  if (evictSlot >= 0) renderOneCarouselFrame(renderer, recentBooks, missingIdx, evictSlot, metrics);
+}
+}  // namespace
+
+bool LyraCarouselTheme::tryFastHomeRender(GfxRenderer& renderer, const std::vector<RecentBook>& recentBooks,
+                                          int selectorIndex, int menuCount,
+                                          const std::function<std::string(int)>& menuLabel,
+                                          const std::function<UIIcon(int)>& menuIcon, const char* hintBtn1,
+                                          const char* hintBtn2, const char* hintBtn3, const char* hintBtn4) const {
+  const int bookCount = static_cast<int>(recentBooks.size());
+  if (bookCount == 0) return false;
+
+  const auto& metrics = UITheme::getInstance().getMetrics();
+  const int pageWidth = renderer.getScreenWidth();
+  const int pageHeight = renderer.getScreenHeight();
+  const size_t bufferSize = renderer.getBufferSize();
+  uint8_t* frameBuffer = renderer.getFrameBuffer();
+  if (!frameBuffer) return false;
+
+  // Build cache key from book paths
+  std::string newKey;
+  newKey.reserve(128);
+  for (const auto& b : recentBooks) {
+    newKey += b.path;
+    newKey += '\0';
+  }
+
+  bool framesReady = (newKey == gCacheKey && gCachedFrameCount > 0);
+
+  if (!framesReady) {
+    // Free old cache and allocate fresh frames
+    invalidateFrameCache();
+    const int frameCount = std::min(bookCount, kFrameCount);
+    for (int i = 0; i < frameCount; ++i) {
+      gCachedFrames[i] = static_cast<uint8_t*>(malloc(bufferSize));
+      if (!gCachedFrames[i]) {
+        LOG_ERR("CAROUSEL", "tryFastHomeRender: malloc failed for frame %d", i);
+        invalidateFrameCache();
+        return false;
+      }
+    }
+    // Render only the initially-selected frame; neighbours are filled lazily.
+    const int initialIdx = (selectorIndex < bookCount) ? selectorIndex : 0;
+    renderOneCarouselFrame(renderer, recentBooks, initialIdx, 0, metrics);
+    gCachedFrameCount = frameCount;
+    gCacheKey = newKey;
+    framesReady = true;
+  }
+
+  const bool inCarouselRow = (selectorIndex < bookCount);
+  const int centerIdx =
+      inCarouselRow ? selectorIndex : (lastCarouselSelectorIndex >= 0 ? lastCarouselSelectorIndex : 0);
+  const int slotIdx = findFrameSlot(centerIdx);
+  if (slotIdx < 0 || !gCachedFrames[slotIdx]) return false;
+
+  memcpy(frameBuffer, gCachedFrames[slotIdx], bufferSize);
+
+  // Overlay the selection border when carousel row is active
+  if (inCarouselRow) {
+    const int screenW = renderer.getScreenWidth();
+    const int centerTileY = metrics.homeTopPadding + kCoverTopPad;
+    const int centerX = (screenW - kCenterCoverMaxW) / 2;
+    renderer.drawRoundedRect(centerX, centerTileY, kCenterCoverMaxW, kCenterCoverMaxH, kSelectionLineW, kCornerRadius,
+                             true);
+  }
+
+  // Menu row
+  const int menuIdx = inCarouselRow ? -1 : (selectorIndex - bookCount);
+  UITheme::getInstance().getTheme().drawButtonMenu(
+      renderer,
+      Rect{0, metrics.homeTopPadding + metrics.homeCoverTileHeight + metrics.verticalSpacing, pageWidth,
+           pageHeight - (metrics.headerHeight + metrics.homeTopPadding + metrics.verticalSpacing * 2 +
+                         metrics.buttonHintsHeight)},
+      menuCount, menuIdx, menuLabel, menuIcon);
+
+  // Button hints
+  UITheme::getInstance().getTheme().drawButtonHints(renderer, hintBtn1, hintBtn2, hintBtn3, hintBtn4);
+
+  renderer.displayBuffer();
+  updateSlidingWindow(renderer, recentBooks, centerIdx, metrics);
+  return true;
 }
 
 // ---------------------------------------------------------------------------
@@ -144,7 +315,6 @@ void LyraCarouselTheme::drawRecentBookCover(GfxRenderer& renderer, Rect rect,
           const float tileRatio = static_cast<float>(maxW) / static_cast<float>(maxH);
           const float cropX = (bmpRatio > tileRatio) ? (1.0f - tileRatio / bmpRatio) : 0.0f;
           renderer.drawBitmap(bitmap, x, y, maxW, maxH, cropX, 0.0f);
-          renderer.maskRoundedRectOutsideCorners(x, y, maxW, maxH, kCornerRadius, Color::White);
           hasCover = true;
         }
         file.close();

src/components/themes/lyra/LyraCarouselTheme.h

@@ -1,9 +1,15 @@
 
 #pragma once
 
+#include <utility>
+#include <vector>
+
 #include "components/themes/lyra/LyraTheme.h"
 
 class GfxRenderer;
+class Epub;
+class Txt;
+class Xtc;
 
 // Lyra Carousel theme metrics (zero runtime cost)
 namespace LyraCarouselMetrics {
@@ -56,13 +62,24 @@ class LyraCarouselTheme : public LyraTheme {
   static constexpr int kSideCoverH = LyraCarouselMetrics::values.homeCoverHeight - 210;  // 390
 
   static void setPreRenderIndex(int idx);
+
+  HomeNavigation getHomeNavigation() const override { return HomeNavigation::Carousel; }
+  std::vector<std::pair<int, int>> getCoverThumbSizes(int /*coverHeight*/) const override {
+    return {{kCenterCoverW, kCenterCoverH}, {kSideCoverW, kSideCoverH}};
+  }
+  bool tryFastHomeRender(GfxRenderer& renderer, const std::vector<RecentBook>& recentBooks, int selectorIndex,
+                         int menuCount, const std::function<std::string(int)>& menuLabel,
+                         const std::function<UIIcon(int)>& menuIcon, const char* hintBtn1, const char* hintBtn2,
+                         const char* hintBtn3, const char* hintBtn4) const override;
+  void onBookWillClose(const std::string& path, Epub* epub, Xtc* xtc, Txt* txt) override;
+  void invalidateFrameCache() const;
+
   void drawRecentBookCover(GfxRenderer& renderer, Rect rect, const std::vector<RecentBook>& recentBooks,
                            const int selectorIndex, bool& coverRendered, bool& coverBufferStored, bool& bufferRestored,
                            std::function<bool()> storeCoverBuffer) const override;
   void drawButtonMenu(GfxRenderer& renderer, Rect rect, int buttonCount, int selectedIndex,
                       const std::function<std::string(int index)>& buttonLabel,
                       const std::function<UIIcon(int index)>& rowIcon) const override;
-  void drawCarouselBorder(GfxRenderer& renderer, Rect coverRect, bool inCarouselRow) const override;
   void drawList(const GfxRenderer& renderer, Rect rect, int itemCount, int selectedIndex,
                 const std::function<std::string(int index)>& rowTitle,
                 const std::function<std::string(int index)>& rowSubtitle,