Something went wrong. Try again.
A fork of https://github.com/crosspoint-reader/crosspoint-reader
Something went wrong. Try again.
27 kB · 597 lines
C++
at master
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598#include "LyraTheme.h"
#include <GfxRenderer.h>#include <HalGPIO.h>#include <HalPowerManager.h>#include <HalStorage.h>#include <I18n.h>
#include <cstdint>#include <string>#include <vector>
#include "RecentBooksStore.h"#include "components/UITheme.h"#include "components/icons/book.h"#include "components/icons/book24.h"#include "components/icons/cover.h"#include "components/icons/file24.h"#include "components/icons/folder.h"#include "components/icons/folder24.h"#include "components/icons/hotspot.h"#include "components/icons/image24.h"#include "components/icons/library.h"#include "components/icons/recent.h"#include "components/icons/settings2.h"#include "components/icons/text24.h"#include "components/icons/transfer.h"#include "components/icons/wifi.h"#include "fontIds.h"
// Internal constantsnamespace {constexpr int hPaddingInSelection = 8;constexpr int cornerRadius = 6;constexpr int topHintButtonY = 345;constexpr int popupMarginX = 16;constexpr int popupMarginY = 12;constexpr int maxListValueWidth = 200;constexpr int mainMenuIconSize = 32;constexpr int listIconSize = 24;constexpr int mainMenuColumns = 2;int coverWidth = 0;
void drawLyraBatteryIcon(const GfxRenderer& renderer, int x, int y, int battWidth, int rectHeight, uint16_t percentage) { BaseTheme::drawBatteryOutline(renderer, x, y, battWidth, rectHeight);
const bool charging = gpio.isUsbConnected();
if (charging) { // Draw solid fill when charging so lightning bolt is visible renderer.fillRect(x + 2, y + 2, battWidth - 5, rectHeight - 4); BaseTheme::drawBatteryLightningBolt(renderer, x + 4, y + 2); } else { // Draw bars when not charging if (percentage > 10) { renderer.fillRect(x + 2, y + 2, 3, rectHeight - 4); } if (percentage > 40) { renderer.fillRect(x + 6, y + 2, 3, rectHeight - 4); } if (percentage > 70) { renderer.fillRect(x + 10, y + 2, 3, rectHeight - 4); } }}
const uint8_t* iconForName(UIIcon icon, int size) { if (size == 24) { switch (icon) { case UIIcon::Folder: return Folder24Icon; case UIIcon::Text: return Text24Icon; case UIIcon::Image: return Image24Icon; case UIIcon::Book: return Book24Icon; case UIIcon::File: return File24Icon; default: return nullptr; } } else if (size == 32) { switch (icon) { case UIIcon::Folder: return FolderIcon; case UIIcon::Book: return BookIcon; case UIIcon::Recent: return RecentIcon; case UIIcon::Settings: return Settings2Icon; case UIIcon::Transfer: return TransferIcon; case UIIcon::Library: return LibraryIcon; case UIIcon::Wifi: return WifiIcon; case UIIcon::Hotspot: return HotspotIcon; default: return nullptr; } } return nullptr;}} // namespace
void LyraTheme::drawBatteryLeft(const GfxRenderer& renderer, Rect rect, const bool showPercentage) const { // Left aligned: icon on left, percentage on right (reader mode) const uint16_t percentage = powerManager.getBatteryPercentage();
if (showPercentage) { const auto percentageText = std::to_string(percentage) + "%"; renderer.drawText(SMALL_FONT_ID, rect.x + BaseTheme::batteryPercentSpacing + LyraMetrics::values.batteryWidth, rect.y, percentageText.c_str()); }
drawLyraBatteryIcon(renderer, rect.x, rect.y + 6, LyraMetrics::values.batteryWidth, rect.height, percentage);}
void LyraTheme::drawBatteryRight(const GfxRenderer& renderer, Rect rect, const bool showPercentage) const { // Right aligned: percentage on left, icon on right (UI headers) const uint16_t percentage = powerManager.getBatteryPercentage();
if (showPercentage) { const auto percentageText = std::to_string(percentage) + "%"; const int textWidth = renderer.getTextWidth(SMALL_FONT_ID, percentageText.c_str()); // Clear the area where we're going to draw the text to prevent ghosting const auto textHeight = renderer.getTextHeight(SMALL_FONT_ID); renderer.fillRect(rect.x - textWidth - BaseTheme::batteryPercentSpacing, rect.y, textWidth, textHeight, false); // Draw text to the left of the icon renderer.drawText(SMALL_FONT_ID, rect.x - textWidth - BaseTheme::batteryPercentSpacing, rect.y, percentageText.c_str()); }
drawLyraBatteryIcon(renderer, rect.x, rect.y + 6, LyraMetrics::values.batteryWidth, rect.height, percentage);}
void LyraTheme::drawHeader(const GfxRenderer& renderer, Rect rect, const char* title, const char* subtitle) const { renderer.fillRect(rect.x, rect.y, rect.width, rect.height, false);
const bool showBatteryPercentage = SETTINGS.hideBatteryPercentage != CrossPointSettings::HIDE_BATTERY_PERCENTAGE::HIDE_ALWAYS; // Position icon at right edge, drawBatteryRight will place text to the left const int batteryX = rect.x + rect.width - 12 - LyraMetrics::values.batteryWidth; drawBatteryRight(renderer, Rect{batteryX, rect.y + 5, LyraMetrics::values.batteryWidth, LyraMetrics::values.batteryHeight}, showBatteryPercentage);
int maxTitleWidth = title != nullptr ? renderer.getTextWidth(UI_12_FONT_ID, title, EpdFontFamily::BOLD) : 0; int maxSubtitleWidth = subtitle != nullptr ? renderer.getTextWidth(SMALL_FONT_ID, subtitle, EpdFontFamily::REGULAR) : 0;
// Available space is the distance between the side paddings, and a with side padding between title and subtitle. const int availableSpace = rect.width - LyraMetrics::values.contentSidePadding * 3;
if (maxTitleWidth + maxSubtitleWidth > availableSpace) { if ((maxTitleWidth > availableSpace / 2) && (maxSubtitleWidth > availableSpace / 2)) { // Both are wider then half the space, truncate both. maxTitleWidth = availableSpace / 2; maxSubtitleWidth = availableSpace / 2; } else { // Truncate the the longest one if (maxTitleWidth > maxSubtitleWidth) { maxTitleWidth = availableSpace - maxSubtitleWidth; } else { maxSubtitleWidth = availableSpace - maxTitleWidth; } } }
if (title) { auto truncatedTitle = renderer.truncatedText(UI_12_FONT_ID, title, maxTitleWidth, EpdFontFamily::BOLD); renderer.drawText(UI_12_FONT_ID, rect.x + LyraMetrics::values.contentSidePadding, rect.y + LyraMetrics::values.batteryBarHeight + 3, truncatedTitle.c_str(), true, EpdFontFamily::BOLD); renderer.drawLine(rect.x, rect.y + rect.height - 3, rect.x + rect.width - 1, rect.y + rect.height - 3, 3, true); }
if (subtitle) { auto truncatedSubtitle = renderer.truncatedText(SMALL_FONT_ID, subtitle, maxSubtitleWidth, EpdFontFamily::REGULAR); int truncatedSubtitleWidth = renderer.getTextWidth(SMALL_FONT_ID, truncatedSubtitle.c_str()); renderer.drawText(SMALL_FONT_ID, rect.x + rect.width - LyraMetrics::values.contentSidePadding - truncatedSubtitleWidth, rect.y + 50, truncatedSubtitle.c_str(), true); }}
void LyraTheme::drawSubHeader(const GfxRenderer& renderer, Rect rect, const char* label, const char* rightLabel) const { int currentX = rect.x + LyraMetrics::values.contentSidePadding; int rightSpace = LyraMetrics::values.contentSidePadding; if (rightLabel) { auto truncatedRightLabel = renderer.truncatedText(SMALL_FONT_ID, rightLabel, maxListValueWidth, EpdFontFamily::REGULAR); int rightLabelWidth = renderer.getTextWidth(SMALL_FONT_ID, truncatedRightLabel.c_str()); renderer.drawText(SMALL_FONT_ID, rect.x + rect.width - LyraMetrics::values.contentSidePadding - rightLabelWidth, rect.y + 7, truncatedRightLabel.c_str()); rightSpace += rightLabelWidth + hPaddingInSelection; }
auto truncatedLabel = renderer.truncatedText( UI_10_FONT_ID, label, rect.width - LyraMetrics::values.contentSidePadding - rightSpace, EpdFontFamily::REGULAR); renderer.drawText(UI_10_FONT_ID, currentX, rect.y + 6, truncatedLabel.c_str(), true, EpdFontFamily::REGULAR);
renderer.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width - 1, rect.y + rect.height - 1, true);}
void LyraTheme::drawTabBar(const GfxRenderer& renderer, Rect rect, const std::vector<TabInfo>& tabs, bool selected) const { int currentX = rect.x + LyraMetrics::values.contentSidePadding;
if (selected) { renderer.fillRectDither(rect.x, rect.y, rect.width, rect.height, Color::LightGray); }
for (const auto& tab : tabs) { const int textWidth = renderer.getTextWidth(UI_10_FONT_ID, tab.label, EpdFontFamily::REGULAR);
if (tab.selected) { if (selected) { renderer.fillRoundedRect(currentX, rect.y + 1, textWidth + 2 * hPaddingInSelection, rect.height - 4, cornerRadius, Color::Black); } else { renderer.fillRectDither(currentX, rect.y, textWidth + 2 * hPaddingInSelection, rect.height - 3, Color::LightGray); renderer.drawLine(currentX, rect.y + rect.height - 3, currentX + textWidth + 2 * hPaddingInSelection, rect.y + rect.height - 3, 2, true); } }
renderer.drawText(UI_10_FONT_ID, currentX + hPaddingInSelection, rect.y + 6, tab.label, !(tab.selected && selected), EpdFontFamily::REGULAR);
currentX += textWidth + LyraMetrics::values.tabSpacing + 2 * hPaddingInSelection; }
renderer.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width - 1, rect.y + rect.height - 1, true);}
void LyraTheme::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, const std::function<UIIcon(int index)>& rowIcon, const std::function<std::string(int index)>& rowValue, bool highlightValue) const { int rowHeight = (rowSubtitle != nullptr) ? LyraMetrics::values.listWithSubtitleRowHeight : LyraMetrics::values.listRowHeight; int pageItems = rect.height / rowHeight;
const int totalPages = (itemCount + pageItems - 1) / pageItems; if (totalPages > 1) { const int scrollAreaHeight = rect.height;
// Draw scroll bar const int scrollBarHeight = (scrollAreaHeight * pageItems) / itemCount; const int currentPage = selectedIndex / pageItems; const int scrollBarY = rect.y + ((scrollAreaHeight - scrollBarHeight) * currentPage) / (totalPages - 1); const int scrollBarX = rect.x + rect.width - LyraMetrics::values.scrollBarRightOffset; renderer.drawLine(scrollBarX, rect.y, scrollBarX, rect.y + scrollAreaHeight, true); renderer.fillRect(scrollBarX - LyraMetrics::values.scrollBarWidth, scrollBarY, LyraMetrics::values.scrollBarWidth, scrollBarHeight, true); }
// Draw selection int contentWidth = rect.width - (totalPages > 1 ? (LyraMetrics::values.scrollBarWidth + LyraMetrics::values.scrollBarRightOffset) : 1); if (selectedIndex >= 0) { renderer.fillRoundedRect(LyraMetrics::values.contentSidePadding, rect.y + selectedIndex % pageItems * rowHeight, contentWidth - LyraMetrics::values.contentSidePadding * 2, rowHeight, cornerRadius, Color::LightGray); }
int textX = rect.x + LyraMetrics::values.contentSidePadding + hPaddingInSelection; int textWidth = contentWidth - LyraMetrics::values.contentSidePadding * 2 - hPaddingInSelection * 2; int iconSize; if (rowIcon != nullptr) { iconSize = (rowSubtitle != nullptr) ? mainMenuIconSize : listIconSize; textX += iconSize + hPaddingInSelection; textWidth -= iconSize + hPaddingInSelection; }
// Draw all items const auto pageStartIndex = selectedIndex / pageItems * pageItems; int iconY = (rowSubtitle != nullptr) ? 16 : 10; for (int i = pageStartIndex; i < itemCount && i < pageStartIndex + pageItems; i++) { const int itemY = rect.y + (i % pageItems) * rowHeight; int rowTextWidth = textWidth;
// Draw name int valueWidth = 0; std::string valueText = ""; if (rowValue != nullptr) { valueText = rowValue(i); valueText = renderer.truncatedText(UI_10_FONT_ID, valueText.c_str(), maxListValueWidth); valueWidth = renderer.getTextWidth(UI_10_FONT_ID, valueText.c_str()) + hPaddingInSelection; rowTextWidth -= valueWidth; }
auto itemName = rowTitle(i); auto item = renderer.truncatedText(UI_10_FONT_ID, itemName.c_str(), rowTextWidth); renderer.drawText(UI_10_FONT_ID, textX, itemY + 7, item.c_str(), true);
if (rowIcon != nullptr) { UIIcon icon = rowIcon(i); const uint8_t* iconBitmap = iconForName(icon, iconSize); if (iconBitmap != nullptr) { renderer.drawIcon(iconBitmap, rect.x + LyraMetrics::values.contentSidePadding + hPaddingInSelection, itemY + iconY, iconSize, iconSize); } }
if (rowSubtitle != nullptr) { // Draw subtitle std::string subtitleText = rowSubtitle(i); auto subtitle = renderer.truncatedText(SMALL_FONT_ID, subtitleText.c_str(), rowTextWidth); renderer.drawText(SMALL_FONT_ID, textX, itemY + 30, subtitle.c_str(), true); }
// Draw value if (!valueText.empty()) { if (i == selectedIndex && highlightValue) { renderer.fillRoundedRect( contentWidth - LyraMetrics::values.contentSidePadding - hPaddingInSelection - valueWidth, itemY, valueWidth + hPaddingInSelection, rowHeight, cornerRadius, Color::Black); }
renderer.drawText(UI_10_FONT_ID, rect.x + contentWidth - LyraMetrics::values.contentSidePadding - valueWidth, itemY + 6, valueText.c_str(), !(i == selectedIndex && highlightValue)); } }}
void LyraTheme::drawButtonHints(GfxRenderer& renderer, const char* btn1, const char* btn2, const char* btn3, const char* btn4) const { const GfxRenderer::Orientation orig_orientation = renderer.getOrientation(); renderer.setOrientation(GfxRenderer::Orientation::Portrait);
const int pageHeight = renderer.getScreenHeight(); constexpr int buttonWidth = 80; constexpr int smallButtonHeight = 15; constexpr int buttonHeight = LyraMetrics::values.buttonHintsHeight; constexpr int buttonY = LyraMetrics::values.buttonHintsHeight; // Distance from bottom constexpr int textYOffset = 7; // Distance from top of button to text baseline // X3 has wider screen in portrait (528 vs 480), use more spacing constexpr int x4ButtonPositions[] = {58, 146, 254, 342}; constexpr int x3ButtonPositions[] = {65, 157, 291, 383}; const int* buttonPositions = gpio.deviceIsX3() ? x3ButtonPositions : x4ButtonPositions; const char* labels[] = {btn1, btn2, btn3, btn4};
for (int i = 0; i < 4; i++) { const int x = buttonPositions[i]; if (labels[i] != nullptr && labels[i][0] != '\0') { // Draw the filled background and border for a FULL-sized button renderer.fillRoundedRect(x, pageHeight - buttonY, buttonWidth, buttonHeight, cornerRadius, Color::White); renderer.drawRoundedRect(x, pageHeight - buttonY, buttonWidth, buttonHeight, 1, cornerRadius, true, true, false, false, true); const int textWidth = renderer.getTextWidth(SMALL_FONT_ID, labels[i]); const int textX = x + (buttonWidth - 1 - textWidth) / 2; renderer.drawText(SMALL_FONT_ID, textX, pageHeight - buttonY + textYOffset, labels[i]); } else { // Draw the filled background and border for a SMALL-sized button renderer.fillRoundedRect(x, pageHeight - smallButtonHeight, buttonWidth, smallButtonHeight, cornerRadius, Color::White); renderer.drawRoundedRect(x, pageHeight - smallButtonHeight, buttonWidth, smallButtonHeight, 1, cornerRadius, true, true, false, false, true); } }
renderer.setOrientation(orig_orientation);}
void LyraTheme::drawSideButtonHints(const GfxRenderer& renderer, const char* topBtn, const char* bottomBtn) const { const int screenWidth = renderer.getScreenWidth(); constexpr int buttonWidth = LyraMetrics::values.sideButtonHintsWidth; // Width on screen (height when rotated) constexpr int buttonHeight = 78; // Height on screen (width when rotated) constexpr int buttonMargin = 0;
if (gpio.deviceIsX3()) { // X3 layout: Up on left side, Down on right side, positioned higher constexpr int x3ButtonY = 155;
if (topBtn != nullptr && topBtn[0] != '\0') { renderer.drawRoundedRect(buttonMargin, x3ButtonY, buttonWidth, buttonHeight, 1, cornerRadius, false, true, false, true, true); const int textWidth = renderer.getTextWidth(SMALL_FONT_ID, topBtn); renderer.drawTextRotated90CW(SMALL_FONT_ID, buttonMargin, x3ButtonY + (buttonHeight + textWidth) / 2, topBtn); }
if (bottomBtn != nullptr && bottomBtn[0] != '\0') { const int rightX = screenWidth - buttonWidth; renderer.drawRoundedRect(rightX, x3ButtonY, buttonWidth, buttonHeight, 1, cornerRadius, true, false, true, false, true); const int textWidth = renderer.getTextWidth(SMALL_FONT_ID, bottomBtn); renderer.drawTextRotated90CW(SMALL_FONT_ID, rightX, x3ButtonY + (buttonHeight + textWidth) / 2, bottomBtn); } } else { // X4 layout: Both buttons stacked on right side const char* labels[] = {topBtn, bottomBtn}; const int x = screenWidth - buttonWidth;
if (topBtn != nullptr && topBtn[0] != '\0') { renderer.drawRoundedRect(x, topHintButtonY, buttonWidth, buttonHeight, 1, cornerRadius, true, false, true, false, true); }
if (bottomBtn != nullptr && bottomBtn[0] != '\0') { renderer.drawRoundedRect(x, topHintButtonY + buttonHeight + 5, buttonWidth, buttonHeight, 1, cornerRadius, true, false, true, false, true); }
for (int i = 0; i < 2; i++) { if (labels[i] != nullptr && labels[i][0] != '\0') { const int y = topHintButtonY + (i * buttonHeight) + 5; const int textWidth = renderer.getTextWidth(SMALL_FONT_ID, labels[i]); renderer.drawTextRotated90CW(SMALL_FONT_ID, x, y + (buttonHeight + textWidth) / 2, labels[i]); } } }}
void LyraTheme::drawRecentBookCover(GfxRenderer& renderer, Rect rect, const std::vector<RecentBook>& recentBooks, const int selectorIndex, bool& coverRendered, bool& coverBufferStored, bool& bufferRestored, std::function<bool()> storeCoverBuffer) const { const int tileWidth = rect.width - 2 * LyraMetrics::values.contentSidePadding; const int tileHeight = rect.height; const int tileY = rect.y; const bool hasContinueReading = !recentBooks.empty(); if (coverWidth == 0) { coverWidth = LyraMetrics::values.homeCoverHeight * 0.6; }
// Draw book card regardless, fill with message based on `hasContinueReading` // Draw cover image as background if available (inside the box) // Only load from SD on first render, then use stored buffer if (hasContinueReading) { RecentBook book = recentBooks[0]; if (!coverRendered) { std::string coverPath = book.coverBmpPath; bool hasCover = true; int tileX = LyraMetrics::values.contentSidePadding; if (coverPath.empty()) { hasCover = false; } else { const std::string coverBmpPath = UITheme::getCoverThumbPath(coverPath, LyraMetrics::values.homeCoverHeight);
// First time: load cover from SD and render FsFile file; if (Storage.openFileForRead("HOME", coverBmpPath, file)) { Bitmap bitmap(file); if (bitmap.parseHeaders() == BmpReaderError::Ok) { coverWidth = bitmap.getWidth(); renderer.drawBitmap(bitmap, tileX + hPaddingInSelection, tileY + hPaddingInSelection, coverWidth, LyraMetrics::values.homeCoverHeight); } else { hasCover = false; } file.close(); } }
// Draw either way renderer.drawRect(tileX + hPaddingInSelection, tileY + hPaddingInSelection, coverWidth, LyraMetrics::values.homeCoverHeight, true);
if (!hasCover) { // Render empty cover renderer.fillRect(tileX + hPaddingInSelection, tileY + hPaddingInSelection + (LyraMetrics::values.homeCoverHeight / 3), coverWidth, 2 * LyraMetrics::values.homeCoverHeight / 3, true); renderer.drawIcon(CoverIcon, tileX + hPaddingInSelection + 24, tileY + hPaddingInSelection + 24, 32, 32); }
coverBufferStored = storeCoverBuffer(); coverRendered = coverBufferStored; // Only consider it rendered if we successfully stored the buffer }
bool bookSelected = (selectorIndex == 0);
int tileX = LyraMetrics::values.contentSidePadding; int textWidth = tileWidth - 2 * hPaddingInSelection - LyraMetrics::values.verticalSpacing - coverWidth;
if (bookSelected) { // Draw selection box renderer.fillRoundedRect(tileX, tileY, tileWidth, hPaddingInSelection, cornerRadius, true, true, false, false, Color::LightGray); renderer.fillRectDither(tileX, tileY + hPaddingInSelection, hPaddingInSelection, LyraMetrics::values.homeCoverHeight, Color::LightGray); renderer.fillRectDither(tileX + hPaddingInSelection + coverWidth, tileY + hPaddingInSelection, tileWidth - hPaddingInSelection - coverWidth, LyraMetrics::values.homeCoverHeight, Color::LightGray); renderer.fillRoundedRect(tileX, tileY + LyraMetrics::values.homeCoverHeight + hPaddingInSelection, tileWidth, hPaddingInSelection, cornerRadius, false, false, true, true, Color::LightGray); }
auto titleLines = renderer.wrappedText(UI_12_FONT_ID, book.title.c_str(), textWidth, 3, EpdFontFamily::BOLD);
auto author = renderer.truncatedText(UI_10_FONT_ID, book.author.c_str(), textWidth); const int titleLineHeight = renderer.getLineHeight(UI_12_FONT_ID); const int titleBlockHeight = titleLineHeight * static_cast<int>(titleLines.size()); const int authorHeight = book.author.empty() ? 0 : (renderer.getLineHeight(UI_10_FONT_ID) * 3 / 2); const int totalBlockHeight = titleBlockHeight + authorHeight; int titleY = tileY + tileHeight / 2 - totalBlockHeight / 2; const int textX = tileX + hPaddingInSelection + coverWidth + LyraMetrics::values.verticalSpacing; for (const auto& line : titleLines) { renderer.drawText(UI_12_FONT_ID, textX, titleY, line.c_str(), true, EpdFontFamily::BOLD); titleY += titleLineHeight; } if (!book.author.empty()) { titleY += renderer.getLineHeight(UI_10_FONT_ID) / 2; renderer.drawText(UI_10_FONT_ID, textX, titleY, author.c_str(), true); } } else { drawEmptyRecents(renderer, rect); }}
void LyraTheme::drawEmptyRecents(const GfxRenderer& renderer, const Rect rect) const { constexpr int padding = 48; renderer.drawText(UI_12_FONT_ID, rect.x + padding, rect.y + rect.height / 2 - renderer.getLineHeight(UI_12_FONT_ID) - 2, tr(STR_NO_OPEN_BOOK), true, EpdFontFamily::BOLD); renderer.drawText(UI_10_FONT_ID, rect.x + padding, rect.y + rect.height / 2 + 2, tr(STR_START_READING), true);}
void LyraTheme::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 { for (int i = 0; i < buttonCount; ++i) { int tileWidth = rect.width - LyraMetrics::values.contentSidePadding * 2; Rect tileRect = Rect{rect.x + LyraMetrics::values.contentSidePadding, rect.y + i * (LyraMetrics::values.menuRowHeight + LyraMetrics::values.menuSpacing), tileWidth, LyraMetrics::values.menuRowHeight};
const bool selected = selectedIndex == i;
if (selected) { renderer.fillRoundedRect(tileRect.x, tileRect.y, tileRect.width, tileRect.height, cornerRadius, Color::LightGray); }
std::string labelStr = buttonLabel(i); const char* label = labelStr.c_str(); int textX = tileRect.x + 16; const int lineHeight = renderer.getLineHeight(UI_12_FONT_ID); const int textY = tileRect.y + (LyraMetrics::values.menuRowHeight - lineHeight) / 2;
if (rowIcon != nullptr) { UIIcon icon = rowIcon(i); const uint8_t* iconBitmap = iconForName(icon, mainMenuIconSize); if (iconBitmap != nullptr) { renderer.drawIcon(iconBitmap, textX, textY + 3, mainMenuIconSize, mainMenuIconSize); textX += mainMenuIconSize + hPaddingInSelection + 2; } }
renderer.drawText(UI_12_FONT_ID, textX, textY, label, true); }}
Rect LyraTheme::drawPopup(const GfxRenderer& renderer, const char* message) const { // Scale y position proportionally to screen height (16.5% from top) const int y = static_cast<int>(renderer.getScreenHeight() * 0.165f); constexpr int outline = 2; const int textWidth = renderer.getTextWidth(UI_12_FONT_ID, message, EpdFontFamily::REGULAR); const int textHeight = renderer.getLineHeight(UI_12_FONT_ID); const int w = textWidth + popupMarginX * 2; const int h = textHeight + popupMarginY * 2; const int x = (renderer.getScreenWidth() - w) / 2;
renderer.fillRoundedRect(x - outline, y - outline, w + outline * 2, h + outline * 2, cornerRadius + outline, Color::White); renderer.fillRoundedRect(x, y, w, h, cornerRadius, Color::Black);
const int textX = x + (w - textWidth) / 2; const int textY = y + popupMarginY - 2; renderer.drawText(UI_12_FONT_ID, textX, textY, message, false, EpdFontFamily::REGULAR); renderer.displayBuffer();
return Rect{x, y, w, h};}
void LyraTheme::fillPopupProgress(const GfxRenderer& renderer, const Rect& layout, const int progress) const { constexpr int barHeight = 4;
// Twice the margin in drawPopup to match text width const int barWidth = layout.width - popupMarginX * 2; const int barX = layout.x + (layout.width - barWidth) / 2; // Center inside the margin of drawPopup. The - 1 is added to account for the - 2 in drawPopup. const int barY = layout.y + layout.height - popupMarginY / 2 - barHeight / 2 - 1;
int fillWidth = barWidth * progress / 100;
renderer.fillRect(barX, barY, fillWidth, barHeight, false);
renderer.displayBuffer(HalDisplay::FAST_REFRESH);}