Compare commits

..
Author SHA1 Message Date
Justin Mitchell 79f5657fb2 Add configurable default home screen action
Themes can now specify an initialAction in home screen config to set the default selected action when entering home normally. Falls back to this theme setting when no explicit action is requested, but explicit firmware navigation still takes precedence.
2026-06-28 02:38:53 -04:00
Justin Mitchell 48aa3c8e02 Add SD theme system
Adds installable SD-card themes with manifest downloads, theme registry parsing, themed home/chrome/settings/file browser support, FreeInk layout integration, theme documentation, and layout tests.
2026-06-28 01:44:38 -04:00
Bastian cbaa498ccc docs: adding quick resume option and quick resume on timeout to userguide (#2425) 2026-06-27 22:40:21 +03:00
Justin Mitchell ebebc6f202 chore: migrate from open-x4-sdk to freeink-sdk (#2449)
This PR moves us from the xteink openx4 SDK to the freeink sdk from
https://freeink.org. Out of the box there are NO changes needed in the
firmware to support this swap, it all magically works as is. However as
we support more than just the x3/x4 devices, this sdk allows us to pass
env vars into the build commands to include support for other devices.
As support for new hardware such as touch screens and bluetooth are
added the xteink builds decide at compile time if the libraries are used
or not. For example right now the freeinkui and icons libraries are in
the platform.io file but as they are not used anywhere, they won't be
included in the final build. Once the touch branch and sd themes branch
are merged in this sdk is required for them to function correctly. All
the docs for freeink are available at freeink.org/docs. x4/x3 is a
single binary build unlike other devices that will build unique binaries
for each device. Eventually we will want to remove a lot of the manual
isx3 type stuff from our firmware and go through the boardsupport api
the sdk provides as it will generalize everything into one common system
that any device can support. The upcoming touch branch does a lot of
this for us but this initial PR is JUST to get the sdk swapped over
without any code changes to show seamless integration without any
regressions.
2026-06-27 21:22:58 +03:00
Julia 970b2c6ca1 chore: release 1.4.1 (#2447)
Compile Release / build-release (push) Canceled after 0s
## Improvements

* Moved the File Manager breadcrumb into the Contents card header for a
cleaner, more consistent interface.
* Updated the Wireless Transfer section of the User Guide with clearer
instructions.
* Battery status bar indicator no longer changes position when adding or
removing bookmarks.

## Performance

* Optimized path normalization for faster file handling.
* Significantly improved bookmark rendering by removing unnecessary
XPath lookups.
* Optimized dithered rectangle drawing (fillRectDither) using a
byte-aligned rendering implementation, improving display performance on
supported devices.

## Bug Fixes

* Fixed an issue where the Inverted Orientation label was incorrectly
combined with the Color Filter label for Geman localization.
* Fixed excessive ghosting on the X3 cover screen during sleep
2026-06-26 17:40:04 -04:00
Julia Nguyen b6ce599b20 fix: address release review feedback 2026-06-26 16:22:20 -04:00
Juliaandcoderabbitai[bot] f54eab2725 fix: typo in STR_ORIENTATION_INVERTED Spanish translation
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
2026-06-26 16:13:19 -04:00
Justin Mitchell 0d4c9ab91b Bump version to 1.4.1 2026-06-26 15:48:19 -04:00
Julia 0daa9db243 fix: keep status bar indicators stable when toggling bookmarks (#2444) 2026-06-26 19:26:33 +03:00
Uri TauberandRyan Mercado a2f2eea79e perf: Optimize fillRectDither with Byte-Aligned fillRectImpl (#2270)
## Summary

* **What is the goal of this PR?**
Replace the pixel-by-pixel `fillRectDither` implementation with a new
byte-aligned `fillRectImpl` that eliminates per-pixel
`rotateCoordinates` calls and Read-Modify-Write bitwise loops, yielding
a significant rendering speedup on ESP32 E-ink framebuffers.

Ported from @rhythmerc's crosspoint-reader fork commit 27ea625.

* **What changes are included?**

- **`GfxRenderer.cpp` — `fillRectDither` refactor:** The existing
`if/else if` chain is replaced with a `switch` statement that delegates
each `Color` case to the new `fillRectImpl<Color>()` template,
eliminating runtime branching.

- **`GfxRenderer.cpp` — new `fillRectImpl<C>()` template:** Core of the
optimization. Key behaviors:
    - Clips the rectangle in logical space upfront.
- Rotates only **2 opposing corner points** (top-left and bottom-right)
into physical framebuffer space instead of rotating every pixel
individually.
- Derives physical-space `byteStart`/`byteEnd` and precomputes
`headMask` / `tailMask` for MSB-first partial-byte boundaries,
performing RMW only on the edge bytes.
- **Solid fills (`Black` / `White`):** Uses `memset` for all interior
full-byte runs per row — no per-pixel writes.
- **Dithered fills (`LightGray` / `DarkGray`):** Precomputes both parity
variants of `blackMask` (even/odd `py`) **outside** the row loop,
eliminating the previously re-evaluated 8-bit construction loop on every
physical row. Interior full bytes are then written with a single
`memset(whiteMask)`.
- Uses `if constexpr` throughout to dispatch on `Color` at compile time,
generating zero runtime branches per template instantiation.

- **`GfxRenderer.h`:** Declares the new private `fillRectImpl<Color>()`
template method with an explanatory doc-comment.

- **Explicit template instantiations** added for all four active `Color`
variants (`Black`, `White`, `LightGray`, `DarkGray`).

## Additional Context

* **Performance:** The primary motivation is ESP32 E-ink framebuffer
performance. The old path called `rotateCoordinates` and did a full RMW
for every single pixel in the rectangle. The new path calls
`rotateCoordinates` exactly **twice** per fill regardless of rectangle
size, then operates at byte granularity — a complexity reduction from
O(W×H) coordinate transforms to O(1).
* **Dither correctness:** The `blackMask` precomputation relies on the
dither pattern having period 2 in both logical X and Y, which makes the
per-row byte pattern repeat with period 2 in `py`. Reviewers should
verify the `lxBase`/`lyBase` derivations for all four orientations
(`Portrait`, `PortraitInverted`, `LandscapeClockwise`,
`LandscapeCounterClockwise`) match the inverse of `rotateCoordinates`.
* **Edge case — single-byte rows:** When `byteStart == byteEnd`, the
head and tail masks are ANDed together into a single `rectMask` to avoid
double-masking the same byte. This path should be tested with narrow
rectangles (width < 8px).
* **No behavioral change for `Color::Clear`:** The `Clear` case exits
early via `if constexpr` and is a no-op, matching the original behavior.

---

### AI Usage

While CrossPoint doesn't have restrictions on AI tools in contributing,
please be transparent about their usage as it
helps set the right context for reviewers.

Did you use AI tools to help write this code? _**< YES >**_

---------

Co-authored-by: Ryan Mercado <rmercado@firstdollar.com>
2026-06-26 12:16:25 -04:00
Ankit 86a9b9c4a2 docs: update user guide wireless transfer section (#2369)
Co-authored-by: Uri Tauber <uritaube@gmail.com>
Closes #1407
2026-06-26 08:25:52 +03:00
Julia Nguyen ba44978ac4 Merge branch 'master' into develop 2026-06-25 17:51:56 -04:00
Pietro Campagnano 555f76da88 feat: move file manager breadcrumb into contents card header (#2430) 2026-06-26 00:45:43 +03:00
Justin Mitchell 0a57c0a5a7 Fix X3 display ghosting on cover screen transitions
Force display resync on X3 when HALF refresh is requested to clear prior content before rendering. Add grayscale preconditioning for X3's UC81xx controller to even out single-pixel dithering artifacts that appear as speckle with its turbo BW waveform.
2026-06-25 17:42:19 -04:00
Uri Tauber a09aef0889 fix: Optimize Bookmark Rendering by Removing XPath Lookup (#2417)
## Summary

fix #2414 

### Root Cause

`updateBookmarkFlag()` was introduced in commit 1db1442 and is executed
on every render (every page turn). The function calls:

`ProgressMapper::toSavedProgress()`
→ `ChapterXPathResolver::findXPathForProgress()`

This path decompresses the current EPUB section content twice:

1. To count visible characters.
2. To resolve the corresponding XPath.

For larger sections (e.g. ~133 KB decompressed content), this adds
approximately **1 second of I/O overhead per page turn**, with the cost
increasing as chapter size grows.

### Fix

`updateBookmarkFlag()` only needs to determine whether a bookmark falls
within the currently displayed page range.

The required information is already available during rendering:

* `currentPage`
* `section->pageCount`
* `currentSpineIndex`

Instead of converting the current location to a saved progress object
(and resolving an XPath), the implementation now computes the current
page's progress range directly and compares bookmark percentages against
that range.

This is effectively the same percentage-based matching logic already
used as a fallback in `bookmarkMatchesProgress()` when XPath matching is
unavailable.

---

### AI Usage

While CrossPoint doesn't have restrictions on AI tools in contributing,
please be transparent about their usage as it
helps set the right context for reviewers.

Did you use AI tools to help write this code? _**< PARTIALLY >**_
2026-06-25 09:20:24 -04:00
Bastian 8626d69f46 fix: small translation changes for german (#2420) 2026-06-25 09:29:05 +03:00
Uri Tauber fc89e57e69 perf: optimise normalisePath (#2162) 2026-06-25 09:01:50 +03:00
Julia 487613b082 fix: split inverted orientation label from color filter label (#2421)
## Summary

* **What is the goal of this PR?** 
* Fix the “Inverted” translation so reader orientation and color/filter
inversion can use separate labels.
* **What changes are included?**
* Adds `STR_ORIENTATION_INVERTED` for the inverted portrait orientation
option.
* Updates the reader orientation setting to use
`STR_ORIENTATION_INVERTED` instead of reusing `STR_INVERTED`.
* Leaves `STR_INVERTED` for the sleep cover filter and tilt page-turn
mode
  * Adds the new orientation string across all 26 locale YAML files.

## Additional Context

* The original issue was found by a user in German, where `STR_INVERTED`
was translated as `Hochformat 180°`, which made sense for orientation
but not for color filters.
* This is a UI-label-only change. It does not change persisted
orientation values or settings behavior.
* Reviewer note: non-English wording may still benefit from
native-speaker review, especially for the new orientation-specific
labels and to verify the interchangeable usage between inverted color
and inverted tilt page turn direction.
---

### AI Usage

While CrossPoint doesn't have restrictions on AI tools in contributing,
please be transparent about their usage as it
helps set the right context for reviewers.

Did you use AI tools to help write this code? _**< YES >**_
2026-06-25 00:47:06 -04:00
JuliaandHusam Younis 8d5b119644 fix: sync master into develop (#2423)
Sync develop branch with master

Co-authored-by: Husam Younis <youhusam@gmail.com>
2026-06-24 22:07:13 -04:00
Husam Younis 7271c00d35 feat: Allow statusbar clock to be on the left (#2359) 2026-06-25 00:23:23 +03:00
Uri Tauber 6e8dbd7f23 chore: Update version to 1.4.0 (#2283)
Compile Release / build-release (push) Canceled after 0s
2026-06-24 18:30:32 +03:00
Uri Tauber c4b1d9644a fix: correct font size selection (#2410) 2026-06-24 17:01:10 +03:00
Justin Mitchell f6e59aab72 feat: Add displayGrayscaleBase method for differential refresh
(#2334)

Introduces a new display method that prepares the framebuffer as a base
frame for grayscale overlays. On X3 panels, this uses the OEM
differential base waveform (AA-pre-BW) without forcing a resync. Other
panels fall back to normal display with configurable refresh mode.


Dependent upon matching SDK commit to work
2026-06-24 07:53:19 -04:00
Uri Tauber 9ad2da0950 fix: add seven missing hebrew translations (#2409) 2026-06-24 09:34:40 +03:00
Uri TauberandJulia Nguyen 1db1442319 fix: several bookmarks UX improvments (#2372)
## Summary

This PR enhances the EPUB reader's bookmark system with two
complementary improvements: a per-page bookmark indicator icon and
toggle behavior on the existing long-press action.

---

### What Changed

**Bookmark Toggle (was: add-only)**

The long-press Confirm action now toggles bookmarks rather than always
adding. `addBookmark()` checks whether a bookmark with the same xpath
already exists in the in-memory cache:
- If found → removes it and shows "Bookmark removed."
- If not found → adds it and shows "Bookmark added."

A new `STR_BOOKMARK_REMOVED` translation string was added to support the
removal message.

**Bookmark Icon Indicator**

A `BookmarkIcon` is now drawn at the top-right corner of the page
whenever the current page has a bookmark. `updateBookmarkFlag()` is
called at render time to determine whether the current page is
bookmarked.

**In-Memory Bookmark Cache**

Bookmarks are now loaded into `cachedBookmarks` on `onEnter()` rather
than being re-read from disk on every toggle. All subsequent add/remove
operations work against this cache and flush to disk, avoiding redundant
file reads on each bookmark action.

**Faster bookmarks list**

Previously, calculating "page X/Y" for each entry required decompressing
the entire spine item. We now persist `si`/`pc`/`pp` (spine index, page
count, and page progress) in the bookmark JSON when saving, and restore
them when loading. This avoids the expensive `toCrossPoint()` loop in
`onEnter()`, significantly reducing the cost of initializing the
bookmarks list.

---

### Files Changed

- `EpubReaderActivity.cpp` — `addBookmark()` toggle logic,
`updateBookmarkFlag()` (new), icon rendering in `renderContents()`,
cache initialization in `onEnter()`
- `EpubReaderActivity.h` — new fields: `currentPageBookmarked`,
`bookmarkRemoved`, `cachedBookmarks`; new method declaration
`updateBookmarkFlag()`

---

### AI Usage

While CrossPoint doesn't have restrictions on AI tools in contributing,
please be transparent about their usage as it
helps set the right context for reviewers.

Did you use AI tools to help write this code? _**< PARTIALLY >**_

---------

Co-authored-by: Julia Nguyen <julia@uxj.io>
2026-06-23 14:55:01 -04:00
Leopoldo Pla Sempere 362dcb2a65 feat: Smooth progressive JPEG cover upscales in BMP conversion (#2214) 2026-06-22 13:55:12 -04:00
Julia d1abcc00a2 feat: render grayscale epub images without text aa (#2393) 2026-06-22 17:15:27 +03:00
Zeph 0ce874f8d4 feat: footnote returns to original position on deep sleep to avoid losing reading position (#2394) 2026-06-22 15:28:42 +03:00
kygia 282514f755 fix(epub): flush displaced anchor before overwrite (#2336) (#2382)
## Summary

* **What is the goal of this PR?** (e.g., Implements the new feature for
file uploading.)

Fixes footnote links landing in start section instead of the specific
foot note target.

* **What changes are included?**

ChapterHtmlSlimParser.cpp: call flushPendingAnchor() before overwriting
pendingAnchorId. First id got lost due to consecutive non-block elements
carry ids, the first id was lost and the reader had no page to jump to,
so it defaulted to page 0.

## Additional Context

Tested with the epubs attached to to #2336. Need to clear .crosspoint/
cache after flashing so the anchor map gets rebuilt with the fix.

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

---

### AI Usage

While CrossPoint doesn't have restrictions on AI tools in contributing,
please be transparent about their usage as it
helps set the right context for reviewers.

Did you use AI tools to help write this code? 

Partially assisted with writing documentation.
2026-06-21 16:43:39 -04:00
SurprisedDuck d1e4650e19 fix: don't justify-stretch a leading no-break space (#2185) (#2298) 2026-06-21 16:12:14 +03:00
Justin Mitchell 370f87ea01 feat: add Spacing Modifier Letters range to font presets (#2194) 2026-06-21 09:14:42 +03:00
174 changed files with 7949 additions and 10673 deletions

No files matched your search

+2 -2
View File
@@ -7,7 +7,7 @@ Mission: Provide a lightweight, high-performance reading experience focused on E
* Role: Senior Embedded Systems Engineer (ESP-IDF/Arduino-ESP32 specialized). * Role: Senior Embedded Systems Engineer (ESP-IDF/Arduino-ESP32 specialized).
* Primary Constraint: 380KB RAM is the hard ceiling. Stability is non-negotiable. * Primary Constraint: 380KB RAM is the hard ceiling. Stability is non-negotiable.
* Evidence-Based Reasoning: Before proposing a change, you MUST cite the specific file path and line numbers that justify the modification. * Evidence-Based Reasoning: Before proposing a change, you MUST cite the specific file path and line numbers that justify the modification.
* Anti-Hallucination: Do not assume the existence of libraries or ESP-IDF functions. If you are unsure of an API's availability for the ESP32-C3 RISC-V target, check the open-x4-sdk or official docs first. * Anti-Hallucination: Do not assume the existence of libraries or ESP-IDF functions. If you are unsure of an API's availability for the ESP32-C3 RISC-V target, check the freeink-sdk source or the FreeInk SDK docs (https://freeink.org/llms.txt for an LLM-readable index) first.
* No Unfounded Claims: Do not claim performance gains or memory savings without explaining the technical mechanism (e.g., DRAM vs IRAM usage). * No Unfounded Claims: Do not claim performance gains or memory savings without explaining the technical mechanism (e.g., DRAM vs IRAM usage).
* Resource Justification: You must justify any new heap allocation (new, malloc, std::vector) or explain why a stack/static alternative was rejected. * Resource Justification: You must justify any new heap allocation (new, malloc, std::vector) or explain why a stack/static alternative was rejected.
* Verification: After suggesting a fix, instruct the user on how to verify it (e.g., monitoring heap via Serial or checking a specific cache file). * Verification: After suggesting a fix, instruct the user on how to verify it (e.g., monitoring heap via Serial or checking a specific cache file).
@@ -127,7 +127,7 @@ These flags in `platformio.ini` fundamentally affect firmware behavior:
* lib/hal/: Hardware Abstraction Layer (HalDisplay, HalGPIO, HalStorage) * lib/hal/: Hardware Abstraction Layer (HalDisplay, HalGPIO, HalStorage)
* lib/I18n/: Internationalization (translations in `translations/*.yaml`, generated string tables) * lib/I18n/: Internationalization (translations in `translations/*.yaml`, generated string tables)
* src/activities/: UI logic using the Activity Lifecycle (onEnter, loop, onExit) * src/activities/: UI logic using the Activity Lifecycle (onEnter, loop, onExit)
* open-x4-sdk/: Low-level SDK (EInkDisplay, InputManager, BatteryMonitor, SDCardManager) * freeink-sdk/: Low-level SDK (EInkDisplay, InputManager, BatteryMonitor, SDCardManager)
* .crosspoint/: SD-based binary cache for EPUB metadata and pre-rendered layout sections * .crosspoint/: SD-based binary cache for EPUB metadata and pre-rendered layout sections
### Hardware Abstraction Layer (HAL) ### Hardware Abstraction Layer (HAL)
+18
View File
@@ -131,6 +131,23 @@ Convert your own TTF/OTF files into `.cpfont` files that load from the SD card.
Conversion runs the firmware repo's `lib/EpdFont/scripts/fontconvert_sdcard.py` script unmodified, so output matches a local host build. Conversion runs the firmware repo's `lib/EpdFont/scripts/fontconvert_sdcard.py` script unmodified, so output matches a local host build.
## Custom SD-card themes
Downloadable themes are packaged in the tools repo under `../crosspoint-tools/public/themes/<theme-id>/`. Each theme folder must contain a `theme.json`; optional assets such as generated BMP icons live beside it, usually under `icons/`.
See [SD-card theme creation](./docs/theme-creation.md) for the full JSON format, device-specific overrides, icon generation, CrossInk extension fields, and packaging rules.
After adding or changing a hosted theme, regenerate the download manifest:
```bash
python3 scripts/generate-theme-manifest.py \
--root ../crosspoint-tools/public/themes \
--base-url http://crosspointreader.com/themes \
--output ../crosspoint-tools/public/themes/themes.json
```
The script scans every theme folder, includes every file in each package, and writes size and CRC32 values used by the device downloader. Commit changed theme package files and the regenerated `themes.json` in `crosspoint-tools`.
--- ---
## Documentation ## Documentation
@@ -138,6 +155,7 @@ Conversion runs the firmware repo's `lib/EpdFont/scripts/fontconvert_sdcard.py`
- [User Guide](./USER_GUIDE.md) - [User Guide](./USER_GUIDE.md)
- [Web server usage](./docs/webserver.md) - [Web server usage](./docs/webserver.md)
- [Web server endpoints](./docs/webserver-endpoints.md) - [Web server endpoints](./docs/webserver-endpoints.md)
- [SD-card theme creation](./docs/theme-creation.md)
- [Project scope](./SCOPE.md) - [Project scope](./SCOPE.md)
- [Contributing docs](./docs/contributing/README.md) - [Contributing docs](./docs/contributing/README.md)
+36 -7
View File
@@ -122,19 +122,43 @@ A **Wi-Fi signal strength indicator** (dBm) is displayed on-screen during joined
CrossPoint supports sending books from Calibre using the CrossPoint Reader device plugin. CrossPoint supports sending books from Calibre using the CrossPoint Reader device plugin.
1. Install the plugin in Calibre: #### Installing the Plugin in Calibre
- Head to https://github.com/crosspoint-reader/calibre-plugins/releases to download the latest version of the crosspoint_reader plugin. If you don't already have the plugin installed:
- Download the zip file. 1. Head to https://github.com/crosspoint-reader/calibre-plugins/releases to download the latest version of the crosspoint_reader plugin.
2. Download the zip file.
3. Open Calibre → Preferences → Plugins → Load plugin from file → Select the zip file.
4. Restart Calibre.
- Open Calibre → Preferences → Plugins → Load plugin from file → Select the zip file. #### Configuring the CrossPoint Plugin in Calibre
1. In Calibre select Preferences.
2. In the Preferences dialog select Plugins.
3. In Plugins search for "crosspoint".
4. Click on "Customize plugin".
5. Update the value for "Host" to match the IP for your device.
6. Leave the other settings as they are.
7. [optional] Modify the "Upload path" to point to a subfolder other than the root "/" folder. Enter this as a path relative to the root folder. Example: `/mybooks`
8. Restart Calibre.
2. On the device: File Transfer -> Calibre Wireless, then join a network. <img width="420" height="385" alt="Image" src="https://github.com/user-attachments/assets/01fc7e33-a9a7-48ba-9e26-2e68d1f9daec" />
3. Make sure your computer is on the same Wi-Fi network. #### Uploading Books
4. In Calibre, click "Send to device" to transfer books. To upload a book using the CrossPoint plugin in Calibre:
1. On the device: File Transfer -> Calibre Wireless, then join a network.
2. Select one or more books.
3. Right-click on that selection.
4. Select "Send to Device" > "Send to main memory"
The CrossPoint plugin will connect to your device, create a folder for the book's author in the root folder (or the folder you configured for the plugin), then copy the book into that folder.
<img width="783" height="310" alt="Image" src="https://github.com/user-attachments/assets/741b0909-2e1d-4f16-8af0-2c43fbda5ce6" />
#### Removing a Book
Books cannot be removed from your device through Calibre. Use the web interface instead.
### 3.6 Settings ### 3.6 Settings
@@ -150,6 +174,7 @@ The Settings screen allows you to configure the device's behavior. There are a f
- "Cover" - The book cover image (Note: this is experimental and may not work as expected) - "Cover" - The book cover image (Note: this is experimental and may not work as expected)
- "None" - A blank screen - "None" - A blank screen
- "Cover + Custom" - The book cover image while actively reading, falls back to "Custom" behavior otherwise - "Cover + Custom" - The book cover image while actively reading, falls back to "Custom" behavior otherwise
- "Quick resume" - The text of the last page read will be displayed on the sleep screen and a moon icon is shown on the edge of the screen. Waking up the device will return to the same page of the opened book. This is useful for quickly resuming reading without waiting for the device to fully wake up and load the book.
- **Sleep Screen Cover Mode**: How to display the book cover when "Cover" sleep screen is selected: - **Sleep Screen Cover Mode**: How to display the book cover when "Cover" sleep screen is selected:
@@ -162,6 +187,8 @@ The Settings screen allows you to configure the device's behavior. There are a f
- "Contrast" - The image will be displayed as a black & white image without grayscale conversion - "Contrast" - The image will be displayed as a black & white image without grayscale conversion
- "Inverted" - The image will be inverted as in white & black and will be displayed without grayscale conversion - "Inverted" - The image will be inverted as in white & black and will be displayed without grayscale conversion
- **Quick Resume on Timeout**: Whether to enable the "Quick Resume" sleep screen when the device goes to sleep due to inactivity (System > Time to Sleep). This is useful for quickly resuming reading without waiting for the device to fully wake up and load the book. This overwrites the Sleep Screen Cover Mode when enabled.
- **Status Bar**: Configure the status bar displayed while reading: - **Status Bar**: Configure the status bar displayed while reading:
- "None" - No status bar - "None" - No status bar
@@ -527,6 +554,8 @@ On the **Xteink X3**, the gyroscope can be used to turn pages by tilting the dev
When reading an EPUB that contains footnotes, you can navigate to the footnote text by selecting the footnote reference in the book. From the footnote, you can return to your original reading position. When reading an EPUB that contains footnotes, you can navigate to the footnote text by selecting the footnote reference in the book. From the footnote, you can return to your original reading position.
If the device goes to sleep or you close the book while viewing a footnote, the book reopens to your original reading position, not the footnote.
### System Navigation ### System Navigation
* **Return to Home:** Press the **Back** button to close the book and return to the **[Home](#31-home-screen)** screen. * **Return to Home:** Press the **Back** button to close the book and return to the **[Home](#31-home-screen)** screen.
+2 -2
View File
@@ -4,7 +4,7 @@
.DESCRIPTION .DESCRIPTION
Formats all C/C++ source and header files in the repository, excluding Formats all C/C++ source and header files in the repository, excluding
generated, vendored, and build directories (open-x4-sdk, builtinFonts, generated, vendored, and build directories (freeink-sdk, builtinFonts,
hyphenation tries, uzlib, .pio, *.generated.h). hyphenation tries, uzlib, .pio, *.generated.h).
The clang-format binary path is resolved once and cached in The clang-format binary path is resolved once and cached in
@@ -92,7 +92,7 @@ function Resolve-ClangFormat {
$clangFormat = Resolve-ClangFormat $clangFormat = Resolve-ClangFormat
$exclude = @( $exclude = @(
'open-x4-sdk' 'freeink-sdk'
'lib\EpdFont\builtinFonts' 'lib\EpdFont\builtinFonts'
'lib\Epub\Epub\hyphenation\generated' 'lib\Epub\Epub\hyphenation\generated'
'lib\uzlib' 'lib\uzlib'
+3 -3
View File
@@ -8,7 +8,7 @@ At a high level, it is firmware that uses an activity-driven application archite
```mermaid ```mermaid
graph TD graph TD
A[Hardware: ESP32-C3 + SD + E-ink + Buttons] --> B[open-x4-sdk] A[Hardware: ESP32-C3 + SD + E-ink + Buttons] --> B[freeink-sdk]
B --> C[lib/hal wrappers] B --> C[lib/hal wrappers]
C --> D[src/main.cpp runtime loop] C --> D[src/main.cpp runtime loop]
D --> E[Activities layer] D --> E[Activities layer]
@@ -195,10 +195,10 @@ When editing related source assets, regenerate via normal build steps/scripts.
- `src/`: app orchestration, settings/state, and activity implementations - `src/`: app orchestration, settings/state, and activity implementations
- `src/network/`: web server and OTA/update networking - `src/network/`: web server and OTA/update networking
- `src/components/`: theming and shared UI components - `src/components/`: theming and shared UI components
- `lib/hal/`: hardware abstraction wrappers around open-x4-sdk - `lib/hal/`: hardware abstraction wrappers around freeink-sdk
- `lib/Epub/`: EPUB parser, layout, CSS handling, and hyphenation - `lib/Epub/`: EPUB parser, layout, CSS handling, and hyphenation
- `lib/`: supporting libraries (fonts, text, filesystem helpers, etc.) - `lib/`: supporting libraries (fonts, text, filesystem helpers, etc.)
- `open-x4-sdk/`: hardware SDK submodule (display, input, storage, battery) - `freeink-sdk/`: hardware SDK submodule (display, input, storage, battery). Docs: https://freeink.org/docs
- `docs/`: user and technical documentation - `docs/`: user and technical documentation
## Embedded constraints that shape design ## Embedded constraints that shape design
+889
View File
@@ -0,0 +1,889 @@
# SD-card theme creation
CrossPoint ships one built-in base theme, Lyra. Additional themes live on the SD card and are selected from Settings. A downloaded theme is just a folder containing a `theme.json` and optional assets such as 1-bit BMP icons.
CrossPoint ignores unknown JSON fields. Other readers, such as CrossInk, can add their own fields under a namespaced object like `extensions.crossink` without breaking CrossPoint.
## Folder layout
Manual install paths:
```text
/.themes/<theme-id>/theme.json # hidden folder used by the downloader
/themes/<theme-id>/theme.json # visible folder for manual installs
```
Hosted theme packages live in the tools repo under:
```text
../crosspoint-tools/public/themes/<theme-id>/theme.json
../crosspoint-tools/public/themes/<theme-id>/icons/*.bmp
```
Theme ids must be path-safe: letters, numbers, `-`, and `_` only. Spaces are not accepted because ids are used in folder names, URLs, and settings.
## Minimal theme
```json
{
"schema": 1,
"id": "my-theme",
"name": "My Theme",
"description": "Short user-facing description shown in the downloader.",
"inherits": "lyra",
"metrics": {
"homeTopPadding": 48,
"menuRowHeight": 42
},
"components": {
"homeMenu": {
"font": "medium",
"style": "regular",
"centeredText": true,
"selectionStyle": "underline",
"showIcons": false
}
},
"devices": {
"x3": {
"constraints": {
"screenWidth": 480,
"screenHeight": 800,
"frontButtons": 4,
"sideButtons": "up-down"
}
},
"x4": {
"constraints": {
"screenWidth": 480,
"screenHeight": 800,
"frontButtons": 0,
"sideButtons": "up-down"
}
}
}
}
```
Top-level fields:
- `schema`: currently `1`.
- `id`: stable id used for settings, folder name, and downloads.
- `name`: display name shown in Settings and the downloader.
- `description`: short downloader text.
- `inherits`: `lyra` for normal SD themes. `classic` is accepted for manually installed themes that intentionally build from the Classic renderer.
- `metrics`: layout numbers shared across screens.
- `components`: style rules for themeable UI surfaces.
- `assets.icons`: optional icon file map.
- `devices`: optional per-device overrides keyed by `x3` or `x4`.
- `requires`: optional metadata for other tooling. CrossPoint currently ignores it.
- `extensions`: optional namespaced metadata for other firmware/apps. CrossPoint currently ignores it.
## Device overrides
The active device id is `x3` or `x4`. Any supported field under `devices.<device-id>` overrides the top-level value:
```json
{
"metrics": {
"homeCoverHeight": 300
},
"components": {
"homeRecents": {
"maxBooks": 3
}
},
"devices": {
"x3": {
"metrics": {
"homeCoverHeight": 280
},
"components": {
"homeRecents": {
"maxBooks": 3
}
}
}
}
}
```
Use `constraints` to document intended screen and button assumptions for builders and compatible apps:
```json
"constraints": {
"screenWidth": 480,
"screenHeight": 800,
"frontButtons": 4,
"sideButtons": "up-down"
}
```
CrossPoint parses these constraints but does not reject themes when they do not match.
## Metrics
Metrics tune global spacing and layout. Any omitted metric keeps Lyra's default.
Common home/list metrics:
- `topPadding`: top inset above normal page headers.
- `headerHeight`: default header band height for non-home screens.
- `verticalSpacing`: default vertical gap between major screen regions.
- `contentSidePadding`: left/right inset used by default list and menu renderers.
- `listRowHeight`: row height for single-line lists.
- `listWithSubtitleRowHeight`: row height for two-line lists such as Recent Books.
- `menuRowHeight`: height of one home menu tile. In `launcherGrid`, this is used by `drawButtonMenu` inside each grid cell; it is not the gap between grid cells.
- `menuSpacing`: vertical spacing between items when rendering a plain one-column home menu. It does not affect `launcherGrid`, because each grid cell is rendered as a one-item menu.
- `tabSpacing`: spacing between tab labels.
- `tabBarHeight`: height of the settings tab bar.
- `scrollBarWidth`: list scrollbar width.
- `scrollBarRightOffset`: list scrollbar inset from the right edge.
- `homeTopPadding`: top inset before the home cover/recent-books area in the legacy home renderer.
- `homeCoverHeight`: cover image height used by home recents.
- `homeCoverTileHeight`: total home recents tile/slot height, including cover title space when applicable.
- `homeRecentBooksCount`: number of recent books to request/render on home.
- `homeContinueReadingInMenu`: whether Continue Reading is part of the home launcher/menu actions.
- `homeShowContinueReadingHeader`: whether the current book title can appear in the home header.
- `homeMenuTopOffset`: legacy/manual home menu offset below the cover area. SD `screens.home.layout` themes should prefer explicit layout slots such as `carouselMenuGap`.
- `buttonHintsHeight`: bottom button-hint band height.
- `sideButtonHintsWidth`: side button-hint band width.
Other supported metric groups:
- Battery: `batteryWidth`, `batteryHeight`, `batteryBarHeight`
- Reader progress/status: `progressBarHeight`, `progressBarMarginTop`, `statusBarHorizontalMargin`, `statusBarVerticalMargin`
- Keyboard: `keyboardKeyWidth`, `keyboardKeyHeight`, `keyboardKeySpacing`, `keyboardBottomKeyHeight`, `keyboardBottomKeySpacing`, `keyboardBottomAligned`, `keyboardCenteredText`, `keyboardVerticalOffset`, `keyboardTextFieldWidthPercent`, `keyboardWidthPercent`, `keyboardKeyCornerRadius`, `keyboardFillUnselected`, `keyboardOutlineAllUnselected`, `keyboardDrawSpecialOutlineWhenUnselected`, `keyboardSecondaryLabelRightPadding`, `keyboardSecondaryLabelTopPadding`, `keyboardMinArrowHeadSize`
- Popups: `popupTopOffsetRatio`, `popupMarginX`, `popupMarginY`, `popupFrameThickness`, `popupCornerRadius`, `popupTextBold`, `popupTextInverted`, `popupTextBaselineOffsetY`, `popupProgressBarHeight`, `popupProgressDrawOutline`, `popupProgressClampPercent`, `popupProgressFillInverted`, `popupProgressOutlineInverted`
- Text fields: `textFieldHorizontalPadding`, `textFieldNormalThickness`, `textFieldCursorThickness`, `textFieldLineEndOffset`
## Screen Layouts
Themes can define `screens.<screen>.layout` to place UI regions with the SDK row/column layout system. This is the preferred path for new SD themes.
Each layout node can contain:
- `id`: slot name used by widgets or firmware renderers.
- `axis`: `column` stacks children top-to-bottom; `row` lays children left-to-right.
- `gap`: pixels inserted between this node's direct children.
- `slots`: child layout nodes.
- `fixed`: exact pixel size along the parent axis.
- `flex`: proportional size after fixed children and gaps are subtracted.
- `token`: named size from `metrics`, such as `menuRow`, `recents`, `buttons`, `header`, `row`, `subtitleRow`, or `gap`.
Example:
```json
"screens": {
"home": {
"navigation": "linear",
"layout": {
"axis": "column",
"gap": 0,
"slots": [
{
"id": "header",
"fixed": 40,
"axis": "row",
"gap": 4,
"slots": [
{ "id": "homeClock", "fixed": 52 },
{ "id": "homeTitle", "flex": 1 },
{ "id": "homeBattery", "fixed": 66 }
]
},
{ "id": "recents", "fixed": 340 },
{ "id": "carouselMenuGap", "fixed": 36 },
{ "id": "launchers", "fixed": 192 },
{ "id": "homeSpacer", "flex": 1 },
{ "id": "buttons", "fixed": 40 }
]
}
}
}
```
Important layout rules:
- A parent layout's `gap` only affects its direct child slots.
- `fixed` and `flex` decide how much space a slot receives. They do not decide how a widget draws inside that slot.
- Widget-specific `gap` fields control spacing inside that widget.
- Named spacer slots such as `carouselMenuGap` and `homeSpacer` do not draw anything unless a widget targets them. They are useful for placing visible regions without manual `x`/`y` coordinates.
- If a screen layout is invalid or missing required slots, CrossPoint falls back to the built-in Lyra-safe layout for that screen.
Home `navigation` modes:
- `linear`: default. Front/side navigation buttons all move through the visible home actions as one ordered list.
- `splitAxis`: front left/right move through launcher actions; side up/down move through recent-book actions. Bottom button hints show Left/Right.
- `carousel`: front left/right move through recent-book actions; side up/down move through launcher actions. Use this when left/right should stay inside a cover carousel and up/down should enter or leave the launcher menu.
Home `initialAction` can optionally choose the default selected action when entering home normally:
```json
"initialAction": "reader:recent"
```
Supported values match launcher `action` values. Explicit firmware navigation, such as returning to Settings from a settings submenu, still overrides this default.
### Layouts vs widgets
Layouts only create named rectangles. They do not choose whether a screen is a list, cover grid, carousel, or any other presentation.
Widgets choose what renders inside those rectangles. This keeps themes explicit and prevents firmware from guessing a grid just because a screen has a `list` slot.
For `screens.recentBooks`, use:
- No `recentBooks` screen: use the built-in Lyra recent-books screen.
- `layout` only, or a `list` widget: use the normal themed recent-books list in the `list` slot.
- A `coverGrid` widget: use FreeInkUI's cover-grid component in the target slot.
Minimal themed list example:
```json
"recentBooks": {
"layout": {
"axis": "column",
"gap": 8,
"slots": [
{ "id": "header", "fixed": 48 },
{ "id": "list", "flex": 1 },
{ "id": "buttons", "fixed": 40 }
]
},
"widgets": [
{ "slot": "list", "type": "list" }
]
}
```
Cover-grid screen example:
```json
"recentBooks": {
"layout": {
"axis": "column",
"gap": 16,
"slots": [
{ "id": "header", "fixed": 48 },
{ "id": "list", "flex": 1 },
{ "id": "buttons", "fixed": 40 }
]
},
"widgets": [
{
"slot": "list",
"type": "coverGrid",
"columns": 3,
"rowGap": 36,
"coverWidth": 92,
"coverHeight": 132,
"rowHeight": 172,
"labelLines": 2,
"selectionStyle": "coverFrame"
}
]
}
```
Do not use screen-level `coverGrid`. Cover-grid settings belong on a widget with `type: "coverGrid"`.
### Home widgets
Home layouts use `screens.home.widgets` to map slot rectangles to visible content.
Supported widget types:
- `clock`: draws the clock when the device has RTC support. On devices without clock support, the slot stays empty.
- `headerTitle`: draws the normal home/header title.
- `battery`: draws the battery indicator.
- `recents`: draws the configured home recents component.
- `recentCoverGrid`: draws recent books with FreeInkUI's `coverGrid` component.
- `launcherList`: draws actions as one vertical menu inside its slot.
- `launcherGrid`: draws actions in a row/column grid inside its slot.
- `buttonHints`: draws bottom button hints.
`launcherGrid` fields:
- `slot`: slot id to render into.
- `presentation`: optional presentation style. Use `iconTabs` for icon-only launcher tabs with outlined unselected cells and filled selected cells.
- `columns`: number of grid columns.
- `rows`: optional fixed row count. If omitted, rows are derived from visible launcher count and columns.
- `gap`: pixels between grid cells, both horizontally and vertically.
- `items`: launcher actions. Each item accepts `text`, `icon`, and `action`.
All home widgets also support visual placement fields:
- `layer`: draw order. Lower layers draw first; higher layers paint on top. Widgets with the same layer keep JSON order.
- `offsetX`: moves the widget right after layout. Negative values move left.
- `offsetY`: moves the widget down after layout. Negative values move up.
- `bleed`: expands the widget draw rectangle outside its slot without changing layout. Use either a single number or `{ "top": 0, "right": 0, "bottom": 0, "left": 0 }`.
- `inset`: shrinks the widget draw rectangle inside its slot without changing layout. Use either a single number or `{ "top": 0, "right": 0, "bottom": 0, "left": 0 }`.
Example overlap:
```json
{
"slot": "recents",
"type": "recents",
"layer": 0,
"bleed": { "bottom": 24 }
},
{
"slot": "launchers",
"type": "launcherGrid",
"layer": 10,
"offsetY": -12,
"columns": 2,
"gap": 24
}
```
That keeps the structural row/column layout intact, but lets the launcher grid visually overlap the recents area by 12 pixels.
`buttonHints` widget fields:
- `labels.confirm`
- `labels.previous`
- `labels.next`
- `labels.back`
Button-hint labels are localized semantic tokens, not literal UI strings. Supported tokens are `default`, `empty`, `back`, `home`, `select`, `confirm`, `open`, `toggle`, `up`, `down`, `left`, and `right`. `default` uses the firmware fallback for that navigation mode; `empty` renders no label for that button.
Example carousel hints:
```json
{
"slot": "buttons",
"type": "buttonHints",
"labels": {
"confirm": "select",
"previous": "left",
"next": "right"
}
}
```
When `components.buttonHints.layout` is `shapes` or `icons`, these same localized tokens render as button shapes/icons where supported.
Example icon tabs:
```json
{
"slot": "tabs",
"type": "launcherGrid",
"presentation": "iconTabs",
"columns": 5,
"rows": 1,
"gap": 6,
"iconSize": 32,
"selectedRadius": 5,
"items": [
{ "icon": "folder", "action": "activity:fileBrowser" },
{ "icon": "recent", "action": "activity:recentBooks" },
{ "icon": "library", "action": "activity:opds" }
]
}
```
Launcher actions:
- `activity:fileBrowser`
- `activity:recentBooks`
- `activity:opds`
- `activity:fileTransfer`
- `activity:settings`
- `activity:reader`
For `launcherGrid`, the final cell height is:
```text
(slot height - gap * (rows - 1)) / rows
```
Then each cell calls the themed home menu renderer with one item. That means:
- Increase the widget `gap` to create more visible space between grid items.
- Increase the launcher slot `fixed` height if larger gaps need more total room.
- Use `menuRowHeight` to tune the selectable tile/text/icon band inside each cell.
- Do not expect `menuSpacing` to change `launcherGrid` spacing.
For a 3-row launcher grid with `menuRowHeight: 48` and `gap: 24`, use a launcher slot near:
```text
3 * 48 + 2 * 24 = 192
```
`recentCoverGrid` / recent-books `coverGrid` widget fields:
- `slot`: slot id to render into.
- `columns`: grid columns.
- `rows`: grid rows.
- `gap`: horizontal pixels between cells. Also used vertically when `rowGap` is omitted.
- `rowGap`: vertical pixels between cover-grid rows.
- `cellInset`: optional padding inside each cover-grid cell, before the cover and label are drawn.
- `labelInset`: optional padding inside the title label area. Use `{ "left": 5, "right": 5 }` to keep two-line titles away from cell edges.
- `coverWidth`: rendered cover width.
- `coverHeight`: rendered cover height and thumbnail size to generate.
- `placeholderIconSize`: maximum icon size for the missing-cover placeholder.
- `rowHeight`: height of each cell row, including label space.
- `labelHeight`: title label area below each cover. Use `0` to hide titles.
- `labelGap`: vertical pixels between the cover and title label block.
- `labelLines`: maximum title lines to render. Increase `rowHeight` when this is greater than `1`.
- `selectionStyle`: `fill`, `outline`, `coverFrame`, or `none`. Prefer `coverFrame` for cover grids because it frames only the thumbnail and does not depend on title wrapping.
- `startIndex`: first recent-book index to show. Use `2` when a featured area already uses the first two books.
These cover-grid widgets use FreeInkUI's `coverGrid` for layout, labels, cell styling, and selected state. CrossPoint supplies a cover painter callback so SD-card thumbnails render from the existing recent-book cache.
Cover widgets can use different visual `coverWidth` and `coverHeight` values on different screens. CrossPoint still generates and reads one largest-needed thumbnail height for the active theme, then scales/crops it into each widget. That keeps the same book cover available on home and recent-books instead of requiring separate BMPs per widget.
`featuredBookCard` fields:
- `coverWidth`, `coverHeight`: rendered cover size and thumbnail height to generate.
- `placeholderIconSize`: maximum icon size for the missing-cover placeholder.
- `coverGap`: horizontal gap between the cover and title/author text.
- `titleGap`: vertical gap below the Continue Reading label before the book card starts.
- `startIndex`: recent-book index to show.
## Components
### Fonts
Most components accept:
```json
"font": "large",
"style": "bold"
```
Supported `font` values are `small`, `medium`, and `large`.
Semantic aliases are also accepted:
- `chrome`, `caption`: same as `small`.
- `body`, `label`: same as `medium`.
- `title`, `display`: same as `large`.
Supported `style` values are `regular` and `bold`.
### Home recents
`components.homeRecents` controls the home cover area.
Supported types:
- `default`: Lyra default.
- `none`: no cover area.
- `cover-strip`: one or more cover slots.
Example:
```json
"homeRecents": {
"type": "cover-strip",
"maxBooks": 3,
"wrap": true,
"selectionLineWidth": 3,
"inactiveSelectionLineWidth": 1,
"selectionCornerRadius": 6,
"slots": [
{
"book": "previous",
"x": "padding",
"y": "center",
"height": 210,
"widthPercent": 62
},
{
"book": "selected",
"x": "center",
"y": "top",
"height": 280,
"widthPercent": 62,
"selected": true,
"title": {
"enabled": true,
"font": "large",
"style": "bold",
"maxLines": 2,
"offsetY": 12
}
},
{
"book": "next",
"x": "right-padding",
"y": "center",
"height": 210,
"widthPercent": 62
}
]
}
```
Slot fields:
- `book`: `selected`, `previous`, `next`, or `index`.
- `bookIndex`: zero-based index when `book` is `index`.
- `x`: `padding`, `center`, or `right-padding`.
- `y`: `top` or `center`.
- `height`: requested thumbnail height. CrossPoint generates/cache-misses thumbnails at requested sizes.
- `widthPercent`: cover width as a percent of the slot height.
- `xOffset`, `yOffset`: positional adjustments.
- `selected`: whether this slot receives the active selection outline.
- `title`: optional book title under the cover.
CrossPoint currently reads up to five cover slots.
Cover slots with `selected: true` draw after unselected slots, so selected covers appear in front. Within each group, slots draw in the same order they appear in JSON. For a carousel where the side covers sit behind the middle cover, mark the middle slot as `selected: true`.
Use `xOffset` and `yOffset` for small relative adjustments after `x`/`y` placement has been resolved:
- Positive `xOffset` moves a cover right.
- Negative `xOffset` moves a cover left.
- Positive `yOffset` moves a cover down.
- Negative `yOffset` moves a cover up.
Example carousel layering:
```json
"slots": [
{
"book": "previous",
"x": "padding",
"y": "center",
"height": 225,
"widthPercent": 62,
"xOffset": 32
},
{
"book": "next",
"x": "right-padding",
"y": "center",
"height": 225,
"widthPercent": 62,
"xOffset": -32
},
{
"book": "selected",
"x": "center",
"y": "top",
"height": 300,
"widthPercent": 62,
"selected": true
}
]
```
In that example, the side covers are pushed toward the center, and the selected cover is drawn in the foreground.
### Home menu
`components.homeMenu` styles the home menu options.
Supported fields:
- `font`, `style`, `bold`
- `centeredText`
- `centerVertically`
- `showIcons`
- `panelWidth`
- `drawPanel`
- `panelCornerRadius`
- `selectionStyle`: `fill`, `outline`, `triangle`, `underline`, or `pill`
- `selectionCornerRadius`
- `selectionInset`
- `selectedTextInverted`
- `selectionFillBlack`
- `rowPaddingX`
- `textInsetX`
### Lists
`components.list` styles Settings, Browse, Recent Books, and similar list rows.
Supported fields:
- `font`, `style`, `bold`
- `subtitleFontId`
- `valueFontId`
- `showIcons`
- `iconSize`
- `textGap`
- `selectionStyle`: `fill`, `outline`, or `underline`
- `selectionCornerRadius`
- `selectionFill`
- `selectionOutline`
- `selectedTextInverted`
- `rowBackgrounds`
- `centerSingleLineRows`
- `subtitleRowAutoHeight`
- `centerValueVertically`
- `rowSidePadding`
- `rowGap`
- `textInsetX`
- `selectionInsetX`
- `selectionInsetY`
- `titleOffsetY`
- `subtitleOffsetY`
- `subtitleTopPadding`
- `subtitleBottomPadding`
- `subtitleInterLineGap`
- `valueOffsetY`
- `subtitleValueOffsetY`
- `iconOffsetY`
### Header
`components.header` styles page headers.
Supported fields:
- `font`, `style`, `bold`
- `centeredTitle`
- `showDivider`
- `titleOffsetY`
- `batteryOffsetY`
### Tab bar
`components.tabBar` styles tabs.
Supported fields:
- `font`, `style`, `bold`
- `equalWidth`
- `selectionStyle`: `fill` or `underline`
- `selectedCornerRadius`
- `selectedTextInverted`
- `drawDivider`
- `horizontalInset`
### Button hints
`components.buttonHints` styles bottom and side button hints.
Supported fields:
- `font`, `style`, `bold`
- `layout`: `buttons`, `groups`, `shapes`, or `icons`
- `buttonWidth`
- `smallButtonHeight`
- `cornerRadius`
- `fill`
- `outline`
- `drawEmpty`
- `shapes`
- `sidePadding`
- `groupGap`
- `bottomMargin`
- `innerPadding`
- `shapeSize`
- `textOffsetY`
Use `layout: "shapes"` or `layout: "icons"` for icon-only arrows/circle/square hints.
### Reader chrome
`screens.reader.chrome` styles the reader status lane. Reader chrome still uses `screens.reader.layout` slots for placement; the chrome object controls how those slots draw.
Battery fields:
- `style`: `icon` or `bar`.
- `width`: battery glyph width in pixels.
- `height`: battery glyph height in pixels.
- `offsetY`: vertical adjustment applied after the battery is positioned in its slot. Positive values move it down; negative values move it up.
- `track`: background/track style for bar batteries: `none`, `hairline`, `outline`, or `dither`.
- `fill`: fill style for bar batteries: `solid`, `dither`, or `segments`.
- `direction`: fill direction: `left-to-right`, `right-to-left`, `center-out`, `bottom-to-top`, or `top-to-bottom`.
- `orientation`: `horizontal` or `vertical`. Vertical is also implied by `bottom-to-top` and `top-to-bottom`.
- `caps`: `square` or `pixel`. `pixel` trims the four filled corners for a softer e-ink cap.
- `segments`: number of filled blocks when `fill` is `segments`.
- `segmentGap`: pixels between segments.
- `radius`: rounded-rect radius for bar track/fill/segments. Keep this small for thin e-ink bars; `0` is square.
- `showPercentage`: whether reader chrome may draw the battery percentage when the global setting allows it.
Example:
```json
"screens": {
"reader": {
"layout": {
"axis": "row",
"gap": 8,
"slots": [
{ "id": "bookmark", "fixed": 18 },
{ "id": "battery", "fixed": 38 },
{ "id": "title", "flex": 1 },
{ "id": "clock", "fixed": 42 },
{ "id": "progress", "fixed": 82 }
]
},
"chrome": {
"battery": {
"style": "bar",
"width": 38,
"height": 3,
"offsetY": 1,
"track": "none",
"fill": "solid",
"direction": "left-to-right",
"radius": 0,
"showPercentage": false
}
}
}
}
```
## Icons
Icons are optional. If both `homeMenu.showIcons` and `list.showIcons` are false, omit `assets.icons` and the icon files to reduce download size and heap use.
Supported icon keys:
- `folder`, `folder24`
- `text`, `text24`
- `image`, `image24`
- `book`, `book24`
- `file`, `file24`
- `recent`
- `settings`, `settings2`
- `transfer`
- `library`
- `wifi`
- `hotspot`
- `bookmark`
Generate firmware-matching 1-bit BMP icons:
```bash
python3 scripts/generate-theme-icons.py \
--icons src/components/icons \
--themes ../crosspoint-tools/public/themes
```
The script writes rotated BMP files into each `../crosspoint-tools/public/themes/<theme-id>/icons/` folder.
Reference them from `theme.json`:
```json
"assets": {
"icons": {
"folder": "icons/folder.bmp",
"book": "icons/book.bmp",
"settings": "icons/settings2.bmp"
}
}
```
## CrossInk and extension fields
CrossPoint only consumes the fields documented above. Unknown fields are ignored, so theme authors can include extra data for compatible apps and firmware.
Put app-specific fields under `extensions.<namespace>`:
```json
{
"schema": 1,
"id": "crossink-stats",
"name": "CrossInk Stats",
"inherits": "lyra",
"components": {
"homeRecents": {
"type": "cover-strip",
"maxBooks": 1
}
},
"extensions": {
"crossink": {
"schema": 1,
"readingStats": {
"enabled": true,
"placement": "home-footer",
"font": "small",
"style": "regular",
"show": [
"currentStreak",
"readingTime",
"pagesRead",
"percentComplete"
],
"labels": {
"currentStreak": "streak",
"readingTime": "reading",
"pagesRead": "pages"
}
}
}
}
}
```
Recommended extension rules:
- Keep CrossPoint layout fields in `metrics`, `components`, `assets`, and `devices`.
- Keep CrossInk-only fields under `extensions.crossink`.
- Add an extension-local `schema` when the app-specific format may evolve.
- Prefer declarative fields such as `placement`, `font`, `show`, and `labels` over code-like strings.
- Keep extension data compact. CrossPoint ignores it, but it is still parsed transiently when discovering themes.
- Do not put required CrossPoint behavior only in an extension field. CrossPoint will not read it.
CrossInk can also use `requires` for compatibility metadata:
```json
"requires": {
"crosspoint": {
"schema": 1,
"modules": ["cover-strip"]
},
"crossink": {
"schema": 1,
"modules": ["reading-stats"]
}
}
```
CrossPoint currently treats `requires` as metadata.
## Package manifest
After adding or changing hosted themes, regenerate `themes.json` in `crosspoint-tools`:
```bash
python3 scripts/generate-theme-manifest.py \
--root ../crosspoint-tools/public/themes \
--base-url http://crosspointreader.com/themes \
--output ../crosspoint-tools/public/themes/themes.json
```
The manifest generator:
- scans every `../crosspoint-tools/public/themes/<theme-id>/theme.json`
- includes every file in each theme folder
- writes per-file `size` and `crc32`
- writes the theme `id`, `name`, `description`, and `totalSize`
Commit the theme files and the regenerated manifest together in `crosspoint-tools`.
## Validation checklist
Before publishing:
```bash
for f in ../crosspoint-tools/public/themes/themes.json ../crosspoint-tools/public/themes/*/theme.json; do
python3 -m json.tool "$f" >/dev/null
done
python3 scripts/generate-theme-manifest.py \
--root ../crosspoint-tools/public/themes \
--base-url http://crosspointreader.com/themes \
--output ../crosspoint-tools/public/themes/themes.json
pio run -e gh_release
```
On device:
1. Download the theme from Settings -> UI Theme -> Download Themes.
2. Exit the downloader and let the device silently restart to clear WiFi/TLS heap.
3. Return to Settings -> UI Theme and select the downloaded theme.
4. Check Home, Settings, Browse, Recent Books, button hints, tabs, popups, keyboard, and reader menus.
+20
View File
@@ -19,6 +19,26 @@ const SdCardFontFileInfo* SdCardFontFamilyInfo::findClosestReaderSize(const uint
const uint8_t style) const { const uint8_t style) const {
if (files.empty()) return nullptr; if (files.empty()) return nullptr;
// Collect sizes matching the requested style, sorted ascending.
std::vector<uint8_t> sizes;
for (const auto& f : files) {
if (f.style != style) continue;
sizes.push_back(f.pointSize);
}
if (sizes.empty()) return nullptr;
std::sort(sizes.begin(), sizes.end());
// When the family provides at least 4 sizes, use ordinal (index-based)
// selection so custom-built font sets (e.g. 10/12/14/16) map SMALL to
// the smallest file, not to a hardcoded 12pt target.
if (sizes.size() >= 4) {
uint8_t idx = fontSizeEnum;
if (idx >= sizes.size()) idx = sizes.size() - 1;
return findFile(sizes[idx], style);
}
// Fewer sizes than enum slots (e.g. CJK packs with only 2-3 sizes):
// fall back to closest-match against the built-in reader targets.
uint8_t target = 14; uint8_t target = 14;
switch (fontSizeEnum) { switch (fontSizeEnum) {
case 0: case 0:
-2
View File
@@ -37,5 +37,3 @@
#include <builtinFonts/ubuntu_10_regular.h> #include <builtinFonts/ubuntu_10_regular.h>
#include <builtinFonts/ubuntu_12_bold.h> #include <builtinFonts/ubuntu_12_bold.h>
#include <builtinFonts/ubuntu_12_regular.h> #include <builtinFonts/ubuntu_12_regular.h>
#include <builtinFonts/ubuntu_14_bold.h>
#include <builtinFonts/ubuntu_14_regular.h>
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
-7
View File
@@ -94,13 +94,6 @@ ruby -rdigest -e 'puts [
].map{|f| Digest::SHA256.hexdigest(File.read(f)).to_i(16) }.sum % (2 ** 32) - (2 ** 31)' ].map{|f| Digest::SHA256.hexdigest(File.read(f)).to_i(16) }.sum % (2 ** 32) - (2 ** 31)'
))" ))"
echo "#define UI_14_FONT_ID ($(
ruby -rdigest -e 'puts [
"./ubuntu_14_regular.h",
"./ubuntu_14_bold.h",
].map{|f| Digest::SHA256.hexdigest(File.read(f)).to_i(16) }.sum % (2 ** 32) - (2 ** 31)'
))"
echo "#define SMALL_FONT_ID ($( echo "#define SMALL_FONT_ID ($(
ruby -rdigest -e 'puts [ ruby -rdigest -e 'puts [
"./notosans_8_regular.h", "./notosans_8_regular.h",
+12 -31
View File
@@ -28,42 +28,23 @@ for size in ${NOTOSANS_FONT_SIZES[@]}; do
done done
done done
# Small UI chrome (button devices, uiScale 1.0). Rendered 1-bit: crisp at these
# sizes and half the flash of 2-bit.
UI_FONT_SIZES=(10 12) UI_FONT_SIZES=(10 12)
# Larger UI chrome substituted in on touch/high-density boards via the uiScale
# remap (see src/main.cpp setupFonts). Rendered 2-bit so it stays smooth when
# enlarged. Touch boards use uiScale 1.2, so UI_12 -> 14.4 -> 14 is the size the
# remap actually lands on; add larger sizes here if a board adopts a higher scale.
UI_FONT_SIZES_LARGE=(14)
UI_FONT_STYLES=("Regular" "Bold") UI_FONT_STYLES=("Regular" "Bold")
# Ubuntu lacks the Latin Extended Additional block (U+1EA0-U+1EF9) used for
# Vietnamese tone marks. Append a Vietnamese-only Ubuntu cut so those glyphs are
# filled from it while every glyph Ubuntu already has stays unchanged (fontstack
# is ordered by descending priority). NotoSansHebrew fills U+05D0-U+05EA so the
# Hebrew UI translation renders in menus and settings.
generate_ui_font() {
local size="$1" style="$2" extra_flags="$3"
local font_name="ubuntu_${size}_$(echo $style | tr '[:upper:]' '[:lower:]')"
local font_path="../builtinFonts/source/Ubuntu/Ubuntu-${style}.ttf"
local hebrew_path="../builtinFonts/source/NotoSansHebrew/NotoSansHebrew-${style}.ttf"
local viet_path="../builtinFonts/source/Ubuntu/Ubuntu-Vietnamese-${style}.ttf"
local output_path="../builtinFonts/${font_name}.h"
python fontconvert.py $font_name $size $font_path $hebrew_path $viet_path \
--additional-intervals 0x05D0,0x05EA $extra_flags > $output_path
echo "Generated $output_path"
}
for size in ${UI_FONT_SIZES[@]}; do for size in ${UI_FONT_SIZES[@]}; do
for style in ${UI_FONT_STYLES[@]}; do for style in ${UI_FONT_STYLES[@]}; do
generate_ui_font $size $style "" font_name="ubuntu_${size}_$(echo $style | tr '[:upper:]' '[:lower:]')"
done font_path="../builtinFonts/source/Ubuntu/Ubuntu-${style}.ttf"
done hebrew_path="../builtinFonts/source/NotoSansHebrew/NotoSansHebrew-${style}.ttf"
# Ubuntu lacks the Latin Extended Additional block (U+1EA0-U+1EF9) used for
for size in ${UI_FONT_SIZES_LARGE[@]}; do # Vietnamese tone marks. Append a Vietnamese-only Ubuntu cut so those glyphs
for style in ${UI_FONT_STYLES[@]}; do # are filled from it while every glyph Ubuntu already has stays unchanged
generate_ui_font $size $style "--2bit --compress" # (fontstack is ordered by descending priority).
viet_path="../builtinFonts/source/Ubuntu/Ubuntu-Vietnamese-${style}.ttf"
output_path="../builtinFonts/${font_name}.h"
python fontconvert.py $font_name $size $font_path $hebrew_path $viet_path \
--additional-intervals 0x05D0,0x05EA > $output_path
echo "Generated $output_path"
done done
done done
+3 -2
View File
@@ -40,7 +40,8 @@ INTERVAL_PRESETS = {
"ascii": [(0x0020, 0x007E)], "ascii": [(0x0020, 0x007E)],
"latin1": [(0x0080, 0x00FF)], "latin1": [(0x0080, 0x00FF)],
"latin-ext": [(0x0020, 0x007E), (0x0080, 0x00FF), (0x0100, 0x024F), "latin-ext": [(0x0020, 0x007E), (0x0080, 0x00FF), (0x0100, 0x024F),
(0x1E00, 0x1EFF), (0x2000, 0x206F), (0xFB00, 0xFB06)], (0x02B0, 0x02FF), (0x1E00, 0x1EFF), (0x2000, 0x206F),
(0xFB00, 0xFB06)],
"greek": [(0x0370, 0x03FF), (0x1F00, 0x1FFF)], "greek": [(0x0370, 0x03FF), (0x1F00, 0x1FFF)],
"cyrillic": [(0x0400, 0x04FF), (0x0500, 0x052F)], "cyrillic": [(0x0400, 0x04FF), (0x0500, 0x052F)],
"hebrew": [(0x0590, 0x05FF), (0xFB1D, 0xFB4F)], "hebrew": [(0x0590, 0x05FF), (0xFB1D, 0xFB4F)],
@@ -62,7 +63,7 @@ INTERVAL_PRESETS = {
# Composite preset for English-language literary fiction including scifi/popsci. # Composite preset for English-language literary fiction including scifi/popsci.
# Greek for physics terms, math operators, geometric shapes, uncommon # Greek for physics terms, math operators, geometric shapes, uncommon
# dialogue punctuation, CJK quote marks, miscellaneous symbols (♪♫♬), dingbats. # dialogue punctuation, CJK quote marks, miscellaneous symbols (♪♫♬), dingbats.
"reading": [(0x0020, 0x024F), (0x0300, 0x036F), (0x0370, 0x03FF), "reading": [(0x0020, 0x024F), (0x02B0, 0x02FF), (0x0300, 0x036F), (0x0370, 0x03FF),
(0x0400, 0x04FF), (0x1E00, 0x1EFF), (0x2000, 0x206F), (0x0400, 0x04FF), (0x1E00, 0x1EFF), (0x2000, 0x206F),
(0x2070, 0x209F), (0x20A0, 0x20CF), (0x2150, 0x218F), (0x2070, 0x209F), (0x20A0, 0x20CF), (0x2150, 0x218F),
(0x2190, 0x21FF), (0x2200, 0x22FF), (0x2500, 0x257F), (0x2190, 0x21FF), (0x2200, 0x22FF), (0x2500, 0x257F),
+13 -71
View File
@@ -14,47 +14,8 @@ constexpr uint8_t BOOK_CACHE_VERSION = 8; // v8: TOC/book titles stored NFC-com
constexpr char bookBinFile[] = "/book.bin"; constexpr char bookBinFile[] = "/book.bin";
constexpr char tmpSpineBinFile[] = "/spine.bin.tmp"; constexpr char tmpSpineBinFile[] = "/spine.bin.tmp";
constexpr char tmpTocBinFile[] = "/toc.bin.tmp"; constexpr char tmpTocBinFile[] = "/toc.bin.tmp";
constexpr uint32_t MAX_CACHE_STRING_LEN = 4096;
bool readStringBounded(HalFile& file, std::string& out, const uint32_t maxLen = MAX_CACHE_STRING_LEN) {
uint32_t len = 0;
if (file.read(&len, sizeof(len)) != static_cast<int>(sizeof(len))) {
return false;
}
if (len > maxLen || len > static_cast<uint32_t>(file.available())) {
LOG_ERR("BMC", "Invalid cache string length: %lu (max=%lu available=%d)", static_cast<unsigned long>(len),
static_cast<unsigned long>(maxLen), file.available());
return false;
}
out.clear();
if (len == 0) {
return true;
}
out.resize(len);
return file.read(out.data(), len) == static_cast<int>(len);
}
class CacheIoLock {
public:
explicit CacheIoLock(SemaphoreHandle_t mutex) : mutex(mutex) {
if (mutex) xSemaphoreTakeRecursive(mutex, portMAX_DELAY);
}
~CacheIoLock() {
if (mutex) xSemaphoreGiveRecursive(mutex);
}
private:
SemaphoreHandle_t mutex;
};
} // namespace } // namespace
BookMetadataCache::~BookMetadataCache() {
if (ioMutex) {
vSemaphoreDelete(ioMutex);
ioMutex = nullptr;
}
}
/* ============= WRITING / BUILDING FUNCTIONS ================ */ /* ============= WRITING / BUILDING FUNCTIONS ================ */
bool BookMetadataCache::beginWrite() { bool BookMetadataCache::beginWrite() {
@@ -414,7 +375,6 @@ void BookMetadataCache::createTocEntry(const std::string& title, const std::stri
/* ============= READING / LOADING FUNCTIONS ================ */ /* ============= READING / LOADING FUNCTIONS ================ */
bool BookMetadataCache::load() { bool BookMetadataCache::load() {
CacheIoLock ioLock(ioMutex);
if (!Storage.openFileForRead("BMC", cachePath + bookBinFile, bookFile)) { if (!Storage.openFileForRead("BMC", cachePath + bookBinFile, bookFile)) {
return false; return false;
} }
@@ -432,13 +392,11 @@ bool BookMetadataCache::load() {
serialization::readPod(bookFile, spineCount); serialization::readPod(bookFile, spineCount);
serialization::readPod(bookFile, tocCount); serialization::readPod(bookFile, tocCount);
if (!readStringBounded(bookFile, coreMetadata.title) || !readStringBounded(bookFile, coreMetadata.author) || serialization::readString(bookFile, coreMetadata.title);
!readStringBounded(bookFile, coreMetadata.language) || !readStringBounded(bookFile, coreMetadata.coverItemHref) || serialization::readString(bookFile, coreMetadata.author);
!readStringBounded(bookFile, coreMetadata.textReferenceHref)) { serialization::readString(bookFile, coreMetadata.language);
LOG_ERR("BMC", "Invalid cache metadata strings"); serialization::readString(bookFile, coreMetadata.coverItemHref);
bookFile.close(); serialization::readString(bookFile, coreMetadata.textReferenceHref);
return false;
}
loaded = true; loaded = true;
LOG_DBG("BMC", "Loaded cache data: %d spine, %d TOC entries", spineCount, tocCount); LOG_DBG("BMC", "Loaded cache data: %d spine, %d TOC entries", spineCount, tocCount);
@@ -446,7 +404,6 @@ bool BookMetadataCache::load() {
} }
BookMetadataCache::SpineEntry BookMetadataCache::getSpineEntry(const int index) { BookMetadataCache::SpineEntry BookMetadataCache::getSpineEntry(const int index) {
CacheIoLock ioLock(ioMutex);
if (!loaded) { if (!loaded) {
LOG_ERR("BMC", "getSpineEntry called but cache not loaded"); LOG_ERR("BMC", "getSpineEntry called but cache not loaded");
return {}; return {};
@@ -461,16 +418,11 @@ BookMetadataCache::SpineEntry BookMetadataCache::getSpineEntry(const int index)
bookFile.seek(lutOffset + sizeof(uint32_t) * index); bookFile.seek(lutOffset + sizeof(uint32_t) * index);
uint32_t spineEntryPos; uint32_t spineEntryPos;
serialization::readPod(bookFile, spineEntryPos); serialization::readPod(bookFile, spineEntryPos);
if (spineEntryPos >= bookFile.size()) {
LOG_ERR("BMC", "Spine entry offset out of range: %lu", static_cast<unsigned long>(spineEntryPos));
return {};
}
bookFile.seek(spineEntryPos); bookFile.seek(spineEntryPos);
return readSpineEntry(bookFile); return readSpineEntry(bookFile);
} }
BookMetadataCache::TocEntry BookMetadataCache::getTocEntry(const int index) { BookMetadataCache::TocEntry BookMetadataCache::getTocEntry(const int index) {
CacheIoLock ioLock(ioMutex);
if (!loaded) { if (!loaded) {
LOG_ERR("BMC", "getTocEntry called but cache not loaded"); LOG_ERR("BMC", "getTocEntry called but cache not loaded");
return {}; return {};
@@ -485,34 +437,24 @@ BookMetadataCache::TocEntry BookMetadataCache::getTocEntry(const int index) {
bookFile.seek(lutOffset + sizeof(uint32_t) * spineCount + sizeof(uint32_t) * index); bookFile.seek(lutOffset + sizeof(uint32_t) * spineCount + sizeof(uint32_t) * index);
uint32_t tocEntryPos; uint32_t tocEntryPos;
serialization::readPod(bookFile, tocEntryPos); serialization::readPod(bookFile, tocEntryPos);
if (tocEntryPos >= bookFile.size()) {
LOG_ERR("BMC", "TOC entry offset out of range: %lu", static_cast<unsigned long>(tocEntryPos));
return {};
}
bookFile.seek(tocEntryPos); bookFile.seek(tocEntryPos);
return readTocEntry(bookFile); return readTocEntry(bookFile);
} }
BookMetadataCache::SpineEntry BookMetadataCache::readSpineEntry(HalFile& file) const { BookMetadataCache::SpineEntry BookMetadataCache::readSpineEntry(HalFile& file) const {
SpineEntry entry; SpineEntry entry;
if (!readStringBounded(file, entry.href) || serialization::readString(file, entry.href);
file.read(&entry.cumulativeSize, sizeof(entry.cumulativeSize)) != serialization::readPod(file, entry.cumulativeSize);
static_cast<int>(sizeof(entry.cumulativeSize)) || serialization::readPod(file, entry.tocIndex);
file.read(&entry.tocIndex, sizeof(entry.tocIndex)) != static_cast<int>(sizeof(entry.tocIndex))) {
LOG_ERR("BMC", "Invalid spine cache entry");
return {};
}
return entry; return entry;
} }
BookMetadataCache::TocEntry BookMetadataCache::readTocEntry(HalFile& file) const { BookMetadataCache::TocEntry BookMetadataCache::readTocEntry(HalFile& file) const {
TocEntry entry; TocEntry entry;
if (!readStringBounded(file, entry.title) || !readStringBounded(file, entry.href) || serialization::readString(file, entry.title);
!readStringBounded(file, entry.anchor) || serialization::readString(file, entry.href);
file.read(&entry.level, sizeof(entry.level)) != static_cast<int>(sizeof(entry.level)) || serialization::readString(file, entry.anchor);
file.read(&entry.spineIndex, sizeof(entry.spineIndex)) != static_cast<int>(sizeof(entry.spineIndex))) { serialization::readPod(file, entry.level);
LOG_ERR("BMC", "Invalid TOC cache entry"); serialization::readPod(file, entry.spineIndex);
return {};
}
return entry; return entry;
} }
+2 -10
View File
@@ -1,7 +1,6 @@
#pragma once #pragma once
#include <HalStorage.h> #include <HalStorage.h>
#include <freertos/semphr.h>
#include <algorithm> #include <algorithm>
#include <deque> #include <deque>
@@ -55,7 +54,6 @@ class BookMetadataCache {
// Temp file handles during build // Temp file handles during build
HalFile spineFile; HalFile spineFile;
HalFile tocFile; HalFile tocFile;
SemaphoreHandle_t ioMutex;
// Index for fast href→spineIndex lookup (used only for large EPUBs) // Index for fast href→spineIndex lookup (used only for large EPUBs)
struct SpineHrefIndexEntry { struct SpineHrefIndexEntry {
@@ -87,14 +85,8 @@ class BookMetadataCache {
BookMetadata coreMetadata; BookMetadata coreMetadata;
explicit BookMetadataCache(std::string cachePath) explicit BookMetadataCache(std::string cachePath)
: cachePath(std::move(cachePath)), : cachePath(std::move(cachePath)), lutOffset(0), spineCount(0), tocCount(0), loaded(false), buildMode(false) {}
lutOffset(0), ~BookMetadataCache() = default;
spineCount(0),
tocCount(0),
loaded(false),
buildMode(false),
ioMutex(xSemaphoreCreateRecursiveMutex()) {}
~BookMetadataCache();
// Building phase (stream to disk immediately) // Building phase (stream to disk immediately)
bool beginWrite(); bool beginWrite();
+20 -3
View File
@@ -6,6 +6,20 @@
#include <new> #include <new>
namespace {
template <typename Predicate>
void renderFilteredPageElements(const std::vector<std::shared_ptr<PageElement>>& elements, GfxRenderer& renderer,
const int fontId, const int xOffset, const int yOffset, Predicate&& predicate) {
for (const auto& element : elements) {
if (predicate(*element)) {
element->render(renderer, fontId, xOffset, yOffset);
}
}
}
} // namespace
void PageLine::render(GfxRenderer& renderer, const int fontId, const int xOffset, const int yOffset) { void PageLine::render(GfxRenderer& renderer, const int fontId, const int xOffset, const int yOffset) {
block->render(renderer, fontId, xPos + xOffset, yPos + yOffset); block->render(renderer, fontId, xPos + xOffset, yPos + yOffset);
} }
@@ -93,9 +107,12 @@ std::unique_ptr<PageHorizontalRule> PageHorizontalRule::deserialize(HalFile& fil
} }
void Page::render(GfxRenderer& renderer, const int fontId, const int xOffset, const int yOffset) const { void Page::render(GfxRenderer& renderer, const int fontId, const int xOffset, const int yOffset) const {
for (auto& element : elements) { renderFilteredPageElements(elements, renderer, fontId, xOffset, yOffset, [](const PageElement&) { return true; });
element->render(renderer, fontId, xOffset, yOffset); }
}
void Page::renderImages(GfxRenderer& renderer, const int fontId, const int xOffset, const int yOffset) const {
renderFilteredPageElements(elements, renderer, fontId, xOffset, yOffset,
[](const PageElement& element) { return element.getTag() == TAG_PageImage; });
} }
bool Page::serialize(HalFile& file) const { bool Page::serialize(HalFile& file) const {
+1
View File
@@ -88,6 +88,7 @@ class Page {
} }
void render(GfxRenderer& renderer, int fontId, int xOffset, int yOffset) const; void render(GfxRenderer& renderer, int fontId, int xOffset, int yOffset) const;
void renderImages(GfxRenderer& renderer, int fontId, int xOffset, int yOffset) const;
bool serialize(HalFile& file) const; bool serialize(HalFile& file) const;
static std::unique_ptr<Page> deserialize(HalFile& file); static std::unique_ptr<Page> deserialize(HalFile& file);
+10 -3
View File
@@ -1006,7 +1006,10 @@ void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const
int advance = int advance =
renderer.getKerning(fontId, lastCodepoint(reorderedWordsScratch[wordIdx]), renderer.getKerning(fontId, lastCodepoint(reorderedWordsScratch[wordIdx]),
firstCodepoint(reorderedWordsScratch[wordIdx + 1]), reorderedStylesScratch[wordIdx]); firstCodepoint(reorderedWordsScratch[wordIdx + 1]), reorderedStylesScratch[wordIdx]);
if (reorderedWordsScratch[wordIdx] == " " && reorderedContinuesScratch[wordIdx] && // wordIdx > 0 mirrors the gap accounting above (which skips index 0): a leading
// no-break space must not receive justifyExtra, or the line over-stretches by one
// gap and the last word is pushed past the right margin (issue #2185).
if (wordIdx > 0 && reorderedWordsScratch[wordIdx] == " " && reorderedContinuesScratch[wordIdx] &&
effectiveAlignment == CssTextAlign::Justify && !isLastLine) { effectiveAlignment == CssTextAlign::Justify && !isLastLine) {
advance += reorderedJustifyExtra; advance += reorderedJustifyExtra;
} }
@@ -1048,7 +1051,8 @@ void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const
// Cross-boundary kerning for continuation words // Cross-boundary kerning for continuation words
int advance = renderer.getKerning(fontId, lastCodepoint(lineWords[wordIdx]), int advance = renderer.getKerning(fontId, lastCodepoint(lineWords[wordIdx]),
firstCodepoint(lineWords[wordIdx + 1]), lineWordStyles[wordIdx]); firstCodepoint(lineWords[wordIdx + 1]), lineWordStyles[wordIdx]);
if (lineWords[wordIdx] == " " && continuesVec[lastBreakAt + wordIdx] && // wordIdx > 0: see the LTR branch — a leading no-break space is not a justifiable gap.
if (wordIdx > 0 && lineWords[wordIdx] == " " && continuesVec[lastBreakAt + wordIdx] &&
effectiveAlignment == CssTextAlign::Justify && !isLastLine) { effectiveAlignment == CssTextAlign::Justify && !isLastLine) {
advance += justifyExtra; advance += justifyExtra;
} }
@@ -1086,7 +1090,10 @@ void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const
int advance = wordWidths[lastBreakAt + wordIdx]; int advance = wordWidths[lastBreakAt + wordIdx];
advance += renderer.getKerning(fontId, lastCodepoint(lineWords[wordIdx]), advance += renderer.getKerning(fontId, lastCodepoint(lineWords[wordIdx]),
firstCodepoint(lineWords[wordIdx + 1]), lineWordStyles[wordIdx]); firstCodepoint(lineWords[wordIdx + 1]), lineWordStyles[wordIdx]);
if (lineWords[wordIdx] == " " && continuesVec[lastBreakAt + wordIdx] && // wordIdx > 0 mirrors the gap accounting above (which skips index 0): a leading
// no-break space must not receive justifyExtra, or the line over-stretches by one
// gap and the last word is pushed past the right margin (issue #2185).
if (wordIdx > 0 && lineWords[wordIdx] == " " && continuesVec[lastBreakAt + wordIdx] &&
effectiveAlignment == CssTextAlign::Justify && !isLastLine) { effectiveAlignment == CssTextAlign::Justify && !isLastLine) {
advance += justifyExtra; advance += justifyExtra;
} }
@@ -317,6 +317,14 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
const bool isTocAnchor = const bool isTocAnchor =
std::find(self->tocAnchors.begin(), self->tocAnchors.end(), idValue) != self->tocAnchors.end(); std::find(self->tocAnchors.begin(), self->tocAnchors.end(), idValue) != self->tocAnchors.end();
if (isTocAnchor || (!isNonNavigableInlineElement(name) && self->anchorData.size() < MAX_ANCHORS_PER_CHAPTER)) { if (isTocAnchor || (!isNonNavigableInlineElement(name) && self->anchorData.size() < MAX_ANCHORS_PER_CHAPTER)) {
// Flush a displaced anchor before overwriting. Consecutive non-block elements
// (e.g. <aside id="fn1">text</aside><aside id="fn2">) with no intervening block
// never trigger startNewTextBlock, so fn1 gets silently overwritten. That leaves
// fn1 missing from the anchor map -> getPageForAnchor returns nullopt -> reader
// lands at page 0 (section start) instead of the footnote.
if (!self->pendingAnchorId.empty()) {
self->flushPendingAnchor();
}
self->pendingAnchorId = idValue; self->pendingAnchorId = idValue;
} }
} else if (strcmp(atts[i], "dir") == 0) { } else if (strcmp(atts[i], "dir") == 0) {
@@ -150,6 +150,7 @@ void XMLCALL ContentOpfParser::startElement(void* userData, const XML_Char* name
if (self->state == IN_PACKAGE && (strcmp(name, "guide") == 0 || strcmp(name, "opf:guide") == 0)) { if (self->state == IN_PACKAGE && (strcmp(name, "guide") == 0 || strcmp(name, "opf:guide") == 0)) {
self->state = IN_GUIDE; self->state = IN_GUIDE;
// TODO Remove print
LOG_DBG("COF", "Entering guide state."); LOG_DBG("COF", "Entering guide state.");
if (!Storage.openFileForRead("COF", self->cachePath + itemCacheFile, self->tempItemStore)) { if (!Storage.openFileForRead("COF", self->cachePath + itemCacheFile, self->tempItemStore)) {
LOG_ERR("COF", "Couldn't open temp items file for reading. This is probably going to be a fatal error."); LOG_ERR("COF", "Couldn't open temp items file for reading. This is probably going to be a fatal error.");
+22 -14
View File
@@ -3,6 +3,7 @@
#include <algorithm> #include <algorithm>
#include <cctype> #include <cctype>
#include <cstring> #include <cstring>
#include <string_view>
#include <vector> #include <vector>
namespace FsHelpers { namespace FsHelpers {
@@ -36,12 +37,14 @@ std::string decodeUriEscapes(const std::string& path) {
} }
std::string normalisePath(const std::string& path) { std::string normalisePath(const std::string& path) {
std::vector<std::string> components; std::vector<std::string_view> components;
std::string component; components.reserve(8); // Eight nested folders is more than we might expect
for (const auto c : path) { size_t start = 0;
if (c == '/') { for (size_t i = 0; i <= path.length(); ++i) {
if (!component.empty()) { if (i == path.length() || path[i] == '/') {
if (i > start) {
std::string_view component(path.data() + start, i - start);
if (component == "..") { if (component == "..") {
if (!components.empty()) { if (!components.empty()) {
components.pop_back(); components.pop_back();
@@ -49,23 +52,28 @@ std::string normalisePath(const std::string& path) {
} else { } else {
components.push_back(component); components.push_back(component);
} }
component.clear();
} }
} else { start = i + 1;
component += c;
} }
} }
if (!component.empty()) { if (components.empty()) {
components.push_back(component); return "";
}
size_t total_len = 0;
for (const auto& c : components) {
total_len += c.length() + 1;
} }
std::string result; std::string result;
for (const auto& c : components) { result.reserve(total_len - 1);
if (!result.empty()) {
result += "/"; for (size_t i = 0; i < components.size(); ++i) {
if (i > 0) {
result += '/';
} }
result += c; result.append(components[i].data(), components[i].length());
} }
return result; return result;
+230 -109
View File
@@ -3,12 +3,12 @@
#include <BidiUtils.h> #include <BidiUtils.h>
#include <FontDecompressor.h> #include <FontDecompressor.h>
#include <HalGPIO.h> #include <HalGPIO.h>
#include <Icon.h>
#include <Logging.h> #include <Logging.h>
#include <SdCardFont.h> #include <SdCardFont.h>
#include <Utf8.h> #include <Utf8.h>
#include <algorithm> #include <algorithm>
#include <cassert>
#include "FontCacheManager.h" #include "FontCacheManager.h"
@@ -101,23 +101,6 @@ void GfxRenderer::insertFont(const int fontId, EpdFontFamily font) {
} }
} }
void GfxRenderer::setUiFontRemap(const int* from, const int* to, int count) {
if (count < 0) count = 0;
if (count > MAX_UI_FONT_REMAP) count = MAX_UI_FONT_REMAP;
for (int i = 0; i < count; ++i) {
uiFontFrom_[i] = from[i];
uiFontTo_[i] = to[i];
}
uiFontRemapCount_ = count;
}
int GfxRenderer::remapUiFont(const int fontId) const {
for (int i = 0; i < uiFontRemapCount_; ++i) {
if (uiFontFrom_[i] == fontId) return uiFontTo_[i];
}
return fontId;
}
// Translate logical (x,y) coordinates to physical panel coordinates based on current orientation // Translate logical (x,y) coordinates to physical panel coordinates based on current orientation
// This should always be inlined for better performance // This should always be inlined for better performance
static inline void rotateCoordinates(const GfxRenderer::Orientation orientation, const int x, const int y, int* phyX, static inline void rotateCoordinates(const GfxRenderer::Orientation orientation, const int x, const int y, int* phyX,
@@ -383,7 +366,7 @@ int GfxRenderer::getTextWidth(const int fontId, const char* text, const EpdFontF
return 0; return 0;
} }
const auto fontIt = fontMap.find(remapUiFont(fontId)); const auto fontIt = fontMap.find(fontId);
if (fontIt == fontMap.end()) { if (fontIt == fontMap.end()) {
LOG_ERR("GFX", "Font %d not found", fontId); LOG_ERR("GFX", "Font %d not found", fontId);
return 0; return 0;
@@ -425,7 +408,7 @@ void GfxRenderer::drawText(const int fontId, const int x, const int y, const cha
return; return;
} }
const auto fontIt = fontMap.find(remapUiFont(fontId)); const auto fontIt = fontMap.find(fontId);
if (fontIt == fontMap.end()) { if (fontIt == fontMap.end()) {
LOG_ERR("GFX", "Font %d not found", fontId); LOG_ERR("GFX", "Font %d not found", fontId);
return; return;
@@ -679,8 +662,10 @@ void GfxRenderer::drawRoundedRect(const int x, const int y, const int width, con
} }
void GfxRenderer::fillRect(const int x, const int y, const int width, const int height, const bool state) const { void GfxRenderer::fillRect(const int x, const int y, const int width, const int height, const bool state) const {
for (int fillY = y; fillY < y + height; fillY++) { if (state) {
drawLine(x, fillY, x + width - 1, fillY, state); fillRectImpl<Color::Black>(x, y, width, height);
} else {
fillRectImpl<Color::White>(x, y, width, height);
} }
} }
@@ -712,26 +697,194 @@ void GfxRenderer::drawPixelDither<Color::DarkGray>(const int x, const int y) con
} }
void GfxRenderer::fillRectDither(const int x, const int y, const int width, const int height, Color color) const { void GfxRenderer::fillRectDither(const int x, const int y, const int width, const int height, Color color) const {
if (color == Color::Clear) { switch (color) {
} else if (color == Color::Black) { case Color::Clear:
fillRect(x, y, width, height, true); break;
} else if (color == Color::White) { case Color::Black:
fillRect(x, y, width, height, false); fillRectImpl<Color::Black>(x, y, width, height);
} else if (color == Color::LightGray) { break;
for (int fillY = y; fillY < y + height; fillY++) { case Color::White:
for (int fillX = x; fillX < x + width; fillX++) { fillRectImpl<Color::White>(x, y, width, height);
drawPixelDither<Color::LightGray>(fillX, fillY); break;
case Color::LightGray:
fillRectImpl<Color::LightGray>(x, y, width, height);
break;
case Color::DarkGray:
fillRectImpl<Color::DarkGray>(x, y, width, height);
break;
}
}
template <Color C>
void GfxRenderer::fillRectImpl(const int x, const int y, const int width, const int height) const {
if constexpr (C == Color::Clear) return;
if (width <= 0 || height <= 0) return;
if (fontCacheManager_ && fontCacheManager_->isScanning()) return;
// Clip in logical space.
const int screenW = getScreenWidth();
const int screenH = getScreenHeight();
const int lx0 = std::max(0, x);
const int ly0 = std::max(0, y);
const int lx1 = std::min(screenW, x + width);
const int ly1 = std::min(screenH, y + height);
if (lx0 >= lx1 || ly0 >= ly1) return;
// Rotate the two opposing logical corners into physical-framebuffer space.
// The bounding rect in physical space is the rect we need to fill — rotation
// is rigid (no shear/stretch) so the bbox of the two corners IS the rect.
int paX, paY, pbX, pbY;
rotateCoordinates(orientation, lx0, ly0, &paX, &paY, panelWidth, panelHeight);
rotateCoordinates(orientation, lx1 - 1, ly1 - 1, &pbX, &pbY, panelWidth, panelHeight);
const int phyX0 = std::min(paX, pbX);
const int phyX1 = std::max(paX, pbX); // inclusive
int phyY0 = std::min(paY, pbY);
int phyY1 = std::max(paY, pbY);
// Strip mode: clip Y range to the active band and redirect writes.
uint8_t* target = getWriteTarget();
const int originY = getWriteOriginY();
const int writeRows = getWriteRows();
phyY0 = std::max(phyY0, originY);
phyY1 = std::min(phyY1, originY + writeRows - 1);
if (phyY0 > phyY1) return;
// Bit/byte layout: MSB-first within a byte, so phyX → bit (7 - (phyX & 7)).
// Head and tail masks cover only the in-rect bits of the first/last byte.
const int byteStart = phyX0 >> 3;
const int byteEnd = phyX1 >> 3; // inclusive
const uint8_t headMask = static_cast<uint8_t>(0xFFu >> (phyX0 & 7));
const uint8_t tailMask = static_cast<uint8_t>(0xFFu << (7 - (phyX1 & 7)));
const int32_t panelStride = static_cast<int32_t>(panelWidthBytes);
if constexpr (C == Color::Black || C == Color::White) {
// Solid fill. Framebuffer: 0 = black, 1 = white.
const uint8_t fillByte = (C == Color::Black) ? 0x00u : 0xFFu;
for (int py = phyY0; py <= phyY1; ++py) {
uint8_t* row = target + static_cast<int32_t>(py - originY) * panelStride;
if (byteStart == byteEnd) {
const uint8_t mask = headMask & tailMask;
if constexpr (C == Color::Black) {
row[byteStart] &= static_cast<uint8_t>(~mask);
} else {
row[byteStart] |= mask;
}
} else {
if constexpr (C == Color::Black) {
row[byteStart] &= static_cast<uint8_t>(~headMask);
if (byteEnd > byteStart + 1) {
memset(row + byteStart + 1, fillByte, byteEnd - byteStart - 1);
}
row[byteEnd] &= static_cast<uint8_t>(~tailMask);
} else {
row[byteStart] |= headMask;
if (byteEnd > byteStart + 1) {
memset(row + byteStart + 1, fillByte, byteEnd - byteStart - 1);
}
row[byteEnd] |= tailMask;
}
} }
} }
} else if (color == Color::DarkGray) { } else {
for (int fillY = y; fillY < y + height; fillY++) { // Dither (LightGray / DarkGray). Both patterns have period 2 in logical
for (int fillX = x; fillX < x + width; fillX++) { // (x, y), so per physical row we precompute one byte that represents the
drawPixelDither<Color::DarkGray>(fillX, fillY); // pattern across an 8-pixel stretch — every full byte in the row uses
// that same value.
//
// dlxPerPhyX / dlyPerPhyX: how logical (x, y) change as phyX increments
// along a physical row. Derived from inverting rotateCoordinates.
int dlxPerPhyX = 0, dlyPerPhyX = 0;
switch (orientation) {
case Portrait:
dlxPerPhyX = 0;
dlyPerPhyX = 1;
break;
case PortraitInverted:
dlxPerPhyX = 0;
dlyPerPhyX = -1;
break;
case LandscapeClockwise:
dlxPerPhyX = -1;
dlyPerPhyX = 0;
break;
case LandscapeCounterClockwise:
dlxPerPhyX = 1;
dlyPerPhyX = 0;
break;
}
// The dither pattern has period 2 in logical space, and each orientation
// maps py to logical coords with a fixed parity relationship. The
// blackMask byte therefore repeats with period 2 in py. Precompute both
// variants outside the row loop to eliminate the per-row switch + 8-bit
// construction loop.
uint8_t blackMasks[2];
for (int parityIdx = 0; parityIdx < 2; ++parityIdx) {
const int samplePy = phyY0 + parityIdx;
int lxBase = 0, lyBase = 0;
switch (orientation) {
case Portrait:
lxBase = panelHeight - 1 - samplePy;
lyBase = byteStart * 8;
break;
case PortraitInverted:
lxBase = samplePy;
lyBase = panelWidth - 1 - byteStart * 8;
break;
case LandscapeClockwise:
lxBase = panelWidth - 1 - byteStart * 8;
lyBase = panelHeight - 1 - samplePy;
break;
case LandscapeCounterClockwise:
lxBase = byteStart * 8;
lyBase = samplePy;
break;
}
uint8_t mask = 0;
for (int b = 0; b < 8; ++b) {
const int lx = lxBase + b * dlxPerPhyX;
const int ly = lyBase + b * dlyPerPhyX;
bool isBlack;
if constexpr (C == Color::LightGray) {
isBlack = ((lx & 1) == 0) && ((ly & 1) == 0);
} else { // DarkGray
isBlack = (((lx + ly) & 1) == 0);
}
if (isBlack) mask |= static_cast<uint8_t>(1u << (7 - b));
}
blackMasks[samplePy & 1] = mask;
}
for (int py = phyY0; py <= phyY1; ++py) {
const uint8_t blackMask = blackMasks[py & 1];
const uint8_t whiteMask = static_cast<uint8_t>(~blackMask);
// Dither writes BOTH inks (the slow path called drawPixel for every
// pixel — setting or clearing — so we must do the same). Inside the
// rect mask: write whiteMask (1s where white, 0s where black). Outside
// the rect mask: leave the framebuffer untouched.
uint8_t* row = target + static_cast<int32_t>(py - originY) * panelStride;
if (byteStart == byteEnd) {
const uint8_t rectMask = headMask & tailMask;
row[byteStart] = static_cast<uint8_t>((row[byteStart] & ~rectMask) | (rectMask & whiteMask));
} else {
row[byteStart] = static_cast<uint8_t>((row[byteStart] & ~headMask) | (headMask & whiteMask));
if (byteEnd > byteStart + 1) {
// Period 2, so every full byte in this row is exactly whiteMask.
memset(row + byteStart + 1, whiteMask, byteEnd - byteStart - 1);
}
row[byteEnd] = static_cast<uint8_t>((row[byteEnd] & ~tailMask) | (tailMask & whiteMask));
} }
} }
} }
} }
template void GfxRenderer::fillRectImpl<Color::Black>(int, int, int, int) const;
template void GfxRenderer::fillRectImpl<Color::White>(int, int, int, int) const;
template void GfxRenderer::fillRectImpl<Color::LightGray>(int, int, int, int) const;
template void GfxRenderer::fillRectImpl<Color::DarkGray>(int, int, int, int) const;
void GfxRenderer::maskRoundedRectOutsideCorners(const int x, const int y, const int width, const int height, void GfxRenderer::maskRoundedRectOutsideCorners(const int x, const int y, const int width, const int height,
const int radius, const Color color) const { const int radius, const Color color) const {
if (radius <= 0 || color == Color::Clear) { if (radius <= 0 || color == Color::Clear) {
@@ -903,20 +1056,17 @@ void GfxRenderer::drawImage(const uint8_t bitmap[], const int x, const int y, co
} }
void GfxRenderer::drawIcon(const uint8_t bitmap[], const int x, const int y, const int width, const int height) const { void GfxRenderer::drawIcon(const uint8_t bitmap[], const int x, const int y, const int width, const int height) const {
display.drawImageTransparent(bitmap, y, getScreenWidth() - width - x, height, width); if (bitmap == nullptr || width <= 0 || height <= 0) return;
} assert(width == height);
void GfxRenderer::drawIcon(const freeink::Icon& icon, const int x, const int y, const bool black) const { const int bytesPerRow = (width + 7) / 8;
// Bits are un-rotated, so each drawn pixel goes through drawPixel (which applies for (int sourceY = 0; sourceY < height; ++sourceY) {
// the orientation transform) — correct in every orientation, unlike the legacy for (int sourceX = 0; sourceX < width; ++sourceX) {
// uint8_t* overload that pre-rotates for one orientation. const uint8_t rowByte = bitmap[sourceY * bytesPerRow + sourceX / 8];
const int rowBytes = (icon.w + 7) / 8; const bool background = (rowByte >> (7 - (sourceX % 8))) & 0x01;
for (int row = 0; row < icon.h; ++row) { if (background) continue;
const uint8_t* r = icon.bits + static_cast<int>(row) * rowBytes;
for (int col = 0; col < icon.w; ++col) { drawPixel(x + height - 1 - sourceY, y + sourceX, true);
if (((r[col >> 3] >> (7 - (col & 7))) & 1) == 0) { // 0 = drawn
drawPixel(x + col, y + row, black);
}
} }
} }
} }
@@ -1329,38 +1479,6 @@ int GfxRenderer::getScreenHeight() const {
return panelWidth; return panelWidth;
} }
void GfxRenderer::tapToLogical(float nx, float ny, int& outX, int& outY) const {
// Native panel pixel of the tap (wasTouchTap normalizes over the native panel).
int phyX = static_cast<int>(nx * panelWidth);
int phyY = static_cast<int>(ny * panelHeight);
if (phyX < 0) phyX = 0;
if (phyX > panelWidth - 1) phyX = panelWidth - 1;
if (phyY < 0) phyY = 0;
if (phyY > panelHeight - 1) phyY = panelHeight - 1;
// Inverse of rotateCoordinates() (see the forward transform above): map a
// physical/native point back into the current orientation's logical frame.
switch (orientation) {
case Portrait: // forward: phyX=logY, phyY=panelHeight-1-logX
outX = panelHeight - 1 - phyY;
outY = phyX;
break;
case PortraitInverted: // forward: phyX=panelWidth-1-logY, phyY=logX
outX = phyY;
outY = panelWidth - 1 - phyX;
break;
case LandscapeClockwise: // forward: phyX=panelWidth-1-logX, phyY=panelHeight-1-logY
outX = panelWidth - 1 - phyX;
outY = panelHeight - 1 - phyY;
break;
case LandscapeCounterClockwise: // forward: identity
default:
outX = phyX;
outY = phyY;
break;
}
}
// Translate a logical rect through rotateCoordinates and take the bounding // Translate a logical rect through rotateCoordinates and take the bounding
// box of its four corners on the physical panel. Output coords are inclusive // box of its four corners on the physical panel. Output coords are inclusive
// and clamped. Returns false if the rect ends up fully off-panel. // and clamped. Returns false if the rect ends up fully off-panel.
@@ -1452,7 +1570,7 @@ int GfxRenderer::getSpaceWidth(const int fontId, const EpdFontFamily::Style styl
return fp4::toPixel(sdIt->second->getAdvance(' ', resolvedStyle)); return fp4::toPixel(sdIt->second->getAdvance(' ', resolvedStyle));
} }
const auto fontIt = fontMap.find(remapUiFont(fontId)); const auto fontIt = fontMap.find(fontId);
if (fontIt == fontMap.end()) { if (fontIt == fontMap.end()) {
LOG_ERR("GFX", "Font %d not found", fontId); LOG_ERR("GFX", "Font %d not found", fontId);
return 0; return 0;
@@ -1473,7 +1591,7 @@ int GfxRenderer::getSpaceAdvance(const int fontId, const uint32_t leftCp, const
return fp4::toPixel(sdIt->second->getAdvance(' ', resolvedStyle)); return fp4::toPixel(sdIt->second->getAdvance(' ', resolvedStyle));
} }
const auto fontIt = fontMap.find(remapUiFont(fontId)); const auto fontIt = fontMap.find(fontId);
if (fontIt == fontMap.end()) return 0; if (fontIt == fontMap.end()) return 0;
const auto& font = fontIt->second; const auto& font = fontIt->second;
const EpdGlyph* spaceGlyph = font.getGlyph(' ', style); const EpdGlyph* spaceGlyph = font.getGlyph(' ', style);
@@ -1487,7 +1605,7 @@ int GfxRenderer::getSpaceAdvance(const int fontId, const uint32_t leftCp, const
int GfxRenderer::getKerning(const int fontId, const uint32_t leftCp, const uint32_t rightCp, int GfxRenderer::getKerning(const int fontId, const uint32_t leftCp, const uint32_t rightCp,
const EpdFontFamily::Style style) const { const EpdFontFamily::Style style) const {
const auto fontIt = fontMap.find(remapUiFont(fontId)); const auto fontIt = fontMap.find(fontId);
if (fontIt == fontMap.end()) return 0; if (fontIt == fontMap.end()) return 0;
const int kernFP = fontIt->second.getKerning(leftCp, rightCp, style); // 4.4 fixed-point const int kernFP = fontIt->second.getKerning(leftCp, rightCp, style); // 4.4 fixed-point
return fp4::toPixel(kernFP); // snap 4.4 fixed-point to nearest pixel return fp4::toPixel(kernFP); // snap 4.4 fixed-point to nearest pixel
@@ -1519,7 +1637,7 @@ int GfxRenderer::getTextAdvanceX(const int fontId, const char* text, EpdFontFami
return fp4::toPixel(widthFP); return fp4::toPixel(widthFP);
} }
const auto fontIt = fontMap.find(remapUiFont(fontId)); const auto fontIt = fontMap.find(fontId);
if (fontIt == fontMap.end()) { if (fontIt == fontMap.end()) {
LOG_ERR("GFX", "Font %d not found", fontId); LOG_ERR("GFX", "Font %d not found", fontId);
return 0; return 0;
@@ -1555,7 +1673,7 @@ int GfxRenderer::getTextAdvanceX(const int fontId, const char* text, EpdFontFami
} }
int GfxRenderer::getFontAscenderSize(const int fontId) const { int GfxRenderer::getFontAscenderSize(const int fontId) const {
const auto fontIt = fontMap.find(remapUiFont(fontId)); const auto fontIt = fontMap.find(fontId);
if (fontIt == fontMap.end()) { if (fontIt == fontMap.end()) {
LOG_ERR("GFX", "Font %d not found", fontId); LOG_ERR("GFX", "Font %d not found", fontId);
return 0; return 0;
@@ -1565,7 +1683,7 @@ int GfxRenderer::getFontAscenderSize(const int fontId) const {
} }
int GfxRenderer::getLineHeight(const int fontId) const { int GfxRenderer::getLineHeight(const int fontId) const {
const auto fontIt = fontMap.find(remapUiFont(fontId)); const auto fontIt = fontMap.find(fontId);
if (fontIt == fontMap.end()) { if (fontIt == fontMap.end()) {
LOG_ERR("GFX", "Font %d not found", fontId); LOG_ERR("GFX", "Font %d not found", fontId);
return 0; return 0;
@@ -1575,7 +1693,7 @@ int GfxRenderer::getLineHeight(const int fontId) const {
} }
int GfxRenderer::getTextHeight(const int fontId) const { int GfxRenderer::getTextHeight(const int fontId) const {
const auto fontIt = fontMap.find(remapUiFont(fontId)); const auto fontIt = fontMap.find(fontId);
if (fontIt == fontMap.end()) { if (fontIt == fontMap.end()) {
LOG_ERR("GFX", "Font %d not found", fontId); LOG_ERR("GFX", "Font %d not found", fontId);
return 0; return 0;
@@ -1583,27 +1701,6 @@ int GfxRenderer::getTextHeight(const int fontId) const {
return fontIt->second.getData(EpdFontFamily::REGULAR)->ascender; return fontIt->second.getData(EpdFontFamily::REGULAR)->ascender;
} }
// Height of a reference glyph above the baseline (glyph->top): 'H' gives the real
// cap height, the actual visible font extent for vertical centering.
int GfxRenderer::glyphTop(const int fontId, const uint32_t cp) const {
const auto fontIt = fontMap.find(remapUiFont(fontId));
if (fontIt == fontMap.end()) return 0;
const EpdGlyph* g = fontIt->second.getGlyph(cp, EpdFontFamily::REGULAR);
return g ? g->top : 0;
}
int GfxRenderer::getFontCapHeight(const int fontId) const { return glyphTop(fontId, 'H'); }
int GfxRenderer::getTextVisualCenterOffset(const int fontId) const {
// Cap-height middle: baseline is at top + ascender, caps reach capHeight above it,
// so the optical center is ascender - capHeight/2 below the top. Cap (not x) height
// because UI labels are capital-led. Falls back to ascender*0.65 without an 'H'.
const int ascender = getFontAscenderSize(fontId);
const int capHeight = getFontCapHeight(fontId);
if (capHeight <= 0) return (ascender * 65) / 100;
return ascender - capHeight / 2;
}
void GfxRenderer::drawTextRotated90CW(const int fontId, const int x, const int y, const char* text, const bool black, void GfxRenderer::drawTextRotated90CW(const int fontId, const int x, const int y, const char* text, const bool black,
const EpdFontFamily::Style style) const { const EpdFontFamily::Style style) const {
// Cannot draw a NULL / empty string // Cannot draw a NULL / empty string
@@ -1611,7 +1708,7 @@ void GfxRenderer::drawTextRotated90CW(const int fontId, const int x, const int y
return; return;
} }
const auto fontIt = fontMap.find(remapUiFont(fontId)); const auto fontIt = fontMap.find(fontId);
if (fontIt == fontMap.end()) { if (fontIt == fontMap.end()) {
LOG_ERR("GFX", "Font %d not found", fontId); LOG_ERR("GFX", "Font %d not found", fontId);
return; return;
@@ -1673,6 +1770,30 @@ size_t GfxRenderer::getBufferSize() const { return frameBufferSize; }
// unused // unused
// void GfxRenderer::grayscaleRevert() const { display.grayscaleRevert(); } // void GfxRenderer::grayscaleRevert() const { display.grayscaleRevert(); }
void GfxRenderer::displayGrayscaleBase(HalDisplay::RefreshMode fallback) const {
display.displayGrayscaleBase(fallback, fadingFix);
}
void GfxRenderer::preconditionGrayscale() const { display.preconditionGrayscale(); }
void GfxRenderer::preconditionGrayscale(int x, int y, int w, int h) const {
if (w <= 0 || h <= 0) return;
// Rotate the logical rect's opposite corners to physical panel coords; the
// physical bbox stays axis-aligned for all four orientations.
int ax, ay, bx, by;
rotateCoordinates(orientation, x, y, &ax, &ay, panelWidth, panelHeight);
rotateCoordinates(orientation, x + w - 1, y + h - 1, &bx, &by, panelWidth, panelHeight);
int x0 = ax < bx ? ax : bx, x1 = ax > bx ? ax : bx;
int y0 = ay < by ? ay : by, y1 = ay > by ? ay : by;
if (x0 < 0) x0 = 0;
if (y0 < 0) y0 = 0;
if (x1 >= panelWidth) x1 = panelWidth - 1;
if (y1 >= panelHeight) y1 = panelHeight - 1;
if (x1 < x0 || y1 < y0) return;
display.preconditionGrayscale(static_cast<uint16_t>(x0), static_cast<uint16_t>(y0),
static_cast<uint16_t>(x1 - x0 + 1), static_cast<uint16_t>(y1 - y0 + 1));
}
void GfxRenderer::copyGrayscaleLsbBuffers() const { display.copyGrayscaleLsbBuffers(frameBuffer); } void GfxRenderer::copyGrayscaleLsbBuffers() const { display.copyGrayscaleLsbBuffers(frameBuffer); }
void GfxRenderer::copyGrayscaleMsbBuffers() const { display.copyGrayscaleMsbBuffers(frameBuffer); } void GfxRenderer::copyGrayscaleMsbBuffers() const { display.copyGrayscaleMsbBuffers(frameBuffer); }
+16 -29
View File
@@ -13,9 +13,6 @@ enum class BidiBaseDir : signed char { AUTO = -1, LTR = 0, RTL = 1 };
class FontCacheManager; class FontCacheManager;
class SdCardFont; class SdCardFont;
namespace freeink {
struct Icon;
}
#include <cstring> #include <cstring>
#include <map> #include <map>
@@ -54,13 +51,6 @@ class GfxRenderer {
uint32_t frameBufferSize = HalDisplay::BUFFER_SIZE; uint32_t frameBufferSize = HalDisplay::BUFFER_SIZE;
std::vector<uint8_t*> bwBufferChunks; std::vector<uint8_t*> bwBufferChunks;
std::map<int, EpdFontFamily> fontMap; std::map<int, EpdFontFamily> fontMap;
// UI chrome font remap table (see setUiFontRemap). Empty = identity.
static constexpr int MAX_UI_FONT_REMAP = 8;
int uiFontFrom_[MAX_UI_FONT_REMAP] = {0};
int uiFontTo_[MAX_UI_FONT_REMAP] = {0};
int uiFontRemapCount_ = 0;
int remapUiFont(int fontId) const;
int glyphTop(int fontId, uint32_t cp) const;
// Mutable because ensureSdCardFontReady() is const (called from layout code // Mutable because ensureSdCardFontReady() is const (called from layout code
// that holds a const GfxRenderer&) but triggers SD card reads and heap // that holds a const GfxRenderer&) but triggers SD card reads and heap
// allocation inside the SdCardFont objects. Same pragmatic compromise as // allocation inside the SdCardFont objects. Same pragmatic compromise as
@@ -91,6 +81,12 @@ class GfxRenderer {
void drawPixelDither(int x, int y) const; void drawPixelDither(int x, int y) const;
template <Color color> template <Color color>
void fillArc(int maxRadius, int cx, int cy, int xDir, int yDir) const; void fillArc(int maxRadius, int cx, int cy, int xDir, int yDir) const;
// Byte-aligned, orientation-specialized rectangle fill. Rotates the rect's
// two opposing corners into physical-framebuffer space once, then walks each
// physical row with head-mask / middle memset / tail-mask byte writes — no
// per-pixel rotation, no per-pixel RMW.
template <Color color>
void fillRectImpl(int x, int y, int width, int height) const;
public: public:
explicit GfxRenderer(HalDisplay& halDisplay) explicit GfxRenderer(HalDisplay& halDisplay)
@@ -105,14 +101,6 @@ class GfxRenderer {
// Setup // Setup
void begin(); // must be called right after display.begin() void begin(); // must be called right after display.begin()
void insertFont(int fontId, EpdFontFamily font); void insertFont(int fontId, EpdFontFamily font);
// Orientation-correct icon blit for the freeink::Icon format (un-rotated bits +
// optical-center metadata). Prefer this over the legacy raw-bitmap drawIcon.
void drawIcon(const freeink::Icon& icon, int x, int y, bool black = true) const;
// UI chrome font scaling: firmware supplies a small remap table (from the board
// uiScale) that substitutes a larger font for each scaled UI font id at lookup
// time, so layout and drawing stay consistent with no call-site changes. Reader
// body fonts aren't in the table, so book text is unaffected. count <= 8.
void setUiFontRemap(const int* from, const int* to, int count);
// Clears both the flash-font map and any SD-font registration for fontId. // Clears both the flash-font map and any SD-font registration for fontId.
// Coupled to avoid dangling SdCardFont* in sdCardFonts_ when callers free // Coupled to avoid dangling SdCardFont* in sdCardFonts_ when callers free
// the underlying SdCardFont and forget the SD-side unregister. // the underlying SdCardFont and forget the SD-side unregister.
@@ -153,11 +141,6 @@ class GfxRenderer {
void clearScreen(uint8_t color = 0xFF) const; void clearScreen(uint8_t color = 0xFF) const;
void getOrientedViewableTRBL(int* outTop, int* outRight, int* outBottom, int* outLeft) const; void getOrientedViewableTRBL(int* outTop, int* outRight, int* outBottom, int* outLeft) const;
// Map a touch tap (normalized 0..1 in panel-native orientation, from
// InputManager::wasTouchTap) to logical screen coordinates matching the Rects the
// UI draws in. Inverse of rotateCoordinates() for the current orientation.
void tapToLogical(float nx, float ny, int& outX, int& outY) const;
// Tiled grayscale strip target. While active, drawPixel() and clearScreen() // Tiled grayscale strip target. While active, drawPixel() and clearScreen()
// operate on `scratch` (panelWidthBytes * stripRows bytes, holding physical // operate on `scratch` (panelWidthBytes * stripRows bytes, holding physical
// rows [stripY0, stripY0 + stripRows)) instead of the framebuffer; pixels // rows [stripY0, stripY0 + stripRows)) instead of the framebuffer; pixels
@@ -225,12 +208,6 @@ class GfxRenderer {
int getTextAdvanceX(int fontId, const char* text, EpdFontFamily::Style style) const; int getTextAdvanceX(int fontId, const char* text, EpdFontFamily::Style style) const;
int getFontAscenderSize(int fontId) const; int getFontAscenderSize(int fontId) const;
int getLineHeight(int fontId) const; int getLineHeight(int fontId) const;
// Cap height (from the 'H' glyph), the real visible font extent for vertical
// alignment that follows the font instead of a guessed ascender fraction.
int getFontCapHeight(int fontId) const;
// Offset from text top (drawText's y) to the text's optical center; align an
// element to a line via centerY = textTop + getTextVisualCenterOffset(fontId).
int getTextVisualCenterOffset(int fontId) const;
std::string truncatedText(int fontId, const char* text, int maxWidth, std::string truncatedText(int fontId, const char* text, int maxWidth,
EpdFontFamily::Style style = EpdFontFamily::REGULAR) const; EpdFontFamily::Style style = EpdFontFamily::REGULAR) const;
/// Word-wrap \p text into at most \p maxLines lines, each no wider than /// Word-wrap \p text into at most \p maxLines lines, each no wider than
@@ -247,6 +224,16 @@ class GfxRenderer {
// Grayscale functions // Grayscale functions
void setRenderMode(const RenderMode mode) { this->renderMode = mode; } void setRenderMode(const RenderMode mode) { this->renderMode = mode; }
RenderMode getRenderMode() const { return renderMode; } RenderMode getRenderMode() const { return renderMode; }
// Grayscale preconditioning settle pass (no-op on X4). The rect overload
// takes the gray region in LOGICAL screen coordinates and rotates it to the
// panel; the no-arg overload settles the full frame. Call after the BW base
// frame is displayed and before the grayscale planes are written.
void preconditionGrayscale() const;
void preconditionGrayscale(int x, int y, int w, int h) const;
// Display the framebuffer as the base frame for a grayscale overlay that
// follows (X3: OEM differential base waveform; others: plain display with
// `fallback`).
void displayGrayscaleBase(HalDisplay::RefreshMode fallback = HalDisplay::HALF_REFRESH) const;
void copyGrayscaleLsbBuffers() const; void copyGrayscaleLsbBuffers() const;
void copyGrayscaleMsbBuffers() const; void copyGrayscaleMsbBuffers() const;
void displayGrayBuffer() const; void displayGrayBuffer() const;
+5 -1
View File
@@ -68,7 +68,6 @@ STR_TEXT_AA: "Згладжванне тэксту"
STR_SHORT_PWR_BTN: "Кароткае націсканне PWR" STR_SHORT_PWR_BTN: "Кароткае націсканне PWR"
STR_ORIENTATION: "Арыентацыя чытання" STR_ORIENTATION: "Арыентацыя чытання"
STR_SIDE_BTN_LAYOUT: "Бакавыя кнопкі" STR_SIDE_BTN_LAYOUT: "Бакавыя кнопкі"
STR_TOUCH_READER_CONTROLS: "Сэнсарнае кіраванне чытаннем"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Арыентаваць пярэднія кнопкі" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Арыентаваць пярэднія кнопкі"
STR_LONG_PRESS_SKIP: "Доўгае націсканне - змена раздзела" STR_LONG_PRESS_SKIP: "Доўгае націсканне - змена раздзела"
STR_FONT_PREVIEW_TEXT: "У Іўі худы жвавы чорт у зялёнай камізэльцы пабег пад'есці фаршу з юшкай" STR_FONT_PREVIEW_TEXT: "У Іўі худы жвавы чорт у зялёнай камізэльцы пабег пад'есці фаршу з юшкай"
@@ -127,6 +126,7 @@ STR_PAGE_TURN: "Перагортванне"
STR_PORTRAIT: "Партрэт" STR_PORTRAIT: "Партрэт"
STR_LANDSCAPE_CW: "Ландшафт (CW)" STR_LANDSCAPE_CW: "Ландшафт (CW)"
STR_INVERTED: "Інверсія" STR_INVERTED: "Інверсія"
STR_ORIENTATION_INVERTED: "Партрэт 180°"
STR_LANDSCAPE_CCW: "Ландшафт (CCW)" STR_LANDSCAPE_CCW: "Ландшафт (CCW)"
STR_PREV_NEXT: "Назад/Наперад" STR_PREV_NEXT: "Назад/Наперад"
STR_NEXT_PREV: "Наперад/Назад" STR_NEXT_PREV: "Наперад/Назад"
@@ -177,6 +177,9 @@ STR_EXIT: "« Выхад"
STR_HOME: "« Галоўная" STR_HOME: "« Галоўная"
STR_SELECT: "Абраць" STR_SELECT: "Абраць"
STR_TOGGLE: "Выбар" STR_TOGGLE: "Выбар"
STR_TOGGLE_BOOKMARK: "Пераключыць закладку"
STR_BOOKMARK_REMOVED: "Закладка выдалена."
STR_HOLD_OPEN_TO_DELETE: "Утрымлівайце Адкрыць, каб выдаліць"
STR_CONFIRM: "Пацв." STR_CONFIRM: "Пацв."
STR_CANCEL: "Адмена" STR_CANCEL: "Адмена"
STR_CONNECT: "Падкл." STR_CONNECT: "Падкл."
@@ -297,3 +300,4 @@ STR_SLEEP_TIMER_STEP_HINT: "Улева/Управа: 1 хв Уверх/Уніз
STR_AUTO_TURN_ENABLED: "Аўтаперагортванне: " STR_AUTO_TURN_ENABLED: "Аўтаперагортванне: "
STR_AUTO_TURN_PAGES_PER_MIN: "Аўтаперагортванне (старонак за хвіліну)" STR_AUTO_TURN_PAGES_PER_MIN: "Аўтаперагортванне (старонак за хвіліну)"
STR_TILT_PAGE_TURN: "Перагортванне нахілам" STR_TILT_PAGE_TURN: "Перагортванне нахілам"
STR_MANAGE_THEMES: "Кіраванне тэмамі"
+5 -3
View File
@@ -72,7 +72,6 @@ STR_IMAGES_SUPPRESS: "Suprimir"
STR_SHORT_PWR_BTN: "Clic curt del botó d'engegada" STR_SHORT_PWR_BTN: "Clic curt del botó d'engegada"
STR_ORIENTATION: "Orientació de lectura" STR_ORIENTATION: "Orientació de lectura"
STR_SIDE_BTN_LAYOUT: "Disposició botons laterals" STR_SIDE_BTN_LAYOUT: "Disposició botons laterals"
STR_TOUCH_READER_CONTROLS: "Controls tàctils del lector"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botons frontals" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botons frontals"
STR_LONG_PRESS_BEHAVIOR: "Comportament de prémer llargament el botó" STR_LONG_PRESS_BEHAVIOR: "Comportament de prémer llargament el botó"
STR_LONG_PRESS_BEHAVIOR_OFF: "Desactivat" STR_LONG_PRESS_BEHAVIOR_OFF: "Desactivat"
@@ -137,6 +136,7 @@ STR_PAGE_TURN: "Canvi de pàgina"
STR_PORTRAIT: "Vertical" STR_PORTRAIT: "Vertical"
STR_LANDSCAPE_CW: "Horitzontal horari" STR_LANDSCAPE_CW: "Horitzontal horari"
STR_INVERTED: "Invertit" STR_INVERTED: "Invertit"
STR_ORIENTATION_INVERTED: "Vertical 180°"
STR_LANDSCAPE_CCW: "Horitzontal antihorari" STR_LANDSCAPE_CCW: "Horitzontal antihorari"
STR_PREV_NEXT: "Anterior/Següent" STR_PREV_NEXT: "Anterior/Següent"
STR_NEXT_PREV: "Següent/Anterior" STR_NEXT_PREV: "Següent/Anterior"
@@ -176,8 +176,7 @@ STR_DOWNLOADING: "S'està baixant..."
STR_DOWNLOAD_FAILED: "Ha fallat la baixada" STR_DOWNLOAD_FAILED: "Ha fallat la baixada"
STR_ERROR_MSG: "Error:" STR_ERROR_MSG: "Error:"
STR_UNNAMED: "Sense nom" STR_UNNAMED: "Sense nom"
STR_HOLD_CONFIRM_TO_DELETE: "Manteniu premut Confirma per esborrar" STR_HOLD_OPEN_TO_DELETE: "Manteniu premut Obre per esborrar"
STR_BOOKMARK_INSTRUCTIONS: "Manteniu premut Confirma al lector per crear un punt de llibre."
STR_NO_SERVER_URL: "No s'ha configurat cap URL de servidor" STR_NO_SERVER_URL: "No s'ha configurat cap URL de servidor"
STR_FETCH_FEED_FAILED: "Ha fallat l'obtenció del feed" STR_FETCH_FEED_FAILED: "Ha fallat l'obtenció del feed"
STR_PARSE_FEED_FAILED: "Ha fallat l'anàlisi del feed" STR_PARSE_FEED_FAILED: "Ha fallat l'anàlisi del feed"
@@ -193,6 +192,7 @@ STR_HOME: "« Inici"
STR_SELECT: "Selecciona" STR_SELECT: "Selecciona"
STR_SELECTED: "Seleccionat" STR_SELECTED: "Seleccionat"
STR_TOGGLE: "Canvia" STR_TOGGLE: "Canvia"
STR_TOGGLE_BOOKMARK: "Commuta punt de llibre"
STR_CONFIRM: "Confirma" STR_CONFIRM: "Confirma"
STR_CANCEL: "Cancel·la" STR_CANCEL: "Cancel·la"
STR_CONNECT: "Connecta" STR_CONNECT: "Connecta"
@@ -237,6 +237,7 @@ STR_QUICK_RESUME_TIMEOUT: "Represa ràpida després del temps"
STR_REMAP_FRONT_BUTTONS: "Reassigna els botons frontals" STR_REMAP_FRONT_BUTTONS: "Reassigna els botons frontals"
STR_BOOKMARKS: "Punts de llibre" STR_BOOKMARKS: "Punts de llibre"
STR_BOOKMARK_ADDED: "S'ha afegit el punt de llibre." STR_BOOKMARK_ADDED: "S'ha afegit el punt de llibre."
STR_BOOKMARK_REMOVED: "S'ha eliminat el punt de llibre."
STR_OPDS_BROWSER: "Navegador OPDS" STR_OPDS_BROWSER: "Navegador OPDS"
STR_COVER_CUSTOM: "Portada + Personalitzat" STR_COVER_CUSTOM: "Portada + Personalitzat"
STR_QUICK_RESUME: "Represa ràpida" STR_QUICK_RESUME: "Represa ràpida"
@@ -382,3 +383,4 @@ STR_FIRMWARE_WRITE_FAILED: "Ha fallat l'escriptura del firmware"
STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "No apagueu el dispositiu!" STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "No apagueu el dispositiu!"
STR_RECOVERY_MODE: "Mode de recuperació" STR_RECOVERY_MODE: "Mode de recuperació"
STR_RECOVERY_MODE_HINT: "Poseu firmware.bin a l'arrel de la targeta SD i seleccioneu-lo" STR_RECOVERY_MODE_HINT: "Poseu firmware.bin a l'arrel de la targeta SD i seleccioneu-lo"
STR_MANAGE_THEMES: "Gestiona els temes"
+5 -1
View File
@@ -68,7 +68,6 @@ STR_TEXT_AA: "Vyhlazování textu"
STR_SHORT_PWR_BTN: "Krátké stisknutí tlačítka napájení" STR_SHORT_PWR_BTN: "Krátké stisknutí tlačítka napájení"
STR_ORIENTATION: "Orientace čtení" STR_ORIENTATION: "Orientace čtení"
STR_SIDE_BTN_LAYOUT: "Rozvržení bočních tlačítek (čtečka)" STR_SIDE_BTN_LAYOUT: "Rozvržení bočních tlačítek (čtečka)"
STR_TOUCH_READER_CONTROLS: "Dotykové ovládání čtečky"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientovat přední tlačítka" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientovat přední tlačítka"
STR_LONG_PRESS_BEHAVIOR: "Chování při dlouhém stisknutí tlačítka" STR_LONG_PRESS_BEHAVIOR: "Chování při dlouhém stisknutí tlačítka"
STR_LONG_PRESS_BEHAVIOR_OFF: "VYP" STR_LONG_PRESS_BEHAVIOR_OFF: "VYP"
@@ -132,6 +131,7 @@ STR_PAGE_TURN: "Otáčení stránek"
STR_PORTRAIT: "Na výšku" STR_PORTRAIT: "Na výšku"
STR_LANDSCAPE_CW: "Na šířku po směru hod. ručiček" STR_LANDSCAPE_CW: "Na šířku po směru hod. ručiček"
STR_INVERTED: "Invertovaný" STR_INVERTED: "Invertovaný"
STR_ORIENTATION_INVERTED: "Na výšku 180°"
STR_LANDSCAPE_CCW: "Na šířku proti směru hod. ručiček" STR_LANDSCAPE_CCW: "Na šířku proti směru hod. ručiček"
STR_PREV_NEXT: "Předchozí/Další" STR_PREV_NEXT: "Předchozí/Další"
STR_NEXT_PREV: "Další/Předchozí" STR_NEXT_PREV: "Další/Předchozí"
@@ -182,6 +182,9 @@ STR_EXIT: "« Konec"
STR_HOME: "« Domů" STR_HOME: "« Domů"
STR_SELECT: "Vybrat" STR_SELECT: "Vybrat"
STR_TOGGLE: "Přepnout" STR_TOGGLE: "Přepnout"
STR_TOGGLE_BOOKMARK: "Přepnout záložku"
STR_BOOKMARK_REMOVED: "Záložka odstraněna."
STR_HOLD_OPEN_TO_DELETE: "Podržte Otevřít pro smazání"
STR_CONFIRM: "Potvrdit" STR_CONFIRM: "Potvrdit"
STR_CANCEL: "Zrušit" STR_CANCEL: "Zrušit"
STR_CONNECT: "Připojit" STR_CONNECT: "Připojit"
@@ -272,3 +275,4 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
STR_SLEEP_NEVER: "Nikdy" STR_SLEEP_NEVER: "Nikdy"
STR_SLEEP_TIMER_STEP_HINT: "Vlevo/Vpravo: 1 min Nahoru/Dolů: 5 min" STR_SLEEP_TIMER_STEP_HINT: "Vlevo/Vpravo: 1 min Nahoru/Dolů: 5 min"
STR_TILT_PAGE_TURN: "Otáčení stránek nakloněním" STR_TILT_PAGE_TURN: "Otáčení stránek nakloněním"
STR_MANAGE_THEMES: "Spravovat motivy"
+5 -1
View File
@@ -72,7 +72,6 @@ STR_IMAGES_SUPPRESS: "Skjul"
STR_SHORT_PWR_BTN: "Kort tryk på tænd/sluk-knap" STR_SHORT_PWR_BTN: "Kort tryk på tænd/sluk-knap"
STR_ORIENTATION: "Læseretning" STR_ORIENTATION: "Læseretning"
STR_SIDE_BTN_LAYOUT: "Knaplayout på siden (læser)" STR_SIDE_BTN_LAYOUT: "Knaplayout på siden (læser)"
STR_TOUCH_READER_CONTROLS: "Touch-betjening (læser)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientér forreste knapper" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientér forreste knapper"
STR_LONG_PRESS_BEHAVIOR: "Comportamiento al mantener pulsado el botón" STR_LONG_PRESS_BEHAVIOR: "Comportamiento al mantener pulsado el botón"
STR_LONG_PRESS_BEHAVIOR_OFF: "Desactivado" STR_LONG_PRESS_BEHAVIOR_OFF: "Desactivado"
@@ -137,6 +136,7 @@ STR_PAGE_TURN: "Sideskift"
STR_PORTRAIT: "Portræt" STR_PORTRAIT: "Portræt"
STR_LANDSCAPE_CW: "Liggende med uret" STR_LANDSCAPE_CW: "Liggende med uret"
STR_INVERTED: "Inverteret" STR_INVERTED: "Inverteret"
STR_ORIENTATION_INVERTED: "Portræt 180°"
STR_LANDSCAPE_CCW: "Liggende mod uret" STR_LANDSCAPE_CCW: "Liggende mod uret"
STR_PREV_NEXT: "Forrige/Næste" STR_PREV_NEXT: "Forrige/Næste"
STR_NEXT_PREV: "Næste/Forrige" STR_NEXT_PREV: "Næste/Forrige"
@@ -188,6 +188,9 @@ STR_HOME: "« Hjem"
STR_SELECT: "Vælg" STR_SELECT: "Vælg"
STR_SELECTED: "Valgt" STR_SELECTED: "Valgt"
STR_TOGGLE: "Skift" STR_TOGGLE: "Skift"
STR_TOGGLE_BOOKMARK: "Skift bogmærke"
STR_BOOKMARK_REMOVED: "Bogmærke fjernet."
STR_HOLD_OPEN_TO_DELETE: "Hold Åbn nede for at slette"
STR_CONFIRM: "Bekræft" STR_CONFIRM: "Bekræft"
STR_CANCEL: "Annuller" STR_CANCEL: "Annuller"
STR_CONNECT: "Forbind" STR_CONNECT: "Forbind"
@@ -300,3 +303,4 @@ STR_SCREENSHOT_BUTTON: "Tag skærmbillede"
STR_AUTO_TURN_ENABLED: "Automatisk sidevendning aktiveret: " STR_AUTO_TURN_ENABLED: "Automatisk sidevendning aktiveret: "
STR_AUTO_TURN_PAGES_PER_MIN: "Automatisk vending (sider per minut)" STR_AUTO_TURN_PAGES_PER_MIN: "Automatisk vending (sider per minut)"
STR_TILT_PAGE_TURN: "Vip for at vende side" STR_TILT_PAGE_TURN: "Vip for at vende side"
STR_MANAGE_THEMES: "Administrer temaer"
+6 -2
View File
@@ -72,7 +72,6 @@ STR_IMAGES_SUPPRESS: "Verbergen"
STR_SHORT_PWR_BTN: "Korte klik aan/uit-knop" STR_SHORT_PWR_BTN: "Korte klik aan/uit-knop"
STR_ORIENTATION: "Leesstand" STR_ORIENTATION: "Leesstand"
STR_SIDE_BTN_LAYOUT: "Indeling zijknoppen (lezer)" STR_SIDE_BTN_LAYOUT: "Indeling zijknoppen (lezer)"
STR_TOUCH_READER_CONTROLS: "Aanraakbediening lezer"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Richt voorste knoppen" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Richt voorste knoppen"
STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior" STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior"
STR_LONG_PRESS_BEHAVIOR_OFF: "OFF" STR_LONG_PRESS_BEHAVIOR_OFF: "OFF"
@@ -136,7 +135,8 @@ STR_SLEEP: "Slaap"
STR_PAGE_TURN: "Pagina omslaan" STR_PAGE_TURN: "Pagina omslaan"
STR_PORTRAIT: "Staand" STR_PORTRAIT: "Staand"
STR_LANDSCAPE_CW: "Liggend (rechtsom)" STR_LANDSCAPE_CW: "Liggend (rechtsom)"
STR_INVERTED: "Omgekeerd" STR_INVERTED: "Geïnverteerd"
STR_ORIENTATION_INVERTED: "Staand 180°"
STR_LANDSCAPE_CCW: "Liggend (linksom)" STR_LANDSCAPE_CCW: "Liggend (linksom)"
STR_PREV_NEXT: "Vorige/Volgende" STR_PREV_NEXT: "Vorige/Volgende"
STR_NEXT_PREV: "Volgende/Vorige" STR_NEXT_PREV: "Volgende/Vorige"
@@ -188,6 +188,9 @@ STR_HOME: "« Home"
STR_SELECT: "Kies" STR_SELECT: "Kies"
STR_SELECTED: "Geselecteerd" STR_SELECTED: "Geselecteerd"
STR_TOGGLE: "Wissel" STR_TOGGLE: "Wissel"
STR_TOGGLE_BOOKMARK: "Bladwijzer wisselen"
STR_BOOKMARK_REMOVED: "Bladwijzer verwijderd."
STR_HOLD_OPEN_TO_DELETE: "Houd Openen ingedrukt om te verwijderen"
STR_CONFIRM: "Bevestig" STR_CONFIRM: "Bevestig"
STR_CANCEL: "Annuleer" STR_CANCEL: "Annuleer"
STR_CONNECT: "Verbind" STR_CONNECT: "Verbind"
@@ -300,3 +303,4 @@ STR_SCREENSHOT_BUTTON: "Screenshot maken"
STR_AUTO_TURN_ENABLED: "Automatisch omslaan ingeschakeld: " STR_AUTO_TURN_ENABLED: "Automatisch omslaan ingeschakeld: "
STR_AUTO_TURN_PAGES_PER_MIN: "Autom. omslaan (pagina's per minuut)" STR_AUTO_TURN_PAGES_PER_MIN: "Autom. omslaan (pagina's per minuut)"
STR_TILT_PAGE_TURN: "Kantel om te bladeren" STR_TILT_PAGE_TURN: "Kantel om te bladeren"
STR_MANAGE_THEMES: "Thema's beheren"
+5 -3
View File
@@ -73,7 +73,6 @@ STR_IMAGES_SUPPRESS: "Suppress"
STR_SHORT_PWR_BTN: "Short Power Button Click" STR_SHORT_PWR_BTN: "Short Power Button Click"
STR_ORIENTATION: "Reading Orientation" STR_ORIENTATION: "Reading Orientation"
STR_SIDE_BTN_LAYOUT: "Side Button Layout (reader)" STR_SIDE_BTN_LAYOUT: "Side Button Layout (reader)"
STR_TOUCH_READER_CONTROLS: "Touch Reader Controls"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orient front buttons" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orient front buttons"
STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior" STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior"
STR_LONG_PRESS_BEHAVIOR_OFF: "OFF" STR_LONG_PRESS_BEHAVIOR_OFF: "OFF"
@@ -140,6 +139,7 @@ STR_FORCE_REFRESH: "Refresh Screen"
STR_PORTRAIT: "Portrait" STR_PORTRAIT: "Portrait"
STR_LANDSCAPE_CW: "Landscape CW" STR_LANDSCAPE_CW: "Landscape CW"
STR_INVERTED: "Inverted" STR_INVERTED: "Inverted"
STR_ORIENTATION_INVERTED: "Portrait 180°"
STR_LANDSCAPE_CCW: "Landscape CCW" STR_LANDSCAPE_CCW: "Landscape CCW"
STR_PREV_NEXT: "Prev/Next" STR_PREV_NEXT: "Prev/Next"
STR_NEXT_PREV: "Next/Prev" STR_NEXT_PREV: "Next/Prev"
@@ -180,8 +180,7 @@ STR_DOWNLOADING: "Downloading..."
STR_DOWNLOAD_FAILED: "Download failed" STR_DOWNLOAD_FAILED: "Download failed"
STR_ERROR_MSG: "Error:" STR_ERROR_MSG: "Error:"
STR_UNNAMED: "Unnamed" STR_UNNAMED: "Unnamed"
STR_HOLD_CONFIRM_TO_DELETE: "Hold Confirm to Delete" STR_HOLD_OPEN_TO_DELETE: "Hold Open to Delete"
STR_BOOKMARK_INSTRUCTIONS: "Hold Confirm from the reader to create a bookmark."
STR_NO_SERVER_URL: "No server URL configured" STR_NO_SERVER_URL: "No server URL configured"
STR_FETCH_FEED_FAILED: "Failed to fetch feed" STR_FETCH_FEED_FAILED: "Failed to fetch feed"
STR_PARSE_FEED_FAILED: "Failed to parse feed" STR_PARSE_FEED_FAILED: "Failed to parse feed"
@@ -199,6 +198,7 @@ STR_HOME: "« Home"
STR_SELECT: "Select" STR_SELECT: "Select"
STR_SELECTED: "Selected" STR_SELECTED: "Selected"
STR_TOGGLE: "Toggle" STR_TOGGLE: "Toggle"
STR_TOGGLE_BOOKMARK: "Toggle Bookmark"
STR_CONFIRM: "Confirm" STR_CONFIRM: "Confirm"
STR_CANCEL: "Cancel" STR_CANCEL: "Cancel"
STR_CONNECT: "Connect" STR_CONNECT: "Connect"
@@ -261,6 +261,7 @@ STR_SUNLIGHT_FADING_FIX: "Sunlight Fading Fix"
STR_REMAP_FRONT_BUTTONS: "Remap Front Buttons" STR_REMAP_FRONT_BUTTONS: "Remap Front Buttons"
STR_BOOKMARKS: "Bookmarks" STR_BOOKMARKS: "Bookmarks"
STR_BOOKMARK_ADDED: "Bookmark added." STR_BOOKMARK_ADDED: "Bookmark added."
STR_BOOKMARK_REMOVED: "Bookmark removed."
STR_OPDS_BROWSER: "OPDS Browser" STR_OPDS_BROWSER: "OPDS Browser"
STR_SEARCH: "Search" STR_SEARCH: "Search"
STR_COVER_CUSTOM: "Cover + Custom" STR_COVER_CUSTOM: "Cover + Custom"
@@ -349,6 +350,7 @@ STR_INSTALLED: "Installed"
STR_DOWNLOAD_ALL: "Download All" STR_DOWNLOAD_ALL: "Download All"
STR_UPDATE_ALL: "Update All" STR_UPDATE_ALL: "Update All"
STR_UPDATE_AVAILABLE: "Update" STR_UPDATE_AVAILABLE: "Update"
STR_MANAGE_THEMES: "Manage Themes"
STR_CRASH_TITLE: "System Crash" STR_CRASH_TITLE: "System Crash"
STR_CRASH_DESCRIPTION: "A detailed report was saved to crash_report.txt. Please include this file in your bug report." STR_CRASH_DESCRIPTION: "A detailed report was saved to crash_report.txt. Please include this file in your bug report."
STR_CRASH_REASON: "Crash reason:" STR_CRASH_REASON: "Crash reason:"
+6 -2
View File
@@ -68,7 +68,6 @@ STR_TEXT_AA: "Tekstin reunanpehmennys"
STR_SHORT_PWR_BTN: "Lyhyt virtapainikkeen painallus" STR_SHORT_PWR_BTN: "Lyhyt virtapainikkeen painallus"
STR_ORIENTATION: "Lukusuunta" STR_ORIENTATION: "Lukusuunta"
STR_SIDE_BTN_LAYOUT: "Sivupainikkeiden asettelu (lukija)" STR_SIDE_BTN_LAYOUT: "Sivupainikkeiden asettelu (lukija)"
STR_TOUCH_READER_CONTROLS: "Kosketusohjaus (lukija)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Suuntaa etupainikkeet" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Suuntaa etupainikkeet"
STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior" STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior"
STR_LONG_PRESS_BEHAVIOR_OFF: "OFF" STR_LONG_PRESS_BEHAVIOR_OFF: "OFF"
@@ -131,7 +130,8 @@ STR_SLEEP: "Lepotila"
STR_PAGE_TURN: "Sivunkääntö" STR_PAGE_TURN: "Sivunkääntö"
STR_PORTRAIT: "Pysty" STR_PORTRAIT: "Pysty"
STR_LANDSCAPE_CW: "Vaaka myötäpäivään" STR_LANDSCAPE_CW: "Vaaka myötäpäivään"
STR_INVERTED: "Käännetty" STR_INVERTED: "Käänteinen"
STR_ORIENTATION_INVERTED: "Pysty 180°"
STR_LANDSCAPE_CCW: "Vaaka vastapäivään" STR_LANDSCAPE_CCW: "Vaaka vastapäivään"
STR_PREV_NEXT: "Edell/Seur" STR_PREV_NEXT: "Edell/Seur"
STR_NEXT_PREV: "Seur/Edell" STR_NEXT_PREV: "Seur/Edell"
@@ -182,6 +182,9 @@ STR_EXIT: "« Poistu"
STR_HOME: "« Koti" STR_HOME: "« Koti"
STR_SELECT: "Valitse" STR_SELECT: "Valitse"
STR_TOGGLE: "Vaihda" STR_TOGGLE: "Vaihda"
STR_TOGGLE_BOOKMARK: "Vaihda kirjanmerkki"
STR_BOOKMARK_REMOVED: "Kirjanmerkki poistettu."
STR_HOLD_OPEN_TO_DELETE: "Pidä Avaa painettuna poistaaksesi"
STR_CONFIRM: "Vahvista" STR_CONFIRM: "Vahvista"
STR_CANCEL: "Peruuta" STR_CANCEL: "Peruuta"
STR_CONNECT: "Yhdistä" STR_CONNECT: "Yhdistä"
@@ -270,3 +273,4 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
STR_SLEEP_NEVER: "Ei koskaan" STR_SLEEP_NEVER: "Ei koskaan"
STR_SLEEP_TIMER_STEP_HINT: "Vasen/Oikea: 1 min Ylös/Alas: 5 min" STR_SLEEP_TIMER_STEP_HINT: "Vasen/Oikea: 1 min Ylös/Alas: 5 min"
STR_TILT_PAGE_TURN: "Sivunkääntö kallistamalla" STR_TILT_PAGE_TURN: "Sivunkääntö kallistamalla"
STR_MANAGE_THEMES: "Hallinnoi teemoja"
+5 -1
View File
@@ -72,7 +72,6 @@ STR_IMAGES_SUPPRESS: "Masquer"
STR_SHORT_PWR_BTN: "Appui court alim." STR_SHORT_PWR_BTN: "Appui court alim."
STR_ORIENTATION: "Orientation de lecture" STR_ORIENTATION: "Orientation de lecture"
STR_SIDE_BTN_LAYOUT: "Boutons latéraux" STR_SIDE_BTN_LAYOUT: "Boutons latéraux"
STR_TOUCH_READER_CONTROLS: "Commandes tactiles (lecteur)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orienter boutons avant" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orienter boutons avant"
STR_LONG_PRESS_BEHAVIOR: "Comportement lors d'un appui long" STR_LONG_PRESS_BEHAVIOR: "Comportement lors d'un appui long"
STR_LONG_PRESS_BEHAVIOR_OFF: "Désactivé" STR_LONG_PRESS_BEHAVIOR_OFF: "Désactivé"
@@ -137,6 +136,7 @@ STR_PAGE_TURN: "Page suivante"
STR_PORTRAIT: "Portrait" STR_PORTRAIT: "Portrait"
STR_LANDSCAPE_CW: "Paysage" STR_LANDSCAPE_CW: "Paysage"
STR_INVERTED: "Inversé" STR_INVERTED: "Inversé"
STR_ORIENTATION_INVERTED: "Portrait 180°"
STR_LANDSCAPE_CCW: "Paysage inversé" STR_LANDSCAPE_CCW: "Paysage inversé"
STR_PREV_NEXT: "Préc/Suiv" STR_PREV_NEXT: "Préc/Suiv"
STR_NEXT_PREV: "Suiv/Préc" STR_NEXT_PREV: "Suiv/Préc"
@@ -188,6 +188,9 @@ STR_HOME: "« Accueil"
STR_SELECT: "OK" STR_SELECT: "OK"
STR_SELECTED: "Sélectionné" STR_SELECTED: "Sélectionné"
STR_TOGGLE: "Modifier" STR_TOGGLE: "Modifier"
STR_TOGGLE_BOOKMARK: "Basculer le marque-page"
STR_BOOKMARK_REMOVED: "Marque-page supprimé."
STR_HOLD_OPEN_TO_DELETE: "Maintenir Ouvrir pour supprimer"
STR_CONFIRM: "Confirmer" STR_CONFIRM: "Confirmer"
STR_CANCEL: "Annuler" STR_CANCEL: "Annuler"
STR_CONNECT: "Connecter" STR_CONNECT: "Connecter"
@@ -301,3 +304,4 @@ STR_SCREENSHOT_BUTTON: "Capture d'écran"
STR_AUTO_TURN_ENABLED: "Tourne-page auto : " STR_AUTO_TURN_ENABLED: "Tourne-page auto : "
STR_AUTO_TURN_PAGES_PER_MIN: "Tourne-page auto (pages par minute)" STR_AUTO_TURN_PAGES_PER_MIN: "Tourne-page auto (pages par minute)"
STR_TILT_PAGE_TURN: "Tourner par inclinaison" STR_TILT_PAGE_TURN: "Tourner par inclinaison"
STR_MANAGE_THEMES: "Gérer les thèmes"
+9 -6
View File
@@ -68,10 +68,9 @@ STR_TEXT_AA: "Schriftglättung"
STR_SHORT_PWR_BTN: "An-Taste kurz drücken" STR_SHORT_PWR_BTN: "An-Taste kurz drücken"
STR_ORIENTATION: "Leseausrichtung" STR_ORIENTATION: "Leseausrichtung"
STR_SIDE_BTN_LAYOUT: "Seitliche Tasten (Lesen)" STR_SIDE_BTN_LAYOUT: "Seitliche Tasten (Lesen)"
STR_TOUCH_READER_CONTROLS: "Touch-Steuerung (Lesen)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Vordere Tasten ausrichten" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Vordere Tasten ausrichten"
STR_LONG_PRESS_BEHAVIOR: "Verhalten bei langem Tastendruck" STR_LONG_PRESS_BEHAVIOR: "Verhalten bei langem Tastendruck"
STR_LONG_PRESS_BEHAVIOR_OFF: "AUS" STR_LONG_PRESS_BEHAVIOR_OFF: "Aus"
STR_LONG_PRESS_BEHAVIOR_SKIP: "Kapitel überspringen" STR_LONG_PRESS_BEHAVIOR_SKIP: "Kapitel überspringen"
STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Ausrichtung ändern" STR_LONG_PRESS_BEHAVIOR_ORIENTATION: "Ausrichtung ändern"
STR_FONT_PREVIEW_TEXT: "Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich" STR_FONT_PREVIEW_TEXT: "Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich"
@@ -80,8 +79,9 @@ STR_FONT_SIZE: "Schriftgröße"
STR_LINE_SPACING: "Lese-Zeilenabstand" STR_LINE_SPACING: "Lese-Zeilenabstand"
STR_SCREEN_MARGIN: "Lese-Seitenränder" STR_SCREEN_MARGIN: "Lese-Seitenränder"
STR_PARA_ALIGNMENT: "Lese-Absatzausrichtung" STR_PARA_ALIGNMENT: "Lese-Absatzausrichtung"
STR_LONG_PRESS_MENU: "Menütaste lang drücken"
STR_HYPHENATION: "Silbentrennung" STR_HYPHENATION: "Silbentrennung"
STR_TIME_TO_SLEEP: "Standby nach" STR_TIME_TO_SLEEP: "Standby-Modus nach"
STR_REFRESH_FREQ: "Anti-Ghosting nach" STR_REFRESH_FREQ: "Anti-Ghosting nach"
STR_KOREADER_SYNC: "KOReader-Synchr." STR_KOREADER_SYNC: "KOReader-Synchr."
STR_CHECK_UPDATES: "Nach Updates suchen" STR_CHECK_UPDATES: "Nach Updates suchen"
@@ -130,7 +130,8 @@ STR_PAGE_TURN: "Umblättern"
STR_FORCE_REFRESH: "Bildschirm regenerieren" STR_FORCE_REFRESH: "Bildschirm regenerieren"
STR_PORTRAIT: "Hochformat" STR_PORTRAIT: "Hochformat"
STR_LANDSCAPE_CW: "Querformat rechts" STR_LANDSCAPE_CW: "Querformat rechts"
STR_INVERTED: "Hochformat 180°" STR_INVERTED: "Invertiert"
STR_ORIENTATION_INVERTED: "Hochformat 180°"
STR_LANDSCAPE_CCW: "Querformat links" STR_LANDSCAPE_CCW: "Querformat links"
STR_PREV_NEXT: "Zurück/Weiter" STR_PREV_NEXT: "Zurück/Weiter"
STR_NEXT_PREV: "Weiter/Zurück" STR_NEXT_PREV: "Weiter/Zurück"
@@ -169,8 +170,7 @@ STR_DOWNLOADING: "Herunterladen…"
STR_DOWNLOAD_FAILED: "Ladefehler" STR_DOWNLOAD_FAILED: "Ladefehler"
STR_ERROR_MSG: "Fehler:" STR_ERROR_MSG: "Fehler:"
STR_UNNAMED: "Unbenannt" STR_UNNAMED: "Unbenannt"
STR_HOLD_CONFIRM_TO_DELETE: "Halte Bestätigen zum Löschen" STR_HOLD_OPEN_TO_DELETE: "Halte Öffnen zum Löschen"
STR_BOOKMARK_INSTRUCTIONS: "Halte Bestätigen im Lesemodus um ein Lesezeichen anzulegen."
STR_NO_SERVER_URL: "Keine Server-URL konfiguriert" STR_NO_SERVER_URL: "Keine Server-URL konfiguriert"
STR_FETCH_FEED_FAILED: "Feedfehler" STR_FETCH_FEED_FAILED: "Feedfehler"
STR_PARSE_FEED_FAILED: "Feed-Format ungültig" STR_PARSE_FEED_FAILED: "Feed-Format ungültig"
@@ -188,6 +188,7 @@ STR_HOME: "« Start"
STR_SELECT: "Auswahl" STR_SELECT: "Auswahl"
STR_SELECTED: "Ausgewählt" STR_SELECTED: "Ausgewählt"
STR_TOGGLE: "Ändern" STR_TOGGLE: "Ändern"
STR_TOGGLE_BOOKMARK: "Lesezeichen umschalten"
STR_CONFIRM: "Bestätigen" STR_CONFIRM: "Bestätigen"
STR_CANCEL: "Abbrechen" STR_CANCEL: "Abbrechen"
STR_CONNECT: "Verbinden" STR_CONNECT: "Verbinden"
@@ -251,6 +252,7 @@ STR_QUICK_RESUME_TIMEOUT: "Schnelles Fortsetzen nach Timeout"
STR_REMAP_FRONT_BUTTONS: "Vordere Tasten belegen" STR_REMAP_FRONT_BUTTONS: "Vordere Tasten belegen"
STR_BOOKMARKS: "Lesezeichen" STR_BOOKMARKS: "Lesezeichen"
STR_BOOKMARK_ADDED: "Lesezeichen hinzugefügt." STR_BOOKMARK_ADDED: "Lesezeichen hinzugefügt."
STR_BOOKMARK_REMOVED: "Lesezeichen entfernt."
STR_SEARCH: "Suche" STR_SEARCH: "Suche"
STR_OPDS_BROWSER: "OPDS-Browser" STR_OPDS_BROWSER: "OPDS-Browser"
STR_COVER_CUSTOM: "Cover + Eigenes" STR_COVER_CUSTOM: "Cover + Eigenes"
@@ -378,3 +380,4 @@ STR_FIRMWARE_WRITE_FAILED: "Schreiben der Firmware-Datei ist fehlgeschlagen"
STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Nicht ausschalten!" STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Nicht ausschalten!"
STR_RECOVERY_MODE: "Wiederherstellungsmodus" STR_RECOVERY_MODE: "Wiederherstellungsmodus"
STR_RECOVERY_MODE_HINT: "Lege firmware.bin im SD-Kartenwurzelverzeichnis ab und wähle es aus" STR_RECOVERY_MODE_HINT: "Lege firmware.bin im SD-Kartenwurzelverzeichnis ab und wähle es aus"
STR_MANAGE_THEMES: "Designs verwalten"
+13 -4
View File
@@ -73,7 +73,6 @@ STR_IMAGES_SUPPRESS: "הסתר תמונות"
STR_SHORT_PWR_BTN: "לחיצה קצרה על כפתור ההפעלה" STR_SHORT_PWR_BTN: "לחיצה קצרה על כפתור ההפעלה"
STR_ORIENTATION: "כיוון קריאה (מסך)" STR_ORIENTATION: "כיוון קריאה (מסך)"
STR_SIDE_BTN_LAYOUT: "פריסת כפתורי צד (בקריאה)" STR_SIDE_BTN_LAYOUT: "פריסת כפתורי צד (בקריאה)"
STR_TOUCH_READER_CONTROLS: "פקדי מגע בקריאה"
STR_LONG_PRESS_BEHAVIOR: "פעולת לחיצה ארוכה" STR_LONG_PRESS_BEHAVIOR: "פעולת לחיצה ארוכה"
STR_LONG_PRESS_BEHAVIOR_OFF: "כבוי" STR_LONG_PRESS_BEHAVIOR_OFF: "כבוי"
STR_LONG_PRESS_BEHAVIOR_SKIP: "דלג פרק" STR_LONG_PRESS_BEHAVIOR_SKIP: "דלג פרק"
@@ -135,7 +134,8 @@ STR_PAGE_TURN: "העברת דף"
STR_FORCE_REFRESH: "רענון מסך מלא" STR_FORCE_REFRESH: "רענון מסך מלא"
STR_PORTRAIT: "לאורך" STR_PORTRAIT: "לאורך"
STR_LANDSCAPE_CW: "לרוחב (ימינה)" STR_LANDSCAPE_CW: "לרוחב (ימינה)"
STR_INVERTED: "הפוך" STR_INVERTED: "היפוך צבעים"
STR_ORIENTATION_INVERTED: "לאורך 180°"
STR_LANDSCAPE_CCW: "לרוחב (שמאלה)" STR_LANDSCAPE_CCW: "לרוחב (שמאלה)"
STR_PREV_NEXT: "הקודם/הבא" STR_PREV_NEXT: "הקודם/הבא"
STR_NEXT_PREV: "הבא/הקודם" STR_NEXT_PREV: "הבא/הקודם"
@@ -190,6 +190,7 @@ STR_HOME: "מסך הבית »"
STR_SELECT: "בחר" STR_SELECT: "בחר"
STR_SELECTED: "נבחר" STR_SELECTED: "נבחר"
STR_TOGGLE: "בחר" STR_TOGGLE: "בחר"
STR_TOGGLE_BOOKMARK: "הוסף/הסר סימנייה"
STR_CONFIRM: "אישור" STR_CONFIRM: "אישור"
STR_CANCEL: "ביטול" STR_CANCEL: "ביטול"
STR_CONNECT: "התחבר" STR_CONNECT: "התחבר"
@@ -361,8 +362,7 @@ STR_FRONT_BTN_FOLLOW_ORIENTATION: "התאמת לחצנים קדמיים לכיו
STR_REMOVE_READ_FROM_RECENTS: "הסר ספרים שנקראו מרשימת האחרונים" STR_REMOVE_READ_FROM_RECENTS: "הסר ספרים שנקראו מרשימת האחרונים"
STR_MOVE_FINISHED_TO_READ: "העבר ספרים שהסתיימו לתיקיית 'נקראו'" STR_MOVE_FINISHED_TO_READ: "העבר ספרים שהסתיימו לתיקיית 'נקראו'"
STR_DISABLED: "מבוטל" STR_DISABLED: "מבוטל"
STR_HOLD_CONFIRM_TO_DELETE: "החזק לחוץ על אישור כדי למחוק" STR_HOLD_OPEN_TO_DELETE: "לחיצה ארוכה על 'פתח' כדי למחוק"
STR_BOOKMARK_INSTRUCTIONS: "החזק לחוץ על כפתור אישור בזמן הקריאה כדי להוסיף סימנייה"
STR_CLOCK: "שעון" STR_CLOCK: "שעון"
STR_CLOCK_UTC_OFFSET: "הפרש זמן UTC" STR_CLOCK_UTC_OFFSET: "הפרש זמן UTC"
STR_CLOCK_FORMAT: "תבנית השעון" STR_CLOCK_FORMAT: "תבנית השעון"
@@ -380,6 +380,15 @@ STR_CLOCK_SYNC_NO_WIFI_HINT: "התחבר תחילה לרשת אלחוטית, ו
STR_CLOCK_SYNCED: "השעון סונכרן" STR_CLOCK_SYNCED: "השעון סונכרן"
STR_BOOKMARKS: "סימניות" STR_BOOKMARKS: "סימניות"
STR_BOOKMARK_ADDED: "הסימנייה התווספה" STR_BOOKMARK_ADDED: "הסימנייה התווספה"
STR_BOOKMARK_REMOVED: "הסימנייה הוסרה"
STR_QUICK_RESUME: "חזרה מהירה" STR_QUICK_RESUME: "חזרה מהירה"
STR_REMOVE_FROM_RECENTS: "להסיר מרשימת הספרים האחרונים?" STR_REMOVE_FROM_RECENTS: "להסיר מרשימת הספרים האחרונים?"
STR_CONFIRM_DELETE_BOOKMARK: "למחוק סימנייה זו?" STR_CONFIRM_DELETE_BOOKMARK: "למחוק סימנייה זו?"
STR_MANAGE_THEMES: "ניהול ערכות נושא"
STR_LONG_PRESS_MENU: "לחיצה ארוכה על אישור"
STR_KOSYNC: "KOSync"
STR_BOOKMARK_OPTION: "סימנייה"
STR_PWR_BTN_FOOTNOTE_BACK: "חזרה מהירה מהערות שוליים"
STR_SLEEP_TIMER_VALUE_FORMAT: "%u דקות"
STR_SLEEP_NEVER: "אף פעם"
STR_SLEEP_TIMER_STEP_HINT: "שמאל/ימין: 1 דק' למעלה/למטה: 5 דק'"
+6 -2
View File
@@ -72,7 +72,6 @@ STR_IMAGES_SUPPRESS: "Elnyomás"
STR_SHORT_PWR_BTN: "Rövid bekapcsológomb nyomás" STR_SHORT_PWR_BTN: "Rövid bekapcsológomb nyomás"
STR_ORIENTATION: "Olvasási irány" STR_ORIENTATION: "Olvasási irány"
STR_SIDE_BTN_LAYOUT: "Oldalsó gomb elrendezés (olvasó)" STR_SIDE_BTN_LAYOUT: "Oldalsó gomb elrendezés (olvasó)"
STR_TOUCH_READER_CONTROLS: "Érintőképernyős vezérlés (olvasó)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Elülső gombok tájolása" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Elülső gombok tájolása"
STR_LONG_PRESS_SKIP: "Hosszú nyomás - fejezet ugrás" STR_LONG_PRESS_SKIP: "Hosszú nyomás - fejezet ugrás"
STR_FONT_PREVIEW_TEXT: "Egy hűtlen vejét fülöncsípő, dühös mexikói úr Wesselényinél mázol Quitóban" STR_FONT_PREVIEW_TEXT: "Egy hűtlen vejét fülöncsípő, dühös mexikói úr Wesselényinél mázol Quitóban"
@@ -133,7 +132,8 @@ STR_SLEEP: "Alvás"
STR_PAGE_TURN: "Lapozás" STR_PAGE_TURN: "Lapozás"
STR_PORTRAIT: "Álló" STR_PORTRAIT: "Álló"
STR_LANDSCAPE_CW: "Fekvő jobbra" STR_LANDSCAPE_CW: "Fekvő jobbra"
STR_INVERTED: "Fordított" STR_INVERTED: "Invertált"
STR_ORIENTATION_INVERTED: "Álló 180°"
STR_LANDSCAPE_CCW: "Fekvő balra" STR_LANDSCAPE_CCW: "Fekvő balra"
STR_PREV_NEXT: "Előző/Következő" STR_PREV_NEXT: "Előző/Következő"
STR_NEXT_PREV: "Következő/Előző" STR_NEXT_PREV: "Következő/Előző"
@@ -185,6 +185,9 @@ STR_HOME: "« Főoldal"
STR_SELECT: "Kiválasztás" STR_SELECT: "Kiválasztás"
STR_SELECTED: "Kiválasztva" STR_SELECTED: "Kiválasztva"
STR_TOGGLE: "Váltás" STR_TOGGLE: "Váltás"
STR_TOGGLE_BOOKMARK: "Könyvjelző váltása"
STR_BOOKMARK_REMOVED: "Könyvjelző eltávolítva."
STR_HOLD_OPEN_TO_DELETE: "Tartsa lenyomva a Megnyitás gombot a törléshez"
STR_CONFIRM: "Megerősítés" STR_CONFIRM: "Megerősítés"
STR_CANCEL: "Mégse" STR_CANCEL: "Mégse"
STR_CONNECT: "Csatlakozás" STR_CONNECT: "Csatlakozás"
@@ -297,3 +300,4 @@ STR_SCREENSHOT_BUTTON: "Képernyőkép készítése"
STR_AUTO_TURN_ENABLED: "Automatikus lapozás bekapcsolva: " STR_AUTO_TURN_ENABLED: "Automatikus lapozás bekapcsolva: "
STR_AUTO_TURN_PAGES_PER_MIN: "Automatikus lapozás (oldal/perc)" STR_AUTO_TURN_PAGES_PER_MIN: "Automatikus lapozás (oldal/perc)"
STR_TILT_PAGE_TURN: "Döntéses lapozás" STR_TILT_PAGE_TURN: "Döntéses lapozás"
STR_MANAGE_THEMES: "Témák kezelése"
+6 -3
View File
@@ -72,7 +72,6 @@ STR_IMAGES_SUPPRESS: "Nascondi"
STR_SHORT_PWR_BTN: "Press. breve pul. accensione" STR_SHORT_PWR_BTN: "Press. breve pul. accensione"
STR_ORIENTATION: "Orientamento lettura" STR_ORIENTATION: "Orientamento lettura"
STR_SIDE_BTN_LAYOUT: "Pul. laterali (lettore)" STR_SIDE_BTN_LAYOUT: "Pul. laterali (lettore)"
STR_TOUCH_READER_CONTROLS: "Controlli touch (lettore)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orienta pul. frontali" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orienta pul. frontali"
STR_LONG_PRESS_BEHAVIOR: "Press. lunga pul. laterali" STR_LONG_PRESS_BEHAVIOR: "Press. lunga pul. laterali"
STR_LONG_PRESS_BEHAVIOR_OFF: "OFF" STR_LONG_PRESS_BEHAVIOR_OFF: "OFF"
@@ -138,7 +137,8 @@ STR_PAGE_TURN: "Cambio pagina"
STR_FORCE_REFRESH: "Refresh" STR_FORCE_REFRESH: "Refresh"
STR_PORTRAIT: "Verticale" STR_PORTRAIT: "Verticale"
STR_LANDSCAPE_CW: "Orizzontale Dx" STR_LANDSCAPE_CW: "Orizzontale Dx"
STR_INVERTED: "Capovolto" STR_INVERTED: "Invertito"
STR_ORIENTATION_INVERTED: "Verticale 180°"
STR_LANDSCAPE_CCW: "Orizzontale Sx" STR_LANDSCAPE_CCW: "Orizzontale Sx"
STR_PREV_NEXT: "Prec/Succ" STR_PREV_NEXT: "Prec/Succ"
STR_NEXT_PREV: "Succ/Prec" STR_NEXT_PREV: "Succ/Prec"
@@ -193,6 +193,7 @@ STR_HOME: "« Home"
STR_SELECT: "Seleziona" STR_SELECT: "Seleziona"
STR_SELECTED: "Selezionato" STR_SELECTED: "Selezionato"
STR_TOGGLE: "Cambia" STR_TOGGLE: "Cambia"
STR_TOGGLE_BOOKMARK: "Attiva/disattiva segnalibro"
STR_CONFIRM: "Conferma" STR_CONFIRM: "Conferma"
STR_CANCEL: "Annulla" STR_CANCEL: "Annulla"
STR_CONNECT: "Connetti" STR_CONNECT: "Connetti"
@@ -358,9 +359,9 @@ STR_FIRMWARE_WRITE_FAILED: "Aggiornamento firmware non riuscito"
STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Non spegnere il dispositivo!" STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Non spegnere il dispositivo!"
STR_RECOVERY_MODE: "Modalità ripristino" STR_RECOVERY_MODE: "Modalità ripristino"
STR_RECOVERY_MODE_HINT: "Metti firmware.bin nella scheda SD e selezionalo" STR_RECOVERY_MODE_HINT: "Metti firmware.bin nella scheda SD e selezionalo"
STR_BOOKMARK_INSTRUCTIONS: "Tieni premuto Conferma nel lettore per creare un segnalibro"
STR_BOOKMARKS: "Segnalibri" STR_BOOKMARKS: "Segnalibri"
STR_BOOKMARK_ADDED: "Segnalibro aggiunto" STR_BOOKMARK_ADDED: "Segnalibro aggiunto"
STR_BOOKMARK_REMOVED: "Segnalibro rimosso"
STR_CONFIRM_DELETE_BOOKMARK: "Eliminare questo segnalibro?" STR_CONFIRM_DELETE_BOOKMARK: "Eliminare questo segnalibro?"
STR_CLOCK_SYNC_NO_WIFI_HINT: "Connettiti prima al Wi-Fi e poi riprova" STR_CLOCK_SYNC_NO_WIFI_HINT: "Connettiti prima al Wi-Fi e poi riprova"
STR_CLOCK_SYNC_OK: "Orologio sincronizzato" STR_CLOCK_SYNC_OK: "Orologio sincronizzato"
@@ -376,6 +377,8 @@ STR_CLOCK_SYNC_FAIL: "Sincronizzazione non riuscita"
STR_CLOCK_SYNC_NOW: "Sincronizza l'orologio adesso" STR_CLOCK_SYNC_NOW: "Sincronizza l'orologio adesso"
STR_CLOCK_SYNC_NO_WIFI: "Wi-Fi non connesso" STR_CLOCK_SYNC_NO_WIFI: "Wi-Fi non connesso"
STR_HOLD_CONFIRM_TO_DELETE: "Tieni premuto Conferma per cancellare" STR_HOLD_CONFIRM_TO_DELETE: "Tieni premuto Conferma per cancellare"
STR_MANAGE_THEMES: "Gestisci temi"
STR_HOLD_OPEN_TO_DELETE: "Tieni premuto Apri per eliminare"
STR_NEXT_FIELD: "Succ." STR_NEXT_FIELD: "Succ."
STR_CURRENT_TIME: "Ora attuale: " STR_CURRENT_TIME: "Ora attuale: "
STR_DISABLED: "Disattivato" STR_DISABLED: "Disattivato"
+6 -2
View File
@@ -67,7 +67,6 @@ STR_TEXT_AA: "Мәтін сырғытпасы"
STR_SHORT_PWR_BTN: "Қуат түймесін қысқа басу" STR_SHORT_PWR_BTN: "Қуат түймесін қысқа басу"
STR_ORIENTATION: "Оқу бағдары" STR_ORIENTATION: "Оқу бағдары"
STR_SIDE_BTN_LAYOUT: "Бүйірлік түймелер орналасуы (оқырман)" STR_SIDE_BTN_LAYOUT: "Бүйірлік түймелер орналасуы (оқырман)"
STR_TOUCH_READER_CONTROLS: "Сенсорлық басқару (оқырман)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Алдыңғы түймелерді бағдарлау" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Алдыңғы түймелерді бағдарлау"
STR_LONG_PRESS_SKIP: "Ұзақ басу арқылы тарау өткізу" STR_LONG_PRESS_SKIP: "Ұзақ басу арқылы тарау өткізу"
STR_FONT_PREVIEW_TEXT: "Канагаттандырылмагандыктарыныздан" STR_FONT_PREVIEW_TEXT: "Канагаттандырылмагандыктарыныздан"
@@ -127,7 +126,8 @@ STR_SLEEP: "Ұйқы"
STR_PAGE_TURN: "Бет аудару" STR_PAGE_TURN: "Бет аудару"
STR_PORTRAIT: "Тік бағдар" STR_PORTRAIT: "Тік бағдар"
STR_LANDSCAPE_CW: "Көлденең (сағат бағытымен)" STR_LANDSCAPE_CW: "Көлденең (сағат бағытымен)"
STR_INVERTED: "Төңкерілген" STR_INVERTED: "Инверсия"
STR_ORIENTATION_INVERTED: "Тік бағдар 180°"
STR_LANDSCAPE_CCW: "Көлденең (сағат тіліне қарсы)" STR_LANDSCAPE_CCW: "Көлденең (сағат тіліне қарсы)"
STR_PREV_NEXT: "Алдыңғы/Келесі" STR_PREV_NEXT: "Алдыңғы/Келесі"
STR_NEXT_PREV: "Келесі/Алдыңғы" STR_NEXT_PREV: "Келесі/Алдыңғы"
@@ -178,6 +178,9 @@ STR_EXIT: "« Шығу"
STR_HOME: "« Басты" STR_HOME: "« Басты"
STR_SELECT: "Таңдау" STR_SELECT: "Таңдау"
STR_TOGGLE: "Ауыстыру" STR_TOGGLE: "Ауыстыру"
STR_TOGGLE_BOOKMARK: "Бетбелгіні ауыстыру"
STR_BOOKMARK_REMOVED: "Бетбелгі жойылды."
STR_HOLD_OPEN_TO_DELETE: "Жою үшін Ашу түймесін ұстап тұрыңыз"
STR_CONFIRM: "Растау" STR_CONFIRM: "Растау"
STR_CANCEL: "Болдырмау" STR_CANCEL: "Болдырмау"
STR_CONNECT: "Қосылу" STR_CONNECT: "Қосылу"
@@ -296,3 +299,4 @@ STR_SCREENSHOT_BUTTON: "Скриншот түсіру"
STR_AUTO_TURN_ENABLED: "Автоматты бет аудару қосулы: " STR_AUTO_TURN_ENABLED: "Автоматты бет аудару қосулы: "
STR_AUTO_TURN_PAGES_PER_MIN: "Автоматты бет аудару (минутына бет саны)" STR_AUTO_TURN_PAGES_PER_MIN: "Автоматты бет аудару (минутына бет саны)"
STR_TILT_PAGE_TURN: "Еңкейту арқылы бет аудару" STR_TILT_PAGE_TURN: "Еңкейту арқылы бет аудару"
STR_MANAGE_THEMES: "Тақырыптарды басқару"
+6 -2
View File
@@ -72,7 +72,6 @@ STR_IMAGES_SUPPRESS: "Slėpti"
STR_SHORT_PWR_BTN: "Trumpas įjungimo pasp." STR_SHORT_PWR_BTN: "Trumpas įjungimo pasp."
STR_ORIENTATION: "Orientacija" STR_ORIENTATION: "Orientacija"
STR_SIDE_BTN_LAYOUT: "Šoniniai mygtukai" STR_SIDE_BTN_LAYOUT: "Šoniniai mygtukai"
STR_TOUCH_READER_CONTROLS: "Liečiamasis valdymas (skaityklė)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientuoti priekinius mygtukus" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientuoti priekinius mygtukus"
STR_LONG_PRESS_SKIP: "Praleisti skyrių (ilgai)" STR_LONG_PRESS_SKIP: "Praleisti skyrių (ilgai)"
STR_FONT_PREVIEW_TEXT: "Įlinkdama fechtuotojo špaga sublykčiojusi pragręžė apvalų arbūzą" STR_FONT_PREVIEW_TEXT: "Įlinkdama fechtuotojo špaga sublykčiojusi pragręžė apvalų arbūzą"
@@ -133,7 +132,8 @@ STR_SLEEP: "Miegas"
STR_PAGE_TURN: "Versti psl." STR_PAGE_TURN: "Versti psl."
STR_PORTRAIT: "Stačias" STR_PORTRAIT: "Stačias"
STR_LANDSCAPE_CW: "Gulsčias (P)" STR_LANDSCAPE_CW: "Gulsčias (P)"
STR_INVERTED: "Apverstas" STR_INVERTED: "Invertuotas"
STR_ORIENTATION_INVERTED: "Stačias 180°"
STR_LANDSCAPE_CCW: "Gulsčias (A)" STR_LANDSCAPE_CCW: "Gulsčias (A)"
STR_PREV_NEXT: "Atgal/Pirmyn" STR_PREV_NEXT: "Atgal/Pirmyn"
STR_NEXT_PREV: "Pirmyn/Atgal" STR_NEXT_PREV: "Pirmyn/Atgal"
@@ -185,6 +185,9 @@ STR_HOME: "« Pradžia"
STR_SELECT: "Rinktis" STR_SELECT: "Rinktis"
STR_SELECTED: "Pasirinkta" STR_SELECTED: "Pasirinkta"
STR_TOGGLE: "Keisti" STR_TOGGLE: "Keisti"
STR_TOGGLE_BOOKMARK: "Perjungti žymę"
STR_BOOKMARK_REMOVED: "Žymė pašalinta."
STR_HOLD_OPEN_TO_DELETE: "Laikykite Atidaryti, kad ištrintumėte"
STR_CONFIRM: "Gerai" STR_CONFIRM: "Gerai"
STR_CANCEL: "Atšaukti" STR_CANCEL: "Atšaukti"
STR_CONNECT: "Jungtis" STR_CONNECT: "Jungtis"
@@ -297,3 +300,4 @@ STR_SCREENSHOT_BUTTON: "Ekrano nuotrauka"
STR_AUTO_TURN_ENABLED: "Auto-vertimas: " STR_AUTO_TURN_ENABLED: "Auto-vertimas: "
STR_AUTO_TURN_PAGES_PER_MIN: "Auto-vertimas (psl/min)" STR_AUTO_TURN_PAGES_PER_MIN: "Auto-vertimas (psl/min)"
STR_TILT_PAGE_TURN: "Puslapio vertimas pakreipiant" STR_TILT_PAGE_TURN: "Puslapio vertimas pakreipiant"
STR_MANAGE_THEMES: "Tvarkyti temas"
+6 -2
View File
@@ -72,7 +72,6 @@ STR_IMAGES_SUPPRESS: "Pomijaj"
STR_SHORT_PWR_BTN: "Krótkie naciśnięcie zasilania" STR_SHORT_PWR_BTN: "Krótkie naciśnięcie zasilania"
STR_ORIENTATION: "Układ czytania" STR_ORIENTATION: "Układ czytania"
STR_SIDE_BTN_LAYOUT: "Układ przycisków bocznych" STR_SIDE_BTN_LAYOUT: "Układ przycisków bocznych"
STR_TOUCH_READER_CONTROLS: "Sterowanie dotykowe (czytnik)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientuj przednie przyciski" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientuj przednie przyciski"
STR_LONG_PRESS_BEHAVIOR: "Funkcja długiego przyciśnięcia" STR_LONG_PRESS_BEHAVIOR: "Funkcja długiego przyciśnięcia"
STR_LONG_PRESS_BEHAVIOR_OFF: "Wył." STR_LONG_PRESS_BEHAVIOR_OFF: "Wył."
@@ -137,7 +136,8 @@ STR_PAGE_TURN: "Nast. str."
STR_FORCE_REFRESH: "Odśwież ekran" STR_FORCE_REFRESH: "Odśwież ekran"
STR_PORTRAIT: "Pionowo" STR_PORTRAIT: "Pionowo"
STR_LANDSCAPE_CW: "Poziomo P" STR_LANDSCAPE_CW: "Poziomo P"
STR_INVERTED: "Odwrócony" STR_INVERTED: "Inwersja"
STR_ORIENTATION_INVERTED: "Pionowo 180°"
STR_LANDSCAPE_CCW: "Poziomo L" STR_LANDSCAPE_CCW: "Poziomo L"
STR_PREV_NEXT: "Poprz./Nast." STR_PREV_NEXT: "Poprz./Nast."
STR_NEXT_PREV: "Nast./Poprz." STR_NEXT_PREV: "Nast./Poprz."
@@ -192,6 +192,9 @@ STR_HOME: "« Home"
STR_SELECT: "Wybierz" STR_SELECT: "Wybierz"
STR_SELECTED: "Wybrano" STR_SELECTED: "Wybrano"
STR_TOGGLE: "Zmień" STR_TOGGLE: "Zmień"
STR_TOGGLE_BOOKMARK: "Przełącz zakładkę"
STR_BOOKMARK_REMOVED: "Zakładka usunięta."
STR_HOLD_OPEN_TO_DELETE: "Przytrzymaj Otwórz, aby usunąć"
STR_CONFIRM: "Potwierdź" STR_CONFIRM: "Potwierdź"
STR_CANCEL: "Anuluj" STR_CANCEL: "Anuluj"
STR_CONNECT: "Połącz" STR_CONNECT: "Połącz"
@@ -357,3 +360,4 @@ STR_FIRMWARE_WRITE_FAILED: "Zapis oprogramowania nieudany"
STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Nie wyłączać!" STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Nie wyłączać!"
STR_RECOVERY_MODE: "Tryb przywracania" STR_RECOVERY_MODE: "Tryb przywracania"
STR_RECOVERY_MODE_HINT: "Umieść firmware.bin w głównym katalogu karty SD i wybierz go" STR_RECOVERY_MODE_HINT: "Umieść firmware.bin w głównym katalogu karty SD i wybierz go"
STR_MANAGE_THEMES: "Zarządzaj motywami"
+5 -1
View File
@@ -68,7 +68,6 @@ STR_TEXT_AA: "Suavização de texto"
STR_SHORT_PWR_BTN: "Clique curto botão ligar" STR_SHORT_PWR_BTN: "Clique curto botão ligar"
STR_ORIENTATION: "Orientação de leitura" STR_ORIENTATION: "Orientação de leitura"
STR_SIDE_BTN_LAYOUT: "Disposição botões laterais" STR_SIDE_BTN_LAYOUT: "Disposição botões laterais"
STR_TOUCH_READER_CONTROLS: "Controlos táteis do leitor"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botões frontais" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botões frontais"
STR_LONG_PRESS_BEHAVIOR: "Comportamento do botão de premir e segurar" STR_LONG_PRESS_BEHAVIOR: "Comportamento do botão de premir e segurar"
STR_LONG_PRESS_BEHAVIOR_OFF: "Desligado" STR_LONG_PRESS_BEHAVIOR_OFF: "Desligado"
@@ -132,6 +131,7 @@ STR_PAGE_TURN: "Virar página"
STR_PORTRAIT: "Retrato" STR_PORTRAIT: "Retrato"
STR_LANDSCAPE_CW: "Paisagem H" STR_LANDSCAPE_CW: "Paisagem H"
STR_INVERTED: "Invertido" STR_INVERTED: "Invertido"
STR_ORIENTATION_INVERTED: "Retrato 180°"
STR_LANDSCAPE_CCW: "Paisagem AH" STR_LANDSCAPE_CCW: "Paisagem AH"
STR_PREV_NEXT: "Ant/Próx" STR_PREV_NEXT: "Ant/Próx"
STR_NEXT_PREV: "Próx/Ant" STR_NEXT_PREV: "Próx/Ant"
@@ -182,6 +182,9 @@ STR_EXIT: "« Sair"
STR_HOME: "« Início" STR_HOME: "« Início"
STR_SELECT: "Escolher" STR_SELECT: "Escolher"
STR_TOGGLE: "Alternar" STR_TOGGLE: "Alternar"
STR_TOGGLE_BOOKMARK: "Alternar marcador"
STR_BOOKMARK_REMOVED: "Marcador removido."
STR_HOLD_OPEN_TO_DELETE: "Mantenha Abrir pressionado para excluir"
STR_CONFIRM: "Confirmar" STR_CONFIRM: "Confirmar"
STR_CANCEL: "Cancelar" STR_CANCEL: "Cancelar"
STR_CONNECT: "Conectar" STR_CONNECT: "Conectar"
@@ -272,3 +275,4 @@ STR_SLEEP_TIMER_VALUE_FORMAT: "%u min"
STR_SLEEP_NEVER: "Nunca" STR_SLEEP_NEVER: "Nunca"
STR_SLEEP_TIMER_STEP_HINT: "Esq/Dir: 1 min Cima/Baixo: 5 min" STR_SLEEP_TIMER_STEP_HINT: "Esq/Dir: 1 min Cima/Baixo: 5 min"
STR_TILT_PAGE_TURN: "Virar página por inclinação" STR_TILT_PAGE_TURN: "Virar página por inclinação"
STR_MANAGE_THEMES: "Gerenciar temas"
+5 -1
View File
@@ -72,7 +72,6 @@ STR_IMAGES_SUPPRESS: "Suprimare"
STR_SHORT_PWR_BTN: "Apăsare scurtă întrerupător" STR_SHORT_PWR_BTN: "Apăsare scurtă întrerupător"
STR_ORIENTATION: "Orientare lectură" STR_ORIENTATION: "Orientare lectură"
STR_SIDE_BTN_LAYOUT: "Aspect butoane laterale (lectură)" STR_SIDE_BTN_LAYOUT: "Aspect butoane laterale (lectură)"
STR_TOUCH_READER_CONTROLS: "Control tactil (lectură)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientare butoane frontale" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientare butoane frontale"
STR_LONG_PRESS_BEHAVIOR: "Comportament buton apăsat lung" STR_LONG_PRESS_BEHAVIOR: "Comportament buton apăsat lung"
STR_LONG_PRESS_BEHAVIOR_OFF: "Dezactivat" STR_LONG_PRESS_BEHAVIOR_OFF: "Dezactivat"
@@ -137,6 +136,7 @@ STR_PAGE_TURN: "Răsfoire pagină"
STR_PORTRAIT: "Vertical" STR_PORTRAIT: "Vertical"
STR_LANDSCAPE_CW: "Orizontal dreapta" STR_LANDSCAPE_CW: "Orizontal dreapta"
STR_INVERTED: "Invers" STR_INVERTED: "Invers"
STR_ORIENTATION_INVERTED: "Vertical 180°"
STR_LANDSCAPE_CCW: "Orizontal stânga" STR_LANDSCAPE_CCW: "Orizontal stânga"
STR_PREV_NEXT: "Înainte/Înapoi" STR_PREV_NEXT: "Înainte/Înapoi"
STR_NEXT_PREV: "Înapoi/Înainte" STR_NEXT_PREV: "Înapoi/Înainte"
@@ -188,6 +188,9 @@ STR_HOME: "« Acasă"
STR_SELECT: "Selectează" STR_SELECT: "Selectează"
STR_SELECTED: "Selectat" STR_SELECTED: "Selectat"
STR_TOGGLE: "Schimbă" STR_TOGGLE: "Schimbă"
STR_TOGGLE_BOOKMARK: "Comută marcajul"
STR_BOOKMARK_REMOVED: "Marcaj eliminat."
STR_HOLD_OPEN_TO_DELETE: "Țineți apăsat Deschideți pentru a șterge"
STR_CONFIRM: "Confirmă" STR_CONFIRM: "Confirmă"
STR_CANCEL: "Anulare" STR_CANCEL: "Anulare"
STR_CONNECT: "Conectare" STR_CONNECT: "Conectare"
@@ -300,3 +303,4 @@ STR_SCREENSHOT_BUTTON: "Captură ecran"
STR_AUTO_TURN_ENABLED: "Răsfoire automată: " STR_AUTO_TURN_ENABLED: "Răsfoire automată: "
STR_AUTO_TURN_PAGES_PER_MIN: "Pagini pe minut" STR_AUTO_TURN_PAGES_PER_MIN: "Pagini pe minut"
STR_TILT_PAGE_TURN: "Întoarcere pagină prin înclinare" STR_TILT_PAGE_TURN: "Întoarcere pagină prin înclinare"
STR_MANAGE_THEMES: "Gestionează temele"
+5 -3
View File
@@ -73,7 +73,6 @@ STR_IMAGES_SUPPRESS: "Скрыть"
STR_SHORT_PWR_BTN: "Короткое нажатие PWR" STR_SHORT_PWR_BTN: "Короткое нажатие PWR"
STR_ORIENTATION: "Ориентация чтения" STR_ORIENTATION: "Ориентация чтения"
STR_SIDE_BTN_LAYOUT: "Боковые кнопки" STR_SIDE_BTN_LAYOUT: "Боковые кнопки"
STR_TOUCH_READER_CONTROLS: "Сенсорное управление чтением"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Ориентировать передние кнопки" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Ориентировать передние кнопки"
STR_LONG_PRESS_BEHAVIOR: "Долгое нажатие" STR_LONG_PRESS_BEHAVIOR: "Долгое нажатие"
STR_LONG_PRESS_BEHAVIOR_OFF: "Ничего" STR_LONG_PRESS_BEHAVIOR_OFF: "Ничего"
@@ -141,6 +140,7 @@ STR_FORCE_REFRESH: "Обновление экрана"
STR_PORTRAIT: "Портрет" STR_PORTRAIT: "Портрет"
STR_LANDSCAPE_CW: "Ландшафт (CW)" STR_LANDSCAPE_CW: "Ландшафт (CW)"
STR_INVERTED: "Инверсия" STR_INVERTED: "Инверсия"
STR_ORIENTATION_INVERTED: "Портрет 180°"
STR_LANDSCAPE_CCW: "Ландшафт (CCW)" STR_LANDSCAPE_CCW: "Ландшафт (CCW)"
STR_PREV_NEXT: "Назад/Вперёд" STR_PREV_NEXT: "Назад/Вперёд"
STR_NEXT_PREV: "Вперёд/Назад" STR_NEXT_PREV: "Вперёд/Назад"
@@ -181,8 +181,7 @@ STR_DOWNLOADING: "Загрузка..."
STR_DOWNLOAD_FAILED: "Ошибка загрузки" STR_DOWNLOAD_FAILED: "Ошибка загрузки"
STR_ERROR_MSG: "Ошибка:" STR_ERROR_MSG: "Ошибка:"
STR_UNNAMED: "Без имени" STR_UNNAMED: "Без имени"
STR_HOLD_CONFIRM_TO_DELETE: "Удерживайте ОТКРЫТЬ для удаления закладки" STR_HOLD_OPEN_TO_DELETE: "Удерживайте Открыть для удаления"
STR_BOOKMARK_INSTRUCTIONS: "Удерживайте ВЫБРАТЬ для добавления закладки"
STR_NO_SERVER_URL: "URL сервера не настроен" STR_NO_SERVER_URL: "URL сервера не настроен"
STR_FETCH_FEED_FAILED: "Не удалось получить ленту" STR_FETCH_FEED_FAILED: "Не удалось получить ленту"
STR_PARSE_FEED_FAILED: "Не удалось обработать ленту" STR_PARSE_FEED_FAILED: "Не удалось обработать ленту"
@@ -200,6 +199,7 @@ STR_HOME: "« Главная"
STR_SELECT: "Выбрать" STR_SELECT: "Выбрать"
STR_SELECTED: "Выбран" STR_SELECTED: "Выбран"
STR_TOGGLE: "Выбор" STR_TOGGLE: "Выбор"
STR_TOGGLE_BOOKMARK: "Переключить закладку"
STR_CONFIRM: "Подтв." STR_CONFIRM: "Подтв."
STR_CANCEL: "Отмена" STR_CANCEL: "Отмена"
STR_CONNECT: "Подкл." STR_CONNECT: "Подкл."
@@ -262,6 +262,7 @@ STR_SUNLIGHT_FADING_FIX: "Компенсация выцветания"
STR_REMAP_FRONT_BUTTONS: "Переназначить передние кнопки" STR_REMAP_FRONT_BUTTONS: "Переназначить передние кнопки"
STR_BOOKMARKS: "Закладки" STR_BOOKMARKS: "Закладки"
STR_BOOKMARK_ADDED: "Закладка добавлена" STR_BOOKMARK_ADDED: "Закладка добавлена"
STR_BOOKMARK_REMOVED: "Закладка удалена"
STR_OPDS_BROWSER: "OPDS браузер" STR_OPDS_BROWSER: "OPDS браузер"
STR_SEARCH: "Поиск" STR_SEARCH: "Поиск"
STR_COVER_CUSTOM: "Обложка + Свой" STR_COVER_CUSTOM: "Обложка + Свой"
@@ -382,3 +383,4 @@ STR_FIRMWARE_WRITE_FAILED: "Ошибка записи прошивки"
STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Не выключайте питание!" STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Не выключайте питание!"
STR_RECOVERY_MODE: "Режим восстановления" STR_RECOVERY_MODE: "Режим восстановления"
STR_RECOVERY_MODE_HINT: "Поместите firmware.bin в корень SD-карты и выберите его" STR_RECOVERY_MODE_HINT: "Поместите firmware.bin в корень SD-карты и выберите его"
STR_MANAGE_THEMES: "Управление темами"
+5 -4
View File
@@ -73,7 +73,6 @@ STR_IMAGES_SUPPRESS: "Potlačiť"
STR_SHORT_PWR_BTN: "Krátke stlačenie tlačidla napájania" STR_SHORT_PWR_BTN: "Krátke stlačenie tlačidla napájania"
STR_ORIENTATION: "Orientácia čítania" STR_ORIENTATION: "Orientácia čítania"
STR_SIDE_BTN_LAYOUT: "Rozloženie bočných tlačidiel (čítačka)" STR_SIDE_BTN_LAYOUT: "Rozloženie bočných tlačidiel (čítačka)"
STR_TOUCH_READER_CONTROLS: "Dotykové ovládanie čítačky"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Prispôsobiť predné tlačidlá orientácii" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Prispôsobiť predné tlačidlá orientácii"
STR_LONG_PRESS_BEHAVIOR: "Správanie pri dlhom stlačení tlačidla" STR_LONG_PRESS_BEHAVIOR: "Správanie pri dlhom stlačení tlačidla"
STR_LONG_PRESS_BEHAVIOR_OFF: "VYP" STR_LONG_PRESS_BEHAVIOR_OFF: "VYP"
@@ -138,7 +137,8 @@ STR_PAGE_TURN: "Otáčanie stránok"
STR_FORCE_REFRESH: "Obnoviť obrazovku" STR_FORCE_REFRESH: "Obnoviť obrazovku"
STR_PORTRAIT: "Na výšku" STR_PORTRAIT: "Na výšku"
STR_LANDSCAPE_CW: "Na šírku v smere hodinových ručičiek" STR_LANDSCAPE_CW: "Na šírku v smere hodinových ručičiek"
STR_INVERTED: "Obrátený" STR_INVERTED: "Invertovaný"
STR_ORIENTATION_INVERTED: "Na výšku 180°"
STR_LANDSCAPE_CCW: "Na šírku proti smeru hodinových ručičiek" STR_LANDSCAPE_CCW: "Na šírku proti smeru hodinových ručičiek"
STR_PREV_NEXT: "Predchádzajúca/Nasledujúca" STR_PREV_NEXT: "Predchádzajúca/Nasledujúca"
STR_NEXT_PREV: "Nasledujúca/Predchádzajúca" STR_NEXT_PREV: "Nasledujúca/Predchádzajúca"
@@ -177,8 +177,7 @@ STR_DOWNLOADING: "Sťahovanie..."
STR_DOWNLOAD_FAILED: "Sťahovanie zlyhalo" STR_DOWNLOAD_FAILED: "Sťahovanie zlyhalo"
STR_ERROR_MSG: "Chyba:" STR_ERROR_MSG: "Chyba:"
STR_UNNAMED: "Nepomenované" STR_UNNAMED: "Nepomenované"
STR_HOLD_CONFIRM_TO_DELETE: "Podrž potvrdiť pre vymazanie" STR_HOLD_OPEN_TO_DELETE: "Podržte Otvoriť pre vymazanie"
STR_BOOKMARK_INSTRUCTIONS: "Podrž tlačidlo Potvrdiť pre vytvorenie záložky."
STR_NO_SERVER_URL: "Nie je nakonfigurovaná URL adresa servera" STR_NO_SERVER_URL: "Nie je nakonfigurovaná URL adresa servera"
STR_FETCH_FEED_FAILED: "Načítanie kanála zlyhalo" STR_FETCH_FEED_FAILED: "Načítanie kanála zlyhalo"
STR_PARSE_FEED_FAILED: "Spracovanie kanála zlyhalo" STR_PARSE_FEED_FAILED: "Spracovanie kanála zlyhalo"
@@ -196,6 +195,7 @@ STR_HOME: "« Domov"
STR_SELECT: "Vybrať" STR_SELECT: "Vybrať"
STR_SELECTED: "Vybrané" STR_SELECTED: "Vybrané"
STR_TOGGLE: "Prepnúť" STR_TOGGLE: "Prepnúť"
STR_TOGGLE_BOOKMARK: "Prepnúť záložku"
STR_CONFIRM: "Potvrdiť" STR_CONFIRM: "Potvrdiť"
STR_CANCEL: "Zrušiť" STR_CANCEL: "Zrušiť"
STR_CONNECT: "Pripojiť" STR_CONNECT: "Pripojiť"
@@ -258,6 +258,7 @@ STR_SUNLIGHT_FADING_FIX: "Oprava blednutia na slnku"
STR_REMAP_FRONT_BUTTONS: "Premapovať predné tlačidlá" STR_REMAP_FRONT_BUTTONS: "Premapovať predné tlačidlá"
STR_BOOKMARKS: "Záložky" STR_BOOKMARKS: "Záložky"
STR_BOOKMARK_ADDED: "Záložka pridaná." STR_BOOKMARK_ADDED: "Záložka pridaná."
STR_BOOKMARK_REMOVED: "Záložka odstránená."
STR_OPDS_BROWSER: "Prehliadač OPDS" STR_OPDS_BROWSER: "Prehliadač OPDS"
STR_SEARCH: "Hľadať" STR_SEARCH: "Hľadať"
STR_COVER_CUSTOM: "Obálka + Vlastné" STR_COVER_CUSTOM: "Obálka + Vlastné"
+6 -2
View File
@@ -72,7 +72,6 @@ STR_IMAGES_SUPPRESS: "Zatdi"
STR_SHORT_PWR_BTN: "Kratek pritisk na gumb za vklop" STR_SHORT_PWR_BTN: "Kratek pritisk na gumb za vklop"
STR_ORIENTATION: "Orientacija branja" STR_ORIENTATION: "Orientacija branja"
STR_SIDE_BTN_LAYOUT: "Razpored stranskih gumbov" STR_SIDE_BTN_LAYOUT: "Razpored stranskih gumbov"
STR_TOUCH_READER_CONTROLS: "Dotikalni nadzor (bralnik)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Usmeri sprednje gumbe" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Usmeri sprednje gumbe"
STR_LONG_PRESS_SKIP: "Dolgi pritisk za preskok poglavja" STR_LONG_PRESS_SKIP: "Dolgi pritisk za preskok poglavja"
STR_FONT_PREVIEW_TEXT: "V kožuščku hudobnega fanta stopiclja mizar" STR_FONT_PREVIEW_TEXT: "V kožuščku hudobnega fanta stopiclja mizar"
@@ -133,7 +132,8 @@ STR_SLEEP: "Spanje"
STR_PAGE_TURN: "Obračanje strani" STR_PAGE_TURN: "Obračanje strani"
STR_PORTRAIT: "Pokončno" STR_PORTRAIT: "Pokončno"
STR_LANDSCAPE_CW: "Ležeče (v smeri urinega kazalca)" STR_LANDSCAPE_CW: "Ležeče (v smeri urinega kazalca)"
STR_INVERTED: "Obrnjeno" STR_INVERTED: "Invertirano"
STR_ORIENTATION_INVERTED: "Pokončno 180°"
STR_LANDSCAPE_CCW: "Ležeče (proti smeri urinega kazalca)" STR_LANDSCAPE_CCW: "Ležeče (proti smeri urinega kazalca)"
STR_PREV_NEXT: "Nazaj/Naprej" STR_PREV_NEXT: "Nazaj/Naprej"
STR_NEXT_PREV: "Naprej/Nazaj" STR_NEXT_PREV: "Naprej/Nazaj"
@@ -185,6 +185,9 @@ STR_HOME: "« Domov"
STR_SELECT: "Izberi" STR_SELECT: "Izberi"
STR_SELECTED: "Izbrano" STR_SELECTED: "Izbrano"
STR_TOGGLE: "Preklopi" STR_TOGGLE: "Preklopi"
STR_TOGGLE_BOOKMARK: "Preklopi zaznamek"
STR_BOOKMARK_REMOVED: "Zaznamek odstranjen."
STR_HOLD_OPEN_TO_DELETE: "Držite Odpri za brisanje"
STR_CONFIRM: "Potrdi" STR_CONFIRM: "Potrdi"
STR_CANCEL: "Prekliči" STR_CANCEL: "Prekliči"
STR_CONNECT: "Poveži" STR_CONNECT: "Poveži"
@@ -297,3 +300,4 @@ STR_SCREENSHOT_BUTTON: "Naredi posnetek zaslona"
STR_AUTO_TURN_ENABLED: "Samodejno obračanje: " STR_AUTO_TURN_ENABLED: "Samodejno obračanje: "
STR_AUTO_TURN_PAGES_PER_MIN: "Samodejno obračanje (strani na minuto)" STR_AUTO_TURN_PAGES_PER_MIN: "Samodejno obračanje (strani na minuto)"
STR_TILT_PAGE_TURN: "Obračanje s priklonom" STR_TILT_PAGE_TURN: "Obračanje s priklonom"
STR_MANAGE_THEMES: "Upravljanje tem"
+5 -3
View File
@@ -72,7 +72,6 @@ STR_IMAGES_SUPPRESS: "Ocultar"
STR_SHORT_PWR_BTN: "Toque corto del encendido" STR_SHORT_PWR_BTN: "Toque corto del encendido"
STR_ORIENTATION: "Orientación" STR_ORIENTATION: "Orientación"
STR_SIDE_BTN_LAYOUT: "Función botones laterales (lector)" STR_SIDE_BTN_LAYOUT: "Función botones laterales (lector)"
STR_TOUCH_READER_CONTROLS: "Controles táctiles (lector)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botones frontales" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botones frontales"
STR_LONG_PRESS_BEHAVIOR: "Al mantener pulsado un botón" STR_LONG_PRESS_BEHAVIOR: "Al mantener pulsado un botón"
STR_LONG_PRESS_BEHAVIOR_OFF: "No hacer nada" STR_LONG_PRESS_BEHAVIOR_OFF: "No hacer nada"
@@ -139,6 +138,7 @@ STR_FORCE_REFRESH: "Refrescar pant."
STR_PORTRAIT: "Vertical" STR_PORTRAIT: "Vertical"
STR_LANDSCAPE_CW: "Horizontal (horario)" STR_LANDSCAPE_CW: "Horizontal (horario)"
STR_INVERTED: "Invertido" STR_INVERTED: "Invertido"
STR_ORIENTATION_INVERTED: "Al revés"
STR_LANDSCAPE_CCW: "Horizontal (antihorario)" STR_LANDSCAPE_CCW: "Horizontal (antihorario)"
STR_PREV_NEXT: "Ant./Sig." STR_PREV_NEXT: "Ant./Sig."
STR_NEXT_PREV: "Sig./Ant." STR_NEXT_PREV: "Sig./Ant."
@@ -179,8 +179,7 @@ STR_DOWNLOADING: "Descargando..."
STR_DOWNLOAD_FAILED: "Fallo de descarga" STR_DOWNLOAD_FAILED: "Fallo de descarga"
STR_ERROR_MSG: "Error:" STR_ERROR_MSG: "Error:"
STR_UNNAMED: "Sin nombre" STR_UNNAMED: "Sin nombre"
STR_HOLD_CONFIRM_TO_DELETE: "Mantenga pulsado Confirmar para borrar" STR_HOLD_OPEN_TO_DELETE: "Mantenga pulsado Abrir para borrar"
STR_BOOKMARK_INSTRUCTIONS: "Mantenga pulsado Confirmar en el lector para crear un marcador."
STR_NO_SERVER_URL: "No se configuró URL de servidor" STR_NO_SERVER_URL: "No se configuró URL de servidor"
STR_FETCH_FEED_FAILED: "Fallo al obtener el feed" STR_FETCH_FEED_FAILED: "Fallo al obtener el feed"
STR_PARSE_FEED_FAILED: "Fallo al procesar el feed" STR_PARSE_FEED_FAILED: "Fallo al procesar el feed"
@@ -198,6 +197,7 @@ STR_HOME: "« Inicio"
STR_SELECT: "Selecc." STR_SELECT: "Selecc."
STR_SELECTED: "Seleccionado" STR_SELECTED: "Seleccionado"
STR_TOGGLE: "Cambiar" STR_TOGGLE: "Cambiar"
STR_TOGGLE_BOOKMARK: "Alternar marcador"
STR_CONFIRM: "Confirmar" STR_CONFIRM: "Confirmar"
STR_CANCEL: "Cancelar" STR_CANCEL: "Cancelar"
STR_CONNECT: "Conectar" STR_CONNECT: "Conectar"
@@ -261,6 +261,7 @@ STR_QUICK_RESUME_TIMEOUT: "Reanudación rápida tras tiempo"
STR_REMAP_FRONT_BUTTONS: "Reconfigurar botones frontales" STR_REMAP_FRONT_BUTTONS: "Reconfigurar botones frontales"
STR_BOOKMARKS: "Marcadores" STR_BOOKMARKS: "Marcadores"
STR_BOOKMARK_ADDED: "Marcador añadido." STR_BOOKMARK_ADDED: "Marcador añadido."
STR_BOOKMARK_REMOVED: "Marcador eliminado."
STR_OPDS_BROWSER: "Navegador OPDS" STR_OPDS_BROWSER: "Navegador OPDS"
STR_SEARCH: "Buscar" STR_SEARCH: "Buscar"
STR_COVER_CUSTOM: "Portada + Pers." STR_COVER_CUSTOM: "Portada + Pers."
@@ -382,3 +383,4 @@ STR_FIRMWARE_WRITE_FAILED: "Falló la escritura del firmware"
STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "¡No apague el dispositivo!" STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "¡No apague el dispositivo!"
STR_RECOVERY_MODE: "Modo de recuperación" STR_RECOVERY_MODE: "Modo de recuperación"
STR_RECOVERY_MODE_HINT: "Ponga firmware.bin en la raíz de la tarj. SD y selecciónelo" STR_RECOVERY_MODE_HINT: "Ponga firmware.bin en la raíz de la tarj. SD y selecciónelo"
STR_MANAGE_THEMES: "Gestionar temas"
+5 -3
View File
@@ -73,7 +73,6 @@ STR_IMAGES_SUPPRESS: "Dölj"
STR_SHORT_PWR_BTN: "Kort strömknappsklick" STR_SHORT_PWR_BTN: "Kort strömknappsklick"
STR_ORIENTATION: "Läsrikting" STR_ORIENTATION: "Läsrikting"
STR_SIDE_BTN_LAYOUT: "Sidoknappslayout (Läsare)" STR_SIDE_BTN_LAYOUT: "Sidoknappslayout (Läsare)"
STR_TOUCH_READER_CONTROLS: "Pekkontroller (läsare)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Rikta främre knappar" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Rikta främre knappar"
STR_LONG_PRESS_BEHAVIOR: "Beteende vid lång knapptryckning" STR_LONG_PRESS_BEHAVIOR: "Beteende vid lång knapptryckning"
STR_LONG_PRESS_BEHAVIOR_OFF: "AV" STR_LONG_PRESS_BEHAVIOR_OFF: "AV"
@@ -139,6 +138,7 @@ STR_FORCE_REFRESH: "Uppdatera skärmen"
STR_PORTRAIT: "Porträtt" STR_PORTRAIT: "Porträtt"
STR_LANDSCAPE_CW: "Landskap medurs" STR_LANDSCAPE_CW: "Landskap medurs"
STR_INVERTED: "Inverterad" STR_INVERTED: "Inverterad"
STR_ORIENTATION_INVERTED: "Porträtt 180°"
STR_LANDSCAPE_CCW: "Landskap moturs" STR_LANDSCAPE_CCW: "Landskap moturs"
STR_PREV_NEXT: "Förra/Nästa" STR_PREV_NEXT: "Förra/Nästa"
STR_NEXT_PREV: "Nästa/Förra" STR_NEXT_PREV: "Nästa/Förra"
@@ -177,8 +177,7 @@ STR_DOWNLOADING: "Laddar ner…"
STR_DOWNLOAD_FAILED: "Nedladdning misslyckades" STR_DOWNLOAD_FAILED: "Nedladdning misslyckades"
STR_ERROR_MSG: "Fel:" STR_ERROR_MSG: "Fel:"
STR_UNNAMED: "Ej namngiven" STR_UNNAMED: "Ej namngiven"
STR_HOLD_CONFIRM_TO_DELETE: "Håll ned Bekräfta för att radera" STR_HOLD_OPEN_TO_DELETE: "Håll ned Öppna för att radera"
STR_BOOKMARK_INSTRUCTIONS: "Håll Bekräfta i läsaren för att skapa ett bokmärke."
STR_NO_SERVER_URL: "Ingen serveradress konfigurerad" STR_NO_SERVER_URL: "Ingen serveradress konfigurerad"
STR_FETCH_FEED_FAILED: "Misslyckades att hämta flöde" STR_FETCH_FEED_FAILED: "Misslyckades att hämta flöde"
STR_PARSE_FEED_FAILED: "Misslyckades att analysera flöde" STR_PARSE_FEED_FAILED: "Misslyckades att analysera flöde"
@@ -196,6 +195,7 @@ STR_HOME: "« Hem"
STR_SELECT: "Välj " STR_SELECT: "Välj "
STR_SELECTED: "Vald" STR_SELECTED: "Vald"
STR_TOGGLE: "Växla" STR_TOGGLE: "Växla"
STR_TOGGLE_BOOKMARK: "Växla bokmärke"
STR_CONFIRM: "Bekräfta" STR_CONFIRM: "Bekräfta"
STR_CANCEL: "Avbryt" STR_CANCEL: "Avbryt"
STR_CONNECT: "Anslut" STR_CONNECT: "Anslut"
@@ -259,6 +259,7 @@ STR_QUICK_RESUME_TIMEOUT: "Snabb återupptagning efter timeout"
STR_REMAP_FRONT_BUTTONS: "Ändra frontknappar" STR_REMAP_FRONT_BUTTONS: "Ändra frontknappar"
STR_BOOKMARKS: "Bokmärken" STR_BOOKMARKS: "Bokmärken"
STR_BOOKMARK_ADDED: "Bokmärke tillagt." STR_BOOKMARK_ADDED: "Bokmärke tillagt."
STR_BOOKMARK_REMOVED: "Bokmärke borttaget."
STR_OPDS_BROWSER: "OPDS-webbläsare" STR_OPDS_BROWSER: "OPDS-webbläsare"
STR_SEARCH: "Sök" STR_SEARCH: "Sök"
STR_COVER_CUSTOM: "Omslag + Valfri" STR_COVER_CUSTOM: "Omslag + Valfri"
@@ -379,3 +380,4 @@ STR_FIRMWARE_WRITE_FAILED: "Skrivning till firmware misslyckades"
STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Stäng inte av!" STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Stäng inte av!"
STR_RECOVERY_MODE: "Återställningsläge" STR_RECOVERY_MODE: "Återställningsläge"
STR_RECOVERY_MODE_HINT: "Placera firmware.bin i SD-kortroten och välj den" STR_RECOVERY_MODE_HINT: "Placera firmware.bin i SD-kortroten och välj den"
STR_MANAGE_THEMES: "Hantera teman"
+6 -2
View File
@@ -67,7 +67,6 @@ STR_TEXT_AA: "Metin Yumuşatma (AA)"
STR_SHORT_PWR_BTN: "Kısa Güç Tuşu Tıklaması" STR_SHORT_PWR_BTN: "Kısa Güç Tuşu Tıklaması"
STR_ORIENTATION: "Okuma Yönü" STR_ORIENTATION: "Okuma Yönü"
STR_SIDE_BTN_LAYOUT: "Yan Tuş Dizilimi (okuyucu)" STR_SIDE_BTN_LAYOUT: "Yan Tuş Dizilimi (okuyucu)"
STR_TOUCH_READER_CONTROLS: "Dokunmatik okuyucu kontrolleri"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Ön düğmeleri yönlendir" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Ön düğmeleri yönlendir"
STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior" STR_LONG_PRESS_BEHAVIOR: "Long-press button behavior"
STR_LONG_PRESS_BEHAVIOR_OFF: "OFF" STR_LONG_PRESS_BEHAVIOR_OFF: "OFF"
@@ -131,7 +130,8 @@ STR_SLEEP: "Uyku"
STR_PAGE_TURN: "Sayfa Çevirme" STR_PAGE_TURN: "Sayfa Çevirme"
STR_PORTRAIT: "Dikey" STR_PORTRAIT: "Dikey"
STR_LANDSCAPE_CW: "Yatay (Saat Yönü)" STR_LANDSCAPE_CW: "Yatay (Saat Yönü)"
STR_INVERTED: "Ters" STR_INVERTED: "Negatif"
STR_ORIENTATION_INVERTED: "Dikey 180°"
STR_LANDSCAPE_CCW: "Yatay (Saat Yönü Tersi)" STR_LANDSCAPE_CCW: "Yatay (Saat Yönü Tersi)"
STR_PREV_NEXT: "Önceki/Sonraki" STR_PREV_NEXT: "Önceki/Sonraki"
STR_NEXT_PREV: "Sonraki/Önceki" STR_NEXT_PREV: "Sonraki/Önceki"
@@ -182,6 +182,9 @@ STR_EXIT: "« Çıkış"
STR_HOME: "« Ana Sayfa" STR_HOME: "« Ana Sayfa"
STR_SELECT: "Seç" STR_SELECT: "Seç"
STR_TOGGLE: "Değiştir" STR_TOGGLE: "Değiştir"
STR_TOGGLE_BOOKMARK: "Yer imini değiştir"
STR_BOOKMARK_REMOVED: "Yer imi kaldırıldı."
STR_HOLD_OPEN_TO_DELETE: "Silmek için Aç düğmesini basılı tutun"
STR_CONFIRM: "Onayla" STR_CONFIRM: "Onayla"
STR_CANCEL: "İptal" STR_CANCEL: "İptal"
STR_CONNECT: "Bağlan" STR_CONNECT: "Bağlan"
@@ -300,3 +303,4 @@ STR_SELECTED: "Seçili"
STR_SHOW: "Göster" STR_SHOW: "Göster"
STR_TITLE: "Başlık" STR_TITLE: "Başlık"
STR_TILT_PAGE_TURN: "Eğerek sayfa çevirme" STR_TILT_PAGE_TURN: "Eğerek sayfa çevirme"
STR_MANAGE_THEMES: "Temaları Yönet"
+6 -4
View File
@@ -73,7 +73,6 @@ STR_IMAGES_SUPPRESS: "Приховати"
STR_SHORT_PWR_BTN: "Короткий натиск кн. живл." STR_SHORT_PWR_BTN: "Короткий натиск кн. живл."
STR_ORIENTATION: "Орієнтація читання" STR_ORIENTATION: "Орієнтація читання"
STR_SIDE_BTN_LAYOUT: "Схема бічних кнопок" STR_SIDE_BTN_LAYOUT: "Схема бічних кнопок"
STR_TOUCH_READER_CONTROLS: "Сенсорне керування читанням"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Орієнтувати передні кнопки" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Орієнтувати передні кнопки"
STR_LONG_PRESS_BEHAVIOR: "Поведінка при довгому настику" STR_LONG_PRESS_BEHAVIOR: "Поведінка при довгому настику"
STR_LONG_PRESS_BEHAVIOR_OFF: "Немає" STR_LONG_PRESS_BEHAVIOR_OFF: "Немає"
@@ -138,7 +137,8 @@ STR_PAGE_TURN: "Наст. сторінка"
STR_FORCE_REFRESH: "Оновити екран" STR_FORCE_REFRESH: "Оновити екран"
STR_PORTRAIT: "Книжкова" STR_PORTRAIT: "Книжкова"
STR_LANDSCAPE_CW: "Альбом. за год." STR_LANDSCAPE_CW: "Альбом. за год."
STR_INVERTED: "Перевернутий" STR_INVERTED: "Інверсія"
STR_ORIENTATION_INVERTED: "Книжкова 180°"
STR_LANDSCAPE_CCW: "Альбом. проти год." STR_LANDSCAPE_CCW: "Альбом. проти год."
STR_PREV_NEXT: "Попер/Наст" STR_PREV_NEXT: "Попер/Наст"
STR_NEXT_PREV: "Наст/Попер" STR_NEXT_PREV: "Наст/Попер"
@@ -177,8 +177,7 @@ STR_DOWNLOADING: "Завантаження..."
STR_DOWNLOAD_FAILED: "Завантаження не вдалося" STR_DOWNLOAD_FAILED: "Завантаження не вдалося"
STR_ERROR_MSG: "Помилка:" STR_ERROR_MSG: "Помилка:"
STR_UNNAMED: "Без назви" STR_UNNAMED: "Без назви"
STR_HOLD_CONFIRM_TO_DELETE: "Утрим. Підтвердити, щоб Видалити" STR_HOLD_OPEN_TO_DELETE: "Утримуйте Відкрити, щоб видалити"
STR_BOOKMARK_INSTRUCTIONS: "Утрим. Підтвердити в книзі, щоб створ. закладку"
STR_NO_SERVER_URL: "URL сервера не налаштовано" STR_NO_SERVER_URL: "URL сервера не налаштовано"
STR_FETCH_FEED_FAILED: "Не вдалося отримати стрічку" STR_FETCH_FEED_FAILED: "Не вдалося отримати стрічку"
STR_PARSE_FEED_FAILED: "Не вдалося розпарсити стрічку" STR_PARSE_FEED_FAILED: "Не вдалося розпарсити стрічку"
@@ -196,6 +195,7 @@ STR_HOME: "« Додому"
STR_SELECT: "Вибрати" STR_SELECT: "Вибрати"
STR_SELECTED: "Вибрано" STR_SELECTED: "Вибрано"
STR_TOGGLE: "Обрати" STR_TOGGLE: "Обрати"
STR_TOGGLE_BOOKMARK: "Перемкнути закладку"
STR_CONFIRM: "Підтвердити" STR_CONFIRM: "Підтвердити"
STR_CANCEL: "Скасувати" STR_CANCEL: "Скасувати"
STR_CONNECT: "Приєдн." STR_CONNECT: "Приєдн."
@@ -258,6 +258,7 @@ STR_SUNLIGHT_FADING_FIX: "Виправлення вицвітання на со
STR_REMAP_FRONT_BUTTONS: "Налаштувати передні кнопки" STR_REMAP_FRONT_BUTTONS: "Налаштувати передні кнопки"
STR_BOOKMARKS: "Закладки" STR_BOOKMARKS: "Закладки"
STR_BOOKMARK_ADDED: "Закладку додано" STR_BOOKMARK_ADDED: "Закладку додано"
STR_BOOKMARK_REMOVED: "Закладку видалено"
STR_OPDS_BROWSER: "Браузер OPDS" STR_OPDS_BROWSER: "Браузер OPDS"
STR_SEARCH: "Пошук" STR_SEARCH: "Пошук"
STR_COVER_CUSTOM: "Обкл. + власне" STR_COVER_CUSTOM: "Обкл. + власне"
@@ -379,3 +380,4 @@ STR_FIRMWARE_WRITE_FAILED: "Помилка запису прошивки"
STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Не вимикайте пристрій!" STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "Не вимикайте пристрій!"
STR_RECOVERY_MODE: "Режим відновлення" STR_RECOVERY_MODE: "Режим відновлення"
STR_RECOVERY_MODE_HINT: "Помістіть firmware.bin у корінь SD-карти та виберіть його" STR_RECOVERY_MODE_HINT: "Помістіть firmware.bin у корінь SD-карти та виберіть його"
STR_MANAGE_THEMES: "Керування темами"
+5 -3
View File
@@ -73,7 +73,6 @@ STR_IMAGES_SUPPRESS: "Eliminar"
STR_SHORT_PWR_BTN: "Clic curt del botó d'engegada" STR_SHORT_PWR_BTN: "Clic curt del botó d'engegada"
STR_ORIENTATION: "Orientació de lectura" STR_ORIENTATION: "Orientació de lectura"
STR_SIDE_BTN_LAYOUT: "Disposició botons laterals" STR_SIDE_BTN_LAYOUT: "Disposició botons laterals"
STR_TOUCH_READER_CONTROLS: "Controls tàctils del lector"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botons frontals" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Orientar botons frontals"
STR_LONG_PRESS_BEHAVIOR: "Comportament de prémer llargament el botó" STR_LONG_PRESS_BEHAVIOR: "Comportament de prémer llargament el botó"
STR_LONG_PRESS_BEHAVIOR_OFF: "Desactivat" STR_LONG_PRESS_BEHAVIOR_OFF: "Desactivat"
@@ -142,6 +141,7 @@ STR_PAGE_TURN: "Canvi de pàgina"
STR_PORTRAIT: "Vertical" STR_PORTRAIT: "Vertical"
STR_LANDSCAPE_CW: "Horitzontal horari" STR_LANDSCAPE_CW: "Horitzontal horari"
STR_INVERTED: "Invertit" STR_INVERTED: "Invertit"
STR_ORIENTATION_INVERTED: "Vertical 180°"
STR_LANDSCAPE_CCW: "Horitzontal antihorari" STR_LANDSCAPE_CCW: "Horitzontal antihorari"
STR_PREV_NEXT: "Anterior/Següent" STR_PREV_NEXT: "Anterior/Següent"
STR_NEXT_PREV: "Següent/Anterior" STR_NEXT_PREV: "Següent/Anterior"
@@ -181,8 +181,7 @@ STR_DOWNLOADING: "S'està baixant..."
STR_DOWNLOAD_FAILED: "Ha fallat la baixada" STR_DOWNLOAD_FAILED: "Ha fallat la baixada"
STR_ERROR_MSG: "Error:" STR_ERROR_MSG: "Error:"
STR_UNNAMED: "Sense nom" STR_UNNAMED: "Sense nom"
STR_HOLD_CONFIRM_TO_DELETE: "Manteniu premut Confirma per esborrar" STR_HOLD_OPEN_TO_DELETE: "Manteniu premut Obre per esborrar"
STR_BOOKMARK_INSTRUCTIONS: "Manteniu premut Confirma al lector per crear un punt de llibre."
STR_NO_SERVER_URL: "No s'ha configurat cap URL de servidor" STR_NO_SERVER_URL: "No s'ha configurat cap URL de servidor"
STR_FETCH_FEED_FAILED: "Ha fallat l'obtenció del feed" STR_FETCH_FEED_FAILED: "Ha fallat l'obtenció del feed"
STR_PARSE_FEED_FAILED: "Ha fallat l'anàlisi del feed" STR_PARSE_FEED_FAILED: "Ha fallat l'anàlisi del feed"
@@ -198,6 +197,7 @@ STR_HOME: "« Inici"
STR_SELECT: "Selecciona" STR_SELECT: "Selecciona"
STR_SELECTED: "Seleccionat" STR_SELECTED: "Seleccionat"
STR_TOGGLE: "Canvia" STR_TOGGLE: "Canvia"
STR_TOGGLE_BOOKMARK: "Canvia punt de llibre"
STR_CONFIRM: "Confirma" STR_CONFIRM: "Confirma"
STR_CANCEL: "Cancel·la" STR_CANCEL: "Cancel·la"
STR_CONNECT: "Connecta" STR_CONNECT: "Connecta"
@@ -241,6 +241,7 @@ STR_SUNLIGHT_FADING_FIX: "Correcció de l'esvaïment pel sol"
STR_REMAP_FRONT_BUTTONS: "Reassigna els botons frontals" STR_REMAP_FRONT_BUTTONS: "Reassigna els botons frontals"
STR_BOOKMARKS: "Punts de llibre" STR_BOOKMARKS: "Punts de llibre"
STR_BOOKMARK_ADDED: "S'ha afegit el punt de llibre." STR_BOOKMARK_ADDED: "S'ha afegit el punt de llibre."
STR_BOOKMARK_REMOVED: "S'ha eliminat el punt de llibre."
STR_OPDS_BROWSER: "Navegador OPDS" STR_OPDS_BROWSER: "Navegador OPDS"
STR_COVER_CUSTOM: "Portada + Personalitzat" STR_COVER_CUSTOM: "Portada + Personalitzat"
STR_QUICK_RESUME: "Represa ràpida" STR_QUICK_RESUME: "Represa ràpida"
@@ -382,3 +383,4 @@ STR_FIRMWARE_WRITE_FAILED: "Ha fallat l'escriptura del firmware"
STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "No apagueu el dispositiu!" STR_FIRMWARE_UPDATE_DO_NOT_POWER_OFF: "No apagueu el dispositiu!"
STR_RECOVERY_MODE: "Mode de recuperació" STR_RECOVERY_MODE: "Mode de recuperació"
STR_RECOVERY_MODE_HINT: "Poseu firmware.bin a l'arrel de la targeta SD i seleccioneu-lo" STR_RECOVERY_MODE_HINT: "Poseu firmware.bin a l'arrel de la targeta SD i seleccioneu-lo"
STR_MANAGE_THEMES: "Gestiona els temes"
+5 -4
View File
@@ -73,7 +73,6 @@ STR_IMAGES_SUPPRESS: "Ẩn đi"
STR_SHORT_PWR_BTN: "Nhấn nhanh nút nguồn" STR_SHORT_PWR_BTN: "Nhấn nhanh nút nguồn"
STR_ORIENTATION: "Hướng đọc" STR_ORIENTATION: "Hướng đọc"
STR_SIDE_BTN_LAYOUT: "Bố trí nút bên (trình đọc)" STR_SIDE_BTN_LAYOUT: "Bố trí nút bên (trình đọc)"
STR_TOUCH_READER_CONTROLS: "Điều khiển cảm ứng (trình đọc)"
STR_FRONT_BTN_FOLLOW_ORIENTATION: "Xoay nút trước theo hướng" STR_FRONT_BTN_FOLLOW_ORIENTATION: "Xoay nút trước theo hướng"
STR_LONG_PRESS_BEHAVIOR: "Hành vi nhấn giữ nút" STR_LONG_PRESS_BEHAVIOR: "Hành vi nhấn giữ nút"
STR_LONG_PRESS_BEHAVIOR_OFF: "TẮT" STR_LONG_PRESS_BEHAVIOR_OFF: "TẮT"
@@ -138,7 +137,8 @@ STR_PAGE_TURN: "Lật trang"
STR_FORCE_REFRESH: "Làm tươi màn hình" STR_FORCE_REFRESH: "Làm tươi màn hình"
STR_PORTRAIT: "Dọc" STR_PORTRAIT: "Dọc"
STR_LANDSCAPE_CW: "Ngang (thuận)" STR_LANDSCAPE_CW: "Ngang (thuận)"
STR_INVERTED: "Lật ngược" STR_INVERTED: "Đảo màu"
STR_ORIENTATION_INVERTED: "Dọc 180°"
STR_LANDSCAPE_CCW: "Ngang (ngược)" STR_LANDSCAPE_CCW: "Ngang (ngược)"
STR_PREV_NEXT: "Trước/Sau" STR_PREV_NEXT: "Trước/Sau"
STR_NEXT_PREV: "Sau/Trước" STR_NEXT_PREV: "Sau/Trước"
@@ -177,8 +177,7 @@ STR_DOWNLOADING: "Đang tải về..."
STR_DOWNLOAD_FAILED: "Tải về thất bại" STR_DOWNLOAD_FAILED: "Tải về thất bại"
STR_ERROR_MSG: "Lỗi:" STR_ERROR_MSG: "Lỗi:"
STR_UNNAMED: "Không tên" STR_UNNAMED: "Không tên"
STR_HOLD_CONFIRM_TO_DELETE: "Giữ Xác nhận để xóa" STR_HOLD_OPEN_TO_DELETE: "Giữ Mở để xóa"
STR_BOOKMARK_INSTRUCTIONS: "Giữ Xác nhận trong trình đọc để tạo dấu trang."
STR_NO_SERVER_URL: "Chưa cấu hình URL máy chủ" STR_NO_SERVER_URL: "Chưa cấu hình URL máy chủ"
STR_FETCH_FEED_FAILED: "Không tải được nguồn cấp" STR_FETCH_FEED_FAILED: "Không tải được nguồn cấp"
STR_PARSE_FEED_FAILED: "Không phân tích được nguồn cấp" STR_PARSE_FEED_FAILED: "Không phân tích được nguồn cấp"
@@ -196,6 +195,7 @@ STR_HOME: "« Thư viện"
STR_SELECT: "Chọn" STR_SELECT: "Chọn"
STR_SELECTED: "Đã chọn" STR_SELECTED: "Đã chọn"
STR_TOGGLE: "Bật/Tắt" STR_TOGGLE: "Bật/Tắt"
STR_TOGGLE_BOOKMARK: "Bật/tắt dấu trang"
STR_CONFIRM: "Xác nhận" STR_CONFIRM: "Xác nhận"
STR_CANCEL: "Hủy" STR_CANCEL: "Hủy"
STR_CONNECT: "Kết nối" STR_CONNECT: "Kết nối"
@@ -258,6 +258,7 @@ STR_SUNLIGHT_FADING_FIX: "Khắc phục mờ dưới nắng"
STR_REMAP_FRONT_BUTTONS: "Gán lại nút mặt trước" STR_REMAP_FRONT_BUTTONS: "Gán lại nút mặt trước"
STR_BOOKMARKS: "Dấu trang" STR_BOOKMARKS: "Dấu trang"
STR_BOOKMARK_ADDED: "Đã thêm dấu trang." STR_BOOKMARK_ADDED: "Đã thêm dấu trang."
STR_BOOKMARK_REMOVED: "Đã xóa dấu trang."
STR_OPDS_BROWSER: "Trình duyệt OPDS" STR_OPDS_BROWSER: "Trình duyệt OPDS"
STR_SEARCH: "Tìm kiếm" STR_SEARCH: "Tìm kiếm"
STR_COVER_CUSTOM: "Ảnh bìa + Tùy chỉnh" STR_COVER_CUSTOM: "Ảnh bìa + Tùy chỉnh"
+122 -2
View File
@@ -164,6 +164,7 @@ namespace {
constexpr int MAX_MCU_HEIGHT = 16; constexpr int MAX_MCU_HEIGHT = 16;
constexpr size_t JPEG_DECODER_SIZE = 20 * 1024; constexpr size_t JPEG_DECODER_SIZE = 20 * 1024;
constexpr size_t MIN_FREE_HEAP = JPEG_DECODER_SIZE + 32 * 1024; constexpr size_t MIN_FREE_HEAP = JPEG_DECODER_SIZE + 32 * 1024;
constexpr uint32_t FP_ONE = 1UL << 16;
// Static file pointer for JPEGDEC open callback. // Static file pointer for JPEGDEC open callback.
// Safe in single-threaded embedded context; never accessed concurrently. // Safe in single-threaded embedded context; never accessed concurrently.
@@ -208,6 +209,9 @@ struct BmpConvertCtx {
bool needsScaling; bool needsScaling;
uint32_t scaleX_fp; // source pixels per output pixel, 16.16 fixed-point uint32_t scaleX_fp; // source pixels per output pixel, 16.16 fixed-point
uint32_t scaleY_fp; uint32_t scaleY_fp;
bool smoothUpscale;
uint32_t smoothScaleX_fp;
uint32_t smoothScaleY_fp;
// Accumulates one MCU row (up to MAX_MCU_HEIGHT source rows × srcWidth pixels) // Accumulates one MCU row (up to MAX_MCU_HEIGHT source rows × srcWidth pixels)
// Filled column-by-column as JPEGDEC callbacks arrive for the same MCU row // Filled column-by-column as JPEGDEC callbacks arrive for the same MCU row
@@ -219,6 +223,13 @@ struct BmpConvertCtx {
std::unique_ptr<uint32_t[]> rowAccum; std::unique_ptr<uint32_t[]> rowAccum;
std::unique_ptr<uint32_t[]> rowCount; std::unique_ptr<uint32_t[]> rowCount;
int smoothNextOutY;
int smoothPrevY;
std::unique_ptr<uint8_t[]> smoothRows;
uint8_t* smoothPrevRow;
uint8_t* smoothCurrRow;
uint8_t* smoothOutRow;
std::unique_ptr<uint8_t[]> bmpRow; std::unique_ptr<uint8_t[]> bmpRow;
std::unique_ptr<AtkinsonDitherer> atkinsonDitherer; std::unique_ptr<AtkinsonDitherer> atkinsonDitherer;
@@ -265,6 +276,88 @@ static void writeOutputRow(BmpConvertCtx* ctx, const uint8_t* srcRow, int outY)
ctx->bmpOut->write(ctx->bmpRow.get(), ctx->bytesPerRow); ctx->bmpOut->write(ctx->bmpRow.get(), ctx->bytesPerRow);
} }
// Matches the progressive-JPEG smoothing used by JpegToFramebufferConverter, but stays
// local because cover generation streams dithered BMP rows instead of framebuffer pixels.
static uint32_t interpolationStep(const int srcSize, const int outSize) {
if (srcSize <= 1 || outSize <= 1) return 0;
return (static_cast<uint32_t>(srcSize - 1) << 16) / static_cast<uint32_t>(outSize - 1);
}
static uint32_t interpolatedSourceFp(const int outIndex, const int outSize, const int srcSize, const uint32_t step) {
if (srcSize <= 1 || outSize <= 1) return 0;
if (outIndex >= outSize - 1) return static_cast<uint32_t>(srcSize - 1) << 16;
return static_cast<uint32_t>(outIndex) * step;
}
static void scaleRowLinear(BmpConvertCtx* ctx, const uint8_t* srcRow, uint8_t* dstRow) {
for (int outX = 0; outX < ctx->outWidth; outX++) {
const uint32_t srcX_fp = interpolatedSourceFp(outX, ctx->outWidth, ctx->srcWidth, ctx->smoothScaleX_fp);
const int x0 = srcX_fp >> 16;
const int x1 = (x0 + 1 < ctx->srcWidth) ? (x0 + 1) : x0;
const uint32_t fx = srcX_fp & (FP_ONE - 1);
dstRow[outX] = static_cast<uint8_t>((srcRow[x0] * (FP_ONE - fx) + srcRow[x1] * fx) >> 16);
}
}
static void writeBlendedRow(BmpConvertCtx* ctx, const uint8_t* row0, const uint8_t* row1, const uint32_t fy,
const int outY) {
const uint32_t invFy = FP_ONE - fy;
for (int outX = 0; outX < ctx->outWidth; outX++) {
ctx->smoothOutRow[outX] = static_cast<uint8_t>((row0[outX] * invFy + row1[outX] * fy) >> 16);
}
writeOutputRow(ctx, ctx->smoothOutRow, outY);
}
static void processSmoothSourceRow(BmpConvertCtx* ctx, const uint8_t* srcRow, const int srcY) {
scaleRowLinear(ctx, srcRow, ctx->smoothCurrRow);
if (ctx->smoothPrevY < 0) {
uint8_t* tmp = ctx->smoothPrevRow;
ctx->smoothPrevRow = ctx->smoothCurrRow;
ctx->smoothCurrRow = tmp;
ctx->smoothPrevY = srcY;
if (ctx->srcHeight <= 1) {
while (ctx->smoothNextOutY < ctx->outHeight) {
writeOutputRow(ctx, ctx->smoothPrevRow, ctx->smoothNextOutY);
ctx->smoothNextOutY++;
}
return;
}
return;
}
while (ctx->smoothNextOutY < ctx->outHeight) {
const uint32_t srcY_fp =
interpolatedSourceFp(ctx->smoothNextOutY, ctx->outHeight, ctx->srcHeight, ctx->smoothScaleY_fp);
const int y0 = srcY_fp >> 16;
const int y1 = (y0 + 1 < ctx->srcHeight) ? (y0 + 1) : y0;
if (y1 > srcY) break;
const uint8_t* row0 = (y0 == srcY) ? ctx->smoothCurrRow : ctx->smoothPrevRow;
const uint8_t* row1 = (y1 == srcY) ? ctx->smoothCurrRow : ctx->smoothPrevRow;
writeBlendedRow(ctx, row0, row1, srcY_fp & (FP_ONE - 1), ctx->smoothNextOutY);
ctx->smoothNextOutY++;
}
uint8_t* tmp = ctx->smoothPrevRow;
ctx->smoothPrevRow = ctx->smoothCurrRow;
ctx->smoothCurrRow = tmp;
ctx->smoothPrevY = srcY;
}
static void finishSmoothUpscale(BmpConvertCtx* ctx) {
if (ctx->smoothPrevY < 0) {
LOG_ERR("JPG", "No progressive rows decoded for smoothing");
ctx->error = true;
return;
}
while (ctx->smoothNextOutY < ctx->outHeight) {
writeOutputRow(ctx, ctx->smoothPrevRow, ctx->smoothNextOutY);
ctx->smoothNextOutY++;
}
}
// Flush one scaled output row from Y-axis accumulators and advance currentOutY // Flush one scaled output row from Y-axis accumulators and advance currentOutY
static void flushScaledRow(BmpConvertCtx* ctx) { static void flushScaledRow(BmpConvertCtx* ctx) {
memset(ctx->bmpRow.get(), 0, ctx->bytesPerRow); memset(ctx->bmpRow.get(), 0, ctx->bytesPerRow);
@@ -344,7 +437,9 @@ int bmpDrawCallback(JPEGDRAW* pDraw) {
for (int y = blockY; y < endRow && y < ctx->srcHeight; y++) { for (int y = blockY; y < endRow && y < ctx->srcHeight; y++) {
const uint8_t* srcRow = ctx->mcuBuf.get() + (y - blockY) * ctx->srcWidth; const uint8_t* srcRow = ctx->mcuBuf.get() + (y - blockY) * ctx->srcWidth;
if (!ctx->needsScaling) { if (ctx->smoothUpscale) {
processSmoothSourceRow(ctx, srcRow, y);
} else if (!ctx->needsScaling) {
// 1:1 — outWidth == srcWidth, write directly // 1:1 — outWidth == srcWidth, write directly
writeOutputRow(ctx, srcRow, y); writeOutputRow(ctx, srcRow, y);
} else { } else {
@@ -472,6 +567,9 @@ bool JpegToBmpConverter::jpegFileToBmpStreamInternal(HalFile& jpegFile, Print& b
needsScaling = true; needsScaling = true;
} }
const bool smoothUpscale =
progressiveDecode && needsScaling && scaleSrcWidth <= outWidth && scaleSrcHeight <= outHeight;
// Write BMP header with output dimensions // Write BMP header with output dimensions
int bytesPerRow; int bytesPerRow;
if (USE_8BIT_OUTPUT && !oneBit) { if (USE_8BIT_OUTPUT && !oneBit) {
@@ -496,6 +594,11 @@ bool JpegToBmpConverter::jpegFileToBmpStreamInternal(HalFile& jpegFile, Print& b
ctx.needsScaling = needsScaling; ctx.needsScaling = needsScaling;
ctx.scaleX_fp = scaleX_fp; ctx.scaleX_fp = scaleX_fp;
ctx.scaleY_fp = scaleY_fp; ctx.scaleY_fp = scaleY_fp;
ctx.smoothUpscale = smoothUpscale;
ctx.smoothScaleX_fp = interpolationStep(ctx.srcWidth, outWidth);
ctx.smoothScaleY_fp = interpolationStep(ctx.srcHeight, outHeight);
ctx.smoothNextOutY = 0;
ctx.smoothPrevY = -1;
ctx.error = false; ctx.error = false;
// MCU row buffer: MAX_MCU_HEIGHT rows × decoded srcWidth columns of grayscale // MCU row buffer: MAX_MCU_HEIGHT rows × decoded srcWidth columns of grayscale
@@ -512,7 +615,20 @@ bool JpegToBmpConverter::jpegFileToBmpStreamInternal(HalFile& jpegFile, Print& b
return false; return false;
} }
if (needsScaling) { if (smoothUpscale) {
// One contiguous allocation avoids three heap blocks while keeping smoothing line-buffered.
const size_t smoothRowsBytes = static_cast<size_t>(outWidth) * 3;
ctx.smoothRows = makeUniqueNoThrow<uint8_t[]>(smoothRowsBytes);
if (!ctx.smoothRows) {
LOG_ERR("JPG", "OOM: progressive smoothing buffers");
return false;
}
ctx.smoothPrevRow = ctx.smoothRows.get();
ctx.smoothCurrRow = ctx.smoothPrevRow + outWidth;
ctx.smoothOutRow = ctx.smoothCurrRow + outWidth;
LOG_DBG("JPG", "Progressive smoothing: %dx%d -> %dx%d, buffers=%u bytes", ctx.srcWidth, ctx.srcHeight, outWidth,
outHeight, static_cast<unsigned>(smoothRowsBytes));
} else if (needsScaling) {
ctx.rowAccum = makeUniqueNoThrow<uint32_t[]>(outWidth); ctx.rowAccum = makeUniqueNoThrow<uint32_t[]>(outWidth);
ctx.rowCount = makeUniqueNoThrow<uint32_t[]>(outWidth); ctx.rowCount = makeUniqueNoThrow<uint32_t[]>(outWidth);
if (!ctx.rowAccum || !ctx.rowCount) { if (!ctx.rowAccum || !ctx.rowCount) {
@@ -549,6 +665,10 @@ bool JpegToBmpConverter::jpegFileToBmpStreamInternal(HalFile& jpegFile, Print& b
rc = jpeg->decode(0, 0, 0); rc = jpeg->decode(0, 0, 0);
if (rc == 1 && ctx.smoothUpscale && !ctx.error) {
finishSmoothUpscale(&ctx);
}
if (rc != 1 || ctx.error) { if (rc != 1 || ctx.error) {
LOG_ERR("JPG", "JPEG decode failed (rc=%d, err=%d)", rc, jpeg->getLastError()); LOG_ERR("JPG", "JPEG decode failed (rc=%d, err=%d)", rc, jpeg->getLastError());
return false; return false;
-13
View File
@@ -1,8 +1,5 @@
#include "Logging.h" #include "Logging.h"
#include <BoardConfig.h>
#include <esp_rom_sys.h>
#include <string> #include <string>
#define MAX_ENTRY_LEN 256 #define MAX_ENTRY_LEN 256
@@ -62,19 +59,9 @@ void logPrintf(const char* level, const char* origin, const char* format, ...) {
} }
} }
va_end(args); va_end(args);
#if FREEINK_LOG_TRANSPORT == FREEINK_LOG_TRANSPORT_USB_CDC_WRITE
// Native USB CDC can report false while PlatformIO monitor is attached on
// boards like LilyGo T5 S3, so write directly to the CDC object.
logSerial.write(reinterpret_cast<const uint8_t*>(buf), strnlen(buf, sizeof(buf)));
#elif FREEINK_LOG_TRANSPORT == FREEINK_LOG_TRANSPORT_ROM_PRINTF
// IDF/ROM console path for boards whose monitor is attached there during
// bring-up, e.g. Sticky.
esp_rom_printf("%s", buf);
#else
if (logSerial) { if (logSerial) {
logSerial.print(buf); logSerial.print(buf);
} }
#endif
addToLogRingBuffer(buf); addToLogRingBuffer(buf);
} }
+1 -4
View File
@@ -27,10 +27,7 @@ won't trigger deprecation warnings.
#define LOG_LEVEL 0 #define LOG_LEVEL 0
#endif #endif
// The concrete Serial type differs by MCU: HWCDC (native USB CDC on C3/S3) vs static HWCDC& logSerial = Serial;
// HardwareSerial (UART0 on the classic ESP32 / M5Paper). Bind to whatever the
// real Serial is here — this is before the `#define Serial` shim below.
static decltype(Serial)& logSerial = Serial;
void logPrintf(const char* level, const char* origin, const char* format, ...); void logPrintf(const char* level, const char* origin, const char* format, ...);
+1 -62
View File
@@ -18,11 +18,8 @@ static uint8_t bcdToDec(uint8_t bcd) { return ((bcd >> 4) * 10) + (bcd & 0x0F);
static uint8_t decToBcd(uint8_t dec) { return ((dec / 10) << 4) | (dec % 10); } static uint8_t decToBcd(uint8_t dec) { return ((dec / 10) << 4) | (dec % 10); }
void HalClock::begin() { void HalClock::begin() {
_usesSdkRtc = false;
if (!gpio.deviceIsX3()) { if (!gpio.deviceIsX3()) {
_available = _sdkRtc.begin(); _available = false;
_usesSdkRtc = _available;
LOG_INF("CLK", _available ? "SDK RTC found" : "RTC not found");
return; return;
} }
@@ -60,24 +57,6 @@ bool HalClock::getTime(uint8_t& hour, uint8_t& minute) const {
return true; return true;
} }
if (_usesSdkRtc) {
Rtc::DateTime dt;
if (!_sdkRtc.now(dt)) {
if (!_hasCachedTime) return false;
_lastPollMs = now;
hour = _cachedHour;
minute = _cachedMinute;
return true;
}
_cachedHour = dt.hour;
_cachedMinute = dt.minute;
_lastPollMs = now;
_hasCachedTime = true;
hour = _cachedHour;
minute = _cachedMinute;
return true;
}
// Read 3 bytes starting at register 0x00: seconds, minutes, hours // Read 3 bytes starting at register 0x00: seconds, minutes, hours
Wire.beginTransmission(I2C_ADDR_DS3231); Wire.beginTransmission(I2C_ADDR_DS3231);
Wire.write(DS3231_SEC_REG); Wire.write(DS3231_SEC_REG);
@@ -152,25 +131,6 @@ bool HalClock::writeTimeToRTC(uint8_t hour, uint8_t minute, uint8_t second) {
assert(hour < 24); assert(hour < 24);
assert(minute < 60); assert(minute < 60);
assert(second < 60); assert(second < 60);
if (_usesSdkRtc) {
Rtc::DateTime dt;
dt.hour = hour;
dt.minute = minute;
dt.second = second;
dt.year = 2000;
dt.month = 1;
dt.day = 1;
if (!_sdkRtc.set(dt)) {
LOG_ERR("CLK", "Failed to write time to SDK RTC");
return false;
}
_lastPollMs = 0;
_cachedHour = hour;
_cachedMinute = minute;
_hasCachedTime = true;
return true;
}
Wire.beginTransmission(I2C_ADDR_DS3231); Wire.beginTransmission(I2C_ADDR_DS3231);
Wire.write(DS3231_SEC_REG); // Start at register 0x00 Wire.write(DS3231_SEC_REG); // Start at register 0x00
Wire.write(decToBcd(second)); // 0x00: Seconds Wire.write(decToBcd(second)); // 0x00: Seconds
@@ -208,27 +168,6 @@ bool HalClock::syncFromNTP() {
struct tm timeinfo; struct tm timeinfo;
gmtime_r(&now, &timeinfo); gmtime_r(&now, &timeinfo);
if (_usesSdkRtc) {
Rtc::DateTime dt;
dt.year = static_cast<uint16_t>(timeinfo.tm_year + 1900);
dt.month = static_cast<uint8_t>(timeinfo.tm_mon + 1);
dt.day = static_cast<uint8_t>(timeinfo.tm_mday);
dt.hour = static_cast<uint8_t>(timeinfo.tm_hour);
dt.minute = static_cast<uint8_t>(timeinfo.tm_min);
dt.second = static_cast<uint8_t>(timeinfo.tm_sec);
dt.weekday = static_cast<uint8_t>(timeinfo.tm_wday);
if (_sdkRtc.set(dt)) {
_lastPollMs = 0;
_cachedHour = dt.hour;
_cachedMinute = dt.minute;
_hasCachedTime = true;
LOG_INF("CLK", "RTC set to %04u-%02u-%02u %02u:%02u:%02u UTC", dt.year, dt.month, dt.day, dt.hour, dt.minute,
dt.second);
return true;
}
return false;
}
if (writeTimeToRTC(timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec)) { if (writeTimeToRTC(timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec)) {
LOG_INF("CLK", "RTC set to %02d:%02d:%02d UTC", timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec); LOG_INF("CLK", "RTC set to %02d:%02d:%02d UTC", timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec);
return true; return true;
-3
View File
@@ -1,7 +1,6 @@
#pragma once #pragma once
#include <Arduino.h> #include <Arduino.h>
#include <Rtc.h>
#include <Wire.h> #include <Wire.h>
#include "HalGPIO.h" #include "HalGPIO.h"
@@ -11,8 +10,6 @@ extern HalClock halClock; // Singleton
class HalClock { class HalClock {
bool _available = false; bool _available = false;
bool _usesSdkRtc = false;
mutable Rtc _sdkRtc;
mutable uint8_t _cachedHour = 0; mutable uint8_t _cachedHour = 0;
mutable uint8_t _cachedMinute = 0; mutable uint8_t _cachedMinute = 0;
mutable bool _hasCachedTime = false; mutable bool _hasCachedTime = false;
+21
View File
@@ -81,6 +81,27 @@ void HalDisplay::copyGrayscaleBuffers(const uint8_t* lsbBuffer, const uint8_t* m
einkDisplay.copyGrayscaleBuffers(lsbBuffer, msbBuffer); einkDisplay.copyGrayscaleBuffers(lsbBuffer, msbBuffer);
} }
void HalDisplay::displayGrayscaleBase(RefreshMode fallback, bool turnOffScreen) {
// X3: a HALF fallback means the caller wants a clean base (e.g. the sleep
// cover, a full-screen swap from arbitrary prior content). Without this, the
// X3 grayscale base takes its gentle differential happy path and the prior
// home/reader frame ghosts through the soft aa_pre_bw_mid waveform. Forcing a
// resync makes displayGrayscaleBase clear first, matching displayBuffer(HALF).
// The reader's FAST path is deliberately left on the differential path so
// per-page grayscale stays cheap.
if (gpio.deviceIsX3() && fallback == RefreshMode::HALF_REFRESH) {
einkDisplay.requestResync(1);
}
einkDisplay.displayGrayscaleBase(convertRefreshMode(fallback), turnOffScreen);
}
void HalDisplay::preconditionGrayscale() { einkDisplay.preconditionGrayscale(); }
void HalDisplay::preconditionGrayscale(uint16_t x, uint16_t y, uint16_t w, uint16_t h) {
einkDisplay.preconditionGrayscale(x, y, w, h);
}
void HalDisplay::copyGrayscaleLsbBuffers(const uint8_t* lsbBuffer) { einkDisplay.copyGrayscaleLsbBuffers(lsbBuffer); } void HalDisplay::copyGrayscaleLsbBuffers(const uint8_t* lsbBuffer) { einkDisplay.copyGrayscaleLsbBuffers(lsbBuffer); }
void HalDisplay::copyGrayscaleMsbBuffers(const uint8_t* msbBuffer) { einkDisplay.copyGrayscaleMsbBuffers(msbBuffer); } void HalDisplay::copyGrayscaleMsbBuffers(const uint8_t* msbBuffer) { einkDisplay.copyGrayscaleMsbBuffers(msbBuffer); }
+13
View File
@@ -47,6 +47,19 @@ class HalDisplay {
// Access to frame buffer // Access to frame buffer
uint8_t* getFrameBuffer() const; uint8_t* getFrameBuffer() const;
// X3 grayscale preconditioning (OEM "AA-pre-BW(mid)" settle pass), windowed
// to the gray region in physical panel coordinates (no-arg = full frame).
// Call after the BW base frame is displayed and before the grayscale planes
// are written; no-op on X4. See EInkDisplay::preconditionGrayscale.
void preconditionGrayscale();
void preconditionGrayscale(uint16_t x, uint16_t y, uint16_t w, uint16_t h);
// Display the framebuffer as the base frame for a grayscale overlay that
// follows. On X3, HALF fallback first requests a resync to match
// displayBuffer(HALF); FAST fallback keeps the OEM differential base waveform
// ("AA-pre-BW(mid)"). Other panels display normally with `fallback` mode.
void displayGrayscaleBase(RefreshMode fallback = HALF_REFRESH, bool turnOffScreen = false);
void copyGrayscaleBuffers(const uint8_t* lsbBuffer, const uint8_t* msbBuffer); void copyGrayscaleBuffers(const uint8_t* lsbBuffer, const uint8_t* msbBuffer);
void copyGrayscaleLsbBuffers(const uint8_t* lsbBuffer); void copyGrayscaleLsbBuffers(const uint8_t* lsbBuffer);
void copyGrayscaleMsbBuffers(const uint8_t* msbBuffer); void copyGrayscaleMsbBuffers(const uint8_t* msbBuffer);
+17 -79
View File
@@ -1,6 +1,5 @@
#include <HalGPIO.h> #include <HalGPIO.h>
#include <Logging.h> #include <Logging.h>
#include <PowerManager.h>
#include <Preferences.h> #include <Preferences.h>
#include <SPI.h> #include <SPI.h>
#include <Wire.h> #include <Wire.h>
@@ -193,44 +192,14 @@ HalGPIO::DeviceType detectDeviceTypeWithFingerprint() {
void HalGPIO::begin() { void HalGPIO::begin() {
inputMgr.begin(); inputMgr.begin();
#if FREEINK_MCU_C3
// Claim the shared SPI bus with the X4/X3 display+SD pins. These EPD_* pin
// macros are hardcoded C3/Xteink values, so this pre-claim is only valid on the
// C3 family. On other boards (M5Paper's IT8951, Sticky's SSD1677, ...) the SDK
// driver and SDCardManager bring up SPI from BoardConfig::ACTIVE pins; pre-
// claiming here would stick (SPIClass::begin early-returns once the bus is
// started) and leave the display/SD on the wrong pins.
SPI.begin(EPD_SCLK, SPI_MISO, EPD_MOSI, EPD_CS); SPI.begin(EPD_SCLK, SPI_MISO, EPD_MOSI, EPD_CS);
#endif
#if FREEINK_MCU_C3
_deviceType = detectDeviceTypeWithFingerprint(); _deviceType = detectDeviceTypeWithFingerprint();
// Sync the runtime board profile to the detected device NOW, before any I2C
// consumer begins. powerManager/clock/tilt begin() run immediately after this
// in setup() and rely on BoardConfig::ACTIVE: HalPowerManager only calls
// Wire.begin() when the active profile has an I2C gauge (gaugeAddr != 0), and
// the X3 clock/tilt raw-Wire paths assume that begin happened. The dual X3+X4
// binary boots as X4 (gaugeAddr 0), so without this the X4 profile stays active
// through those begins, Wire is never (re)initialised after the detection probe
// end()s it, and every X3 read fails with lock==NULL ("could not acquire lock"
// / "NULL TX buffer pointer"). FreeInkDisplay also calls selectDevice() later,
// but that is after the I2C consumers — too late. selectDevice() is idempotent.
BoardConfig::selectDevice(deviceIsX3() ? BoardConfig::Board::XteinkX3 : BoardConfig::Board::XteinkX4);
if (deviceIsX4()) { if (deviceIsX4()) {
pinMode(BAT_GPIO0, INPUT); pinMode(BAT_GPIO0, INPUT);
pinMode(UART0_RXD, INPUT); pinMode(UART0_RXD, INPUT);
} }
#else
// Non-C3 boards (S3/ESP32) are single-device builds; their pins, panel, and
// battery backend all come from BoardConfig::ACTIVE. The X3/X4 fingerprint probe
// targets Xteink C3 hardware and drives Wire on X3_I2C_SDA/SCL (GPIO20/0) — which
// collides with this board's own I2C (e.g. Sticky's BQ27220 gauge shares GPIO0)
// and reconfigures strapping pins. Skip it; _deviceType stays X4 ("not X3"),
// the correct non-X3 branch for every deviceIsX3() consumer.
_deviceType = DeviceType::X4;
#endif
} }
void HalGPIO::update() { void HalGPIO::update() {
@@ -256,55 +225,30 @@ unsigned long HalGPIO::getHeldTime() const { return inputMgr.getHeldTime(); }
unsigned long HalGPIO::getPowerButtonHeldTime() const { return inputMgr.getPowerButtonHeldTime(); } unsigned long HalGPIO::getPowerButtonHeldTime() const { return inputMgr.getPowerButtonHeldTime(); }
bool HalGPIO::wasTouchTap(float& nx, float& ny) const { return inputMgr.wasTouchTap(nx, ny); }
bool HalGPIO::wasTouchDown(float& nx, float& ny) const { return inputMgr.wasTouchPressedAt(nx, ny); }
bool HalGPIO::isTouchTapCandidate(float& nx, float& ny, unsigned long& heldMs) const {
return inputMgr.isTouchTapCandidate(nx, ny, heldMs);
}
unsigned long HalGPIO::lastTouchHeldMs() const { return inputMgr.lastTouchHeldMs(); }
bool HalGPIO::wasSwipe(float& nxStart, float& nyStart, float& nxEnd, float& nyEnd) const {
return inputMgr.wasSwipe(nxStart, nyStart, nxEnd, nyEnd);
}
bool HalGPIO::hasTouch() const { return inputMgr.hasTouch(); }
bool HalGPIO::wasTouchActivity() const { return inputMgr.wasTouchActivity(); }
bool HalGPIO::isXteinkDevice() const {
const auto board = BoardConfig::ACTIVE.board;
return board == BoardConfig::Board::XteinkX3 || board == BoardConfig::Board::XteinkX4;
}
void HalGPIO::startDeepSleep() { void HalGPIO::startDeepSleep() {
// Ensure that the power button has been released to avoid immediately turning back on if you're holding it // Ensure that the power button has been released to avoid immediately turning back on if you're holding it
while (inputMgr.isPressed(BTN_POWER)) { while (inputMgr.isPressed(BTN_POWER)) {
delay(50); delay(50);
inputMgr.update(); inputMgr.update();
} }
freeink::PowerManager::armPowerButtonWakeup(); // Arm the wakeup trigger *after* the button is released
freeink::PowerManager::deepSleep(); esp_deep_sleep_enable_gpio_wakeup(1ULL << InputManager::POWER_BUTTON_PIN, ESP_GPIO_WAKEUP_GPIO_LOW);
// Enter Deep Sleep
esp_deep_sleep_start();
} }
void HalGPIO::verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPressAllowed) { void HalGPIO::verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPressAllowed) {
if (BoardConfig::ACTIVE.input.power < 0) {
// No readable power-button input pin: can't verify a hold, so don't sleep.
return;
}
#if defined(FREEINK_DEVICE_M5PAPER) && FREEINK_DEVICE_M5PAPER
// M5Paper: power-on is a hardware latch and the "power button" is the rotary
// push (G38), shared with Confirm. A USB/flash cold boot is indistinguishable
// from an intentional power-on hold here, so skip the X4-style anti-accidental-
// wake check and always boot. G38 still serves as the deep-sleep wake source.
return;
#endif
if (shortPressAllowed) { if (shortPressAllowed) {
// Fast path - no duration check needed // Fast path - no duration check needed
return; return;
} }
// TODO: Intermittent edge case remains: a single tap followed by another single tap
// can still power on the device. Tighten wake debounce/state handling here.
// Calibrate: subtract boot time already elapsed, assuming button held since boot
const uint16_t calibration = millis();
const uint16_t calibratedDuration = (calibration < requiredDurationMs) ? (requiredDurationMs - calibration) : 1;
const auto start = millis(); const auto start = millis();
inputMgr.update(); inputMgr.update();
// inputMgr.isPressed() may take up to ~500ms to return correct state // inputMgr.isPressed() may take up to ~500ms to return correct state
@@ -313,12 +257,11 @@ void HalGPIO::verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPre
inputMgr.update(); inputMgr.update();
} }
if (inputMgr.isPressed(BTN_POWER)) { if (inputMgr.isPressed(BTN_POWER)) {
const auto holdStart = millis();
do { do {
delay(10); delay(10);
inputMgr.update(); inputMgr.update();
} while (inputMgr.isPressed(BTN_POWER) && millis() - holdStart < requiredDurationMs); } while (inputMgr.isPressed(BTN_POWER) && inputMgr.getPowerButtonHeldTime() < calibratedDuration);
if (millis() - holdStart < requiredDurationMs) { if (inputMgr.getPowerButtonHeldTime() < calibratedDuration) {
startDeepSleep(); startDeepSleep();
} }
} else { } else {
@@ -339,10 +282,8 @@ bool HalGPIO::isUsbConnected() const {
} }
return false; return false;
} }
if (BoardConfig::ACTIVE.usbDetect < 0) { // U0RXD/GPIO20 reads HIGH when USB is connected
return false; return digitalRead(UART0_RXD) == HIGH;
}
return digitalRead(BoardConfig::ACTIVE.usbDetect) == HIGH;
} }
HalGPIO::WakeupReason HalGPIO::getWakeupReason() const { HalGPIO::WakeupReason HalGPIO::getWakeupReason() const {
@@ -351,11 +292,8 @@ HalGPIO::WakeupReason HalGPIO::getWakeupReason() const {
const bool usbConnected = isUsbConnected(); const bool usbConnected = isUsbConnected();
if (resetReason == ESP_RST_DEEPSLEEP && if ((wakeupCause == ESP_SLEEP_WAKEUP_UNDEFINED && resetReason == ESP_RST_POWERON && !usbConnected) ||
(wakeupCause == ESP_SLEEP_WAKEUP_GPIO || wakeupCause == ESP_SLEEP_WAKEUP_EXT1)) { (wakeupCause == ESP_SLEEP_WAKEUP_GPIO && resetReason == ESP_RST_DEEPSLEEP && usbConnected)) {
return WakeupReason::PowerButton;
}
if (wakeupCause == ESP_SLEEP_WAKEUP_UNDEFINED && resetReason == ESP_RST_POWERON && !usbConnected) {
return WakeupReason::PowerButton; return WakeupReason::PowerButton;
} }
if (wakeupCause == ESP_SLEEP_WAKEUP_UNDEFINED && resetReason == ESP_RST_UNKNOWN && usbConnected) { if (wakeupCause == ESP_SLEEP_WAKEUP_UNDEFINED && resetReason == ESP_RST_UNKNOWN && usbConnected) {
-33
View File
@@ -59,11 +59,6 @@ class HalGPIO {
inline bool deviceIsX3() const { return _deviceType == DeviceType::X3; } inline bool deviceIsX3() const { return _deviceType == DeviceType::X3; }
inline bool deviceIsX4() const { return _deviceType == DeviceType::X4; } inline bool deviceIsX4() const { return _deviceType == DeviceType::X4; }
// True on the Xteink X3/X4 boards. Unlike deviceIsX3/X4 (which both stay "X4"
// on non-C3 boards), this keys off BoardConfig::ACTIVE.board, so it reliably
// gates Xteink-only features (sunlight fix) and non-Xteink-only ones (touch).
bool isXteinkDevice() const;
// Start button GPIO and setup SPI for screen and SD card // Start button GPIO and setup SPI for screen and SD card
void begin(); void begin();
@@ -77,34 +72,6 @@ class HalGPIO {
unsigned long getHeldTime() const; unsigned long getHeldTime() const;
unsigned long getPowerButtonHeldTime() const; unsigned long getPowerButtonHeldTime() const;
// Touch: one-shot tap with the release position normalized 0..1 in the panel's
// native orientation. Returns false on non-touch devices. (Reusable gesture
// primitive; see MappedInputManager for the top-left = Back mapping.)
bool wasTouchTap(float& nx, float& ny) const;
// Press-edge of a touch: true on touch-down with the down position normalized
// 0..1 (panel native). For showing the pressed/selected element before release.
bool wasTouchDown(float& nx, float& ny) const;
// True while a touch remains within tap slop; writes touch-down position and held time.
bool isTouchTapCandidate(float& nx, float& ny, unsigned long& heldMs) const;
// Duration (ms) of the last touch contact, latched on release. Valid on the
// release frame (alongside wasTouchTap). For tap-vs-long-press decisions.
unsigned long lastTouchHeldMs() const;
// Swipe (flick) gesture on the release frame: writes the start/end positions
// normalized 0..1 in the panel's native frame (map via GfxRenderer::tapToLogical).
// A swipe also raises wasTouchTap(), so check this first. False on non-touch.
bool wasSwipe(float& nxStart, float& nyStart, float& nxEnd, float& nyEnd) const;
// True if a touch controller is present/active (runtime gate; false on the C3).
bool hasTouch() const;
// True if a touch press or release happened this frame (the touch analogue of
// wasAnyPressed/Released), for resetting idle/sleep timers and CPU frequency.
bool wasTouchActivity() const;
// Setup wake up GPIO and enter deep sleep // Setup wake up GPIO and enter deep sleep
void startDeepSleep(); void startDeepSleep();
+25 -45
View File
@@ -1,7 +1,6 @@
#include "HalPowerManager.h" #include "HalPowerManager.h"
#include <Logging.h> #include <Logging.h>
#include <PowerManager.h>
#include <WiFi.h> #include <WiFi.h>
#include <esp_sleep.h> #include <esp_sleep.h>
@@ -11,32 +10,15 @@
HalPowerManager powerManager; // Singleton instance HalPowerManager powerManager; // Singleton instance
namespace {
// The fuel gauge's I2C controller (Wire or Wire1) per the active board profile.
// On single-bus SoCs (ESP32-C3, SOC_I2C_NUM == 1) Wire1 doesn't exist, so always
// use Wire. On Sticky the gauge is on Wire1 so it doesn't fight the GT911 touch,
// which owns Wire.
TwoWire& gaugeWire() {
#if SOC_I2C_NUM > 1
if (BoardConfig::ACTIVE.batteryGauge.i2cBus == 1) return Wire1;
#endif
return Wire;
}
} // namespace
void HalPowerManager::begin() { void HalPowerManager::begin() {
const auto& gauge = BoardConfig::ACTIVE.batteryGauge; if (gpio.deviceIsX3()) {
if (gauge.gaugeAddr != 0) { // X3 uses an I2C fuel gauge for battery monitoring.
// Board has an I2C fuel gauge (X3, LilyGo, Sticky, ...). Pins/freq come from // I2C init must come AFTER gpio.begin() so early hardware detection/probes are finished.
// the active board profile, not hardcoded X3 values. I2C init must come AFTER Wire.begin(X3_I2C_SDA, X3_I2C_SCL, X3_I2C_FREQ);
// gpio.begin() so early hardware detection/probes are finished. Wire.setTimeOut(4);
gaugeWire().begin(gauge.i2cSda, gauge.i2cScl, gauge.i2cHz);
gaugeWire().setTimeOut(4);
_batteryUseI2C = true; _batteryUseI2C = true;
} else if (BoardConfig::ACTIVE.batteryAdc >= 0) { } else {
// ADC-sensed board (X4: GPIO0, M5Paper: GPIO35). Skip when the profile leaves pinMode(BAT_GPIO0, INPUT);
// batteryAdc unassigned (PIN_UNASSIGNED) — pinMode(255) faults the GPIO mux.
pinMode(BoardConfig::ACTIVE.batteryAdc, INPUT);
} }
normalFreq = getCpuFrequencyMhz(); normalFreq = getCpuFrequencyMhz();
modeMutex = xSemaphoreCreateMutex(); modeMutex = xSemaphoreCreateMutex();
@@ -94,19 +76,22 @@ void HalPowerManager::startDeepSleep(HalGPIO& gpio) const {
#endif #endif
// Pre-sleep routines from the original firmware // Pre-sleep routines from the original firmware
#if !SOC_PM_SUPPORT_EXT1_WAKEUP // RISC-V (C3 / X4)
// GPIO13 is connected to battery latch MOSFET, we need to make sure it's low during sleep // GPIO13 is connected to battery latch MOSFET, we need to make sure it's low during sleep
// Note that this means the MCU will be completely powered off during sleep, including RTC // Note that this means the MCU will be completely powered off during sleep, including RTC
// (X4-specific: on classic ESP32/M5Paper GPIO13 is SD MISO, so this is skipped.)
constexpr gpio_num_t GPIO_SPIWP = GPIO_NUM_13; constexpr gpio_num_t GPIO_SPIWP = GPIO_NUM_13;
gpio_set_direction(GPIO_SPIWP, GPIO_MODE_OUTPUT); gpio_set_direction(GPIO_SPIWP, GPIO_MODE_OUTPUT);
gpio_set_level(GPIO_SPIWP, 0); gpio_set_level(GPIO_SPIWP, 0);
esp_sleep_config_gpio_isolate(); esp_sleep_config_gpio_isolate();
gpio_deep_sleep_hold_en(); gpio_deep_sleep_hold_en();
gpio_hold_en(GPIO_SPIWP); gpio_hold_en(GPIO_SPIWP);
#endif pinMode(InputManager::POWER_BUTTON_PIN, INPUT_PULLUP);
freeink::PowerManager::armPowerButtonWakeup(); // Arm the wakeup trigger *after* the button is released
freeink::PowerManager::deepSleep(); // Note: this is only useful for waking up on USB power. On battery, the MCU will be completely powered off, so the
// power button is hard-wired to briefly provide power to the MCU, waking it up regardless of the wakeup source
// configuration
esp_deep_sleep_enable_gpio_wakeup(1ULL << InputManager::POWER_BUTTON_PIN, ESP_GPIO_WAKEUP_GPIO_LOW);
// Enter Deep Sleep
esp_deep_sleep_start();
} }
uint16_t HalPowerManager::getBatteryPercentage() const { uint16_t HalPowerManager::getBatteryPercentage() const {
@@ -116,32 +101,27 @@ uint16_t HalPowerManager::getBatteryPercentage() const {
return _batteryCachedPercent; return _batteryCachedPercent;
} }
// Read SOC directly from the I2C fuel gauge (16-bit LE register). Gauge // Read SOC directly from I2C fuel gauge (16-bit LE register).
// address comes from the active board profile (all current gauges are // On I2C error, keep last known value to avoid UI jitter/slowdowns.
// BQ27220-class, SOC at 0x2C). On I2C error, keep last known value to avoid Wire.beginTransmission(I2C_ADDR_BQ27220);
// UI jitter/slowdowns. Wire.write(BQ27220_SOC_REG);
const uint8_t gaugeAddr = BoardConfig::ACTIVE.batteryGauge.gaugeAddr; if (Wire.endTransmission(false) != 0) {
TwoWire& w = gaugeWire();
w.beginTransmission(gaugeAddr);
w.write(BQ27220_SOC_REG);
if (w.endTransmission(false) != 0) {
_batteryLastPollMs = now; _batteryLastPollMs = now;
return _batteryCachedPercent; return _batteryCachedPercent;
} }
w.requestFrom(gaugeAddr, (uint8_t)2); Wire.requestFrom(I2C_ADDR_BQ27220, (uint8_t)2);
if (w.available() < 2) { if (Wire.available() < 2) {
_batteryLastPollMs = now; _batteryLastPollMs = now;
return _batteryCachedPercent; return _batteryCachedPercent;
} }
const uint8_t lo = w.read(); const uint8_t lo = Wire.read();
const uint8_t hi = w.read(); const uint8_t hi = Wire.read();
const uint16_t soc = (hi << 8) | lo; const uint16_t soc = (hi << 8) | lo;
_batteryCachedPercent = soc > 100 ? 100 : soc; _batteryCachedPercent = soc > 100 ? 100 : soc;
_batteryLastPollMs = now; _batteryLastPollMs = now;
return _batteryCachedPercent; return _batteryCachedPercent;
} }
// ADC pin from the active profile (X4 GPIO0 / M5Paper GPIO35); default 2:1 divider. static const BatteryMonitor battery = BatteryMonitor(BAT_GPIO0);
static const BatteryMonitor battery = BatteryMonitor(BoardConfig::ACTIVE.batteryAdc);
// smooth the battery %. // smooth the battery %.
if (_batteryCachedPercent == 0) { if (_batteryCachedPercent == 0) {
+1 -10
View File
@@ -28,16 +28,7 @@ class HalPowerManager {
SemaphoreHandle_t modeMutex = nullptr; // Protect access to currentLockMode SemaphoreHandle_t modeMutex = nullptr; // Protect access to currentLockMode
public: public:
// On PSRAM boards (classic ESP32 / M5Paper) the APB clock follows the CPU below static constexpr int LOW_POWER_FREQ = 10; // MHz
// 80 MHz, and APB clocks both the SD SPI bus and the 80 MHz PSRAM (which holds
// the framebuffer). Dropping to 10 MHz breaks SD writes and PSRAM, so floor the
// low-power CPU at 80 MHz (APB stays pinned at 80 for CPU 80/160/240, so power
// still drops from the 240 MHz default while SD/PSRAM stay stable).
#if defined(BOARD_HAS_PSRAM)
static constexpr int LOW_POWER_FREQ = 80; // MHz (APB-safe floor for PSRAM/SD)
#else
static constexpr int LOW_POWER_FREQ = 10; // MHz
#endif
static constexpr unsigned long IDLE_POWER_SAVING_MS = 3000; // ms static constexpr unsigned long IDLE_POWER_SAVING_MS = 3000; // ms
static constexpr unsigned long BATTERY_POLL_MS = 1500; // ms static constexpr unsigned long BATTERY_POLL_MS = 1500; // ms
-8
View File
@@ -38,13 +38,6 @@ void IRAM_ATTR __wrap_panic_print_backtrace(const void* frame, int core) {
__real_panic_print_backtrace(frame, core); __real_panic_print_backtrace(frame, core);
return; return;
} }
#if !__riscv
// RvExcFrame and the flat SP scan below are RISC-V-only (C3). On Xtensa
// (classic ESP32 / S3) the exception frame is XtExcFrame with windowed-register
// unwinding, so fall back to the default backtrace.
__real_panic_print_backtrace(frame, core);
return;
#else
for (size_t i = 0; i < MAX_PANIC_STACK_DEPTH; i++) { for (size_t i = 0; i < MAX_PANIC_STACK_DEPTH; i++) {
panicStack[i].sp = 0; panicStack[i].sp = 0;
} }
@@ -72,7 +65,6 @@ void IRAM_ATTR __wrap_panic_print_backtrace(const void* frame, int core) {
} }
__real_panic_print_backtrace(frame, core); __real_panic_print_backtrace(frame, core);
#endif // __riscv
} }
} }
+1 -36
View File
@@ -26,15 +26,6 @@ bool HalTiltSensor::readReg(uint8_t reg, uint8_t* val) const {
} }
bool HalTiltSensor::readGyro(float& gx, float& gy, float& gz) const { bool HalTiltSensor::readGyro(float& gx, float& gy, float& gz) const {
if (_backend == Backend::SdkImu) {
Imu::Sample sample;
if (!_sdkImu.read(sample)) return false;
gx = sample.gx;
gy = sample.gy;
gz = sample.gz;
return true;
}
Wire.beginTransmission(_i2cAddr); Wire.beginTransmission(_i2cAddr);
Wire.write(REG_GX_L); // Start reading at Gyro X Low Wire.write(REG_GX_L); // Start reading at Gyro X Low
if (Wire.endTransmission(false) != 0) { if (Wire.endTransmission(false) != 0) {
@@ -61,22 +52,11 @@ bool HalTiltSensor::readGyro(float& gx, float& gy, float& gz) const {
} }
void HalTiltSensor::begin() { void HalTiltSensor::begin() {
_backend = Backend::None;
if (!gpio.deviceIsX3()) { if (!gpio.deviceIsX3()) {
_available = _sdkImu.begin(); _available = false;
if (!_available) {
LOG_ERR("GYR", "SDK IMU not found");
return;
}
_backend = Backend::SdkImu;
_initMs = millis();
_lastPollMs = millis();
LOG_INF("GYR", "SDK IMU initialized");
return; return;
} }
_backend = Backend::Qmi8658;
// Try primary address, then alternate // Try primary address, then alternate
uint8_t whoami = 0; uint8_t whoami = 0;
_i2cAddr = I2C_ADDR_QMI8658; _i2cAddr = I2C_ADDR_QMI8658;
@@ -109,14 +89,6 @@ bool HalTiltSensor::wake() {
return false; return false;
} }
if (_backend == Backend::SdkImu) {
_lastPollMs = millis();
_lastTiltMs = millis();
_wakeMs = millis();
_isAwake = true;
return true;
}
// Wait for init to complete before waking // Wait for init to complete before waking
if ((millis() - _initMs) < SLEEP_STABILIZE_MS) { if ((millis() - _initMs) < SLEEP_STABILIZE_MS) {
return false; return false;
@@ -139,13 +111,6 @@ bool HalTiltSensor::deepSleep() {
return false; return false;
} }
if (_backend == Backend::SdkImu) {
clearPendingEvents();
_inTilt = false;
_isAwake = false;
return true;
}
if ((millis() - _wakeMs) < SLEEP_STABILIZE_MS) { if ((millis() - _wakeMs) < SLEEP_STABILIZE_MS) {
return false; return false;
} }
-5
View File
@@ -1,7 +1,6 @@
#pragma once #pragma once
#include <Arduino.h> #include <Arduino.h>
#include <Imu.h>
#include <Wire.h> #include <Wire.h>
#include "HalGPIO.h" #include "HalGPIO.h"
@@ -19,12 +18,8 @@ class HalTiltSensor;
extern HalTiltSensor halTiltSensor; // Singleton extern HalTiltSensor halTiltSensor; // Singleton
class HalTiltSensor { class HalTiltSensor {
enum class Backend : uint8_t { None, Qmi8658, SdkImu };
bool _available = false; bool _available = false;
Backend _backend = Backend::None;
uint8_t _i2cAddr = 0; uint8_t _i2cAddr = 0;
mutable Imu _sdkImu;
// Tilt gesture state machine // Tilt gesture state machine
bool _tiltForwardEvent = false; // Consumed by wasTiltedForward() bool _tiltForwardEvent = false; // Consumed by wasTiltedForward()
+11 -79
View File
@@ -4,7 +4,7 @@ build_cache_dir = .cache
extra_configs = platformio.local.ini extra_configs = platformio.local.ini
[crosspoint] [crosspoint]
version = 1.3.0 version = 1.4.1
[base] [base]
platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.37/platform-espressif32.zip platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.37/platform-espressif32.zip
@@ -35,6 +35,8 @@ build_flags =
# Increase PNG scanline buffer to support up to 2048px wide images # Increase PNG scanline buffer to support up to 2048px wide images
# Default is (320*4+1)*2=2562, we need more for larger images # Default is (320*4+1)*2=2562, we need more for larger images
-DPNG_MAX_BUFFERED_PIXELS=16416 -DPNG_MAX_BUFFERED_PIXELS=16416
-DFREEINK_DEVICE_X4=1
-DFREEINK_DEVICE_X3=1
-Wno-bidi-chars -Wno-bidi-chars
-Wl,--wrap=panic_print_backtrace,--wrap=panic_abort,--wrap=bootloader_common_check_efuse_blk_validity -Wl,--wrap=panic_print_backtrace,--wrap=panic_abort,--wrap=bootloader_common_check_efuse_blk_validity
-fno-exceptions -fno-exceptions
@@ -55,10 +57,7 @@ extra_scripts =
pre:scripts/patch_jpegdec.py pre:scripts/patch_jpegdec.py
post:scripts/register_unit_tests_target.py post:scripts/register_unit_tests_target.py
; Libraries — FreeInk SDK (git submodule at ./freeink-sdk). The left-hand names ; Libraries
; are the include paths the firmware already uses (<EInkDisplay.h>, etc.); FreeInk's
; compat shim preserves them. BoardConfig + PowerManager are FreeInk-only and
; required (device profiles + the SoC-correct deep-sleep wakeup the HAL relies on).
lib_deps = lib_deps =
BatteryMonitor=symlink://freeink-sdk/libs/hardware/BatteryMonitor BatteryMonitor=symlink://freeink-sdk/libs/hardware/BatteryMonitor
InputManager=symlink://freeink-sdk/libs/hardware/InputManager InputManager=symlink://freeink-sdk/libs/hardware/InputManager
@@ -66,8 +65,6 @@ lib_deps =
SDCardManager=symlink://freeink-sdk/libs/hardware/SDCardManager SDCardManager=symlink://freeink-sdk/libs/hardware/SDCardManager
BoardConfig=symlink://freeink-sdk/libs/hardware/BoardConfig BoardConfig=symlink://freeink-sdk/libs/hardware/BoardConfig
PowerManager=symlink://freeink-sdk/libs/hardware/PowerManager PowerManager=symlink://freeink-sdk/libs/hardware/PowerManager
Rtc=symlink://freeink-sdk/libs/hardware/Rtc
Imu=symlink://freeink-sdk/libs/hardware/Imu
FreeInkUI=symlink://freeink-sdk/libs/ui/FreeInkUI FreeInkUI=symlink://freeink-sdk/libs/ui/FreeInkUI
Icons=symlink://freeink-sdk/libs/assets/Icons Icons=symlink://freeink-sdk/libs/assets/Icons
bblanchon/ArduinoJson @ 7.4.2 bblanchon/ArduinoJson @ 7.4.2
@@ -76,100 +73,35 @@ lib_deps =
https://github.com/bitbank2/JPEGDEC.git#86282979224c8a32fd51e091ed5a35b0c699a52b https://github.com/bitbank2/JPEGDEC.git#86282979224c8a32fd51e091ed5a35b0c699a52b
links2004/WebSockets @ 2.7.3 links2004/WebSockets @ 2.7.3
; ESP32-C3 device set: X3 + X4 compiled into one binary, runtime-selected after [env:default]
; the I2C fingerprint. FreeInk requires an explicit device selection, so the C3
; envs extend this instead of [base] directly. (M5Paper is a different MCU family
; and selects its own device below.)
[c3]
extends = base extends = base
build_flags = build_flags =
${base.build_flags} ${base.build_flags}
-DFREEINK_DEVICE_X3=1
-DFREEINK_DEVICE_X4=1
[env:default]
extends = c3
build_flags =
${c3.build_flags}
; CROSSPOINT_VERSION is set by scripts/git_branch.py (includes branch + short SHA) ; CROSSPOINT_VERSION is set by scripts/git_branch.py (includes branch + short SHA)
-DENABLE_SERIAL_LOG -DENABLE_SERIAL_LOG
-DLOG_LEVEL=2 ; Set log level to debug for development builds -DLOG_LEVEL=2 ; Set log level to debug for development builds
[env:gh_release] [env:gh_release]
extends = c3 extends = base
build_flags = build_flags =
${c3.build_flags} ${base.build_flags}
-DCROSSPOINT_VERSION=\"${crosspoint.version}\" -DCROSSPOINT_VERSION=\"${crosspoint.version}\"
-DENABLE_SERIAL_LOG -DENABLE_SERIAL_LOG
-DLOG_LEVEL=1 ; Set log level to info for release builds -DLOG_LEVEL=1 ; Set log level to info for release builds
[env:gh_release_rc] [env:gh_release_rc]
extends = c3 extends = base
build_flags = build_flags =
${c3.build_flags} ${base.build_flags}
-DCROSSPOINT_VERSION=\"${crosspoint.version}-rc+${sysenv.CROSSPOINT_RC_HASH}\" -DCROSSPOINT_VERSION=\"${crosspoint.version}-rc+${sysenv.CROSSPOINT_RC_HASH}\"
-DENABLE_SERIAL_LOG -DENABLE_SERIAL_LOG
-DLOG_LEVEL=1 ; Set log level to info for release candidate builds -DLOG_LEVEL=1 ; Set log level to info for release candidate builds
[env:slim] [env:slim]
extends = c3 extends = base
build_flags = build_flags =
${c3.build_flags} ${base.build_flags}
-DCROSSPOINT_VERSION=\"${crosspoint.version}-slim\" -DCROSSPOINT_VERSION=\"${crosspoint.version}-slim\"
; serial output is disabled in slim builds to save space ; serial output is disabled in slim builds to save space
-UENABLE_SERIAL_LOG -UENABLE_SERIAL_LOG
; --- LilyGo T5 S3 (ESP32-S3 N16R8, 4.7" ED047TC1 / raw-parallel EPD) ---------
; Uses FreeInk's LilyGo board-support library for the PCA9535/TPS65185 display
; power hooks and expander button.
; pio run -e lilygo_t5s3 -t upload --upload-port /dev/tty.usbmodemXXXX
[env:lilygo_t5s3]
extends = base
board = esp32-s3-devkitc1-n16r8
board_build.mcu = esp32s3
board_build.flash_mode = qio
board_build.arduino.memory_type = qio_opi
build_flags =
${base.build_flags}
-DBOARD_HAS_PSRAM
-DFREEINK_DEVICE_LILYGO=1
-DCROSSPOINT_VERSION=\"${crosspoint.version}-lilygo_t5s3\"
-DCROSSPOINT_SHOW_BUTTON_HINTS=0
-DENABLE_SERIAL_LOG
-DLOG_LEVEL=2
-DTOUCH_PROBE_DEBUG=1
lib_deps =
${base.lib_deps}
BoardT5S3=symlink://freeink-sdk/libs/hardware/BoardT5S3
m5stack/M5GFX @ 0.2.20
; --- M5Paper v1.1 (classic ESP32-D0WDQ6, 4.7" 540x960 / IT8951E) -------------
; Different MCU family than the C3 base: override board/mcu/flash, disable the
; C3-only native-USB CDC (logs over UART0), and select the M5Paper device.
; pio run -e m5paper_v11 -t upload --upload-port /dev/tty.usbserial-XXXX
[env:m5paper_v11]
extends = base
board = esp32dev
board_build.mcu = esp32
board_build.flash_mode = qio
; CP2104 bridge: 460800 is ~4x the 115200 fallback and reliable; drop if a flash
; stalls. (921600 usually works too.)
upload_speed = 460800
build_flags =
${base.build_flags}
-UARDUINO_USB_MODE
-UARDUINO_USB_CDC_ON_BOOT
-DBOARD_HAS_PSRAM
-DFREEINK_DEVICE_M5PAPER=1
; git_branch.py only injects CROSSPOINT_VERSION for the default env; set it here.
-DCROSSPOINT_VERSION=\"${crosspoint.version}-m5paper_v11\"
-DENABLE_SERIAL_LOG
-DLOG_LEVEL=2
; Touch + rotary: no physical button row, so hide on-screen button hints.
-DCROSSPOINT_SHOW_BUTTON_HINTS=0
; Archive-order workarounds for the classic-ESP32 link (see freeink-sdk
; platformio.crosspoint.sample.ini): force Arduino startup + the I2C HAL members.
-Wl,.pio/build/m5paper_v11/FrameworkArduino/main.cpp.o
-Wl,-u,i2cInit
-Wl,-u,i2cSlaveInit
-26
View File
@@ -1,26 +0,0 @@
#!/usr/bin/env bash
# Regenerate src/components/icons/generated_icons.h from icons.manifest, using the
# FreeInk SDK icon generator and its vendored Lucide submodule. generated_icons.h is
# a committed build product of these inputs — re-run this after editing the manifest.
#
# Requires: rsvg-convert (librsvg) + Pillow, and the Lucide submodule fetched
# (git submodule update --init in the SDK).
set -euo pipefail
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
SDK="$ROOT/freeink-sdk"
SVGDIR="$SDK/libs/assets/Icons/lucide/icons"
if [ ! -d "$SVGDIR" ]; then
echo "Lucide SVGs not found at $SVGDIR" >&2
echo "Fetch the submodule: git -C \"$SDK\" submodule update --init libs/assets/Icons/lucide" >&2
exit 1
fi
python3 "$SDK/libs/assets/Icons/tools/gen_icons.py" \
--manifest "$ROOT/src/components/icons/icons.manifest" \
--svgdir "$SVGDIR" \
--sizes 24,32,40,48 \
--out "$ROOT/src/components/icons/generated_icons.h"
echo "Regenerated src/components/icons/generated_icons.h"
+117
View File
@@ -0,0 +1,117 @@
#!/usr/bin/env python3
"""Export compiled 1-bit UI icon headers as BMP assets for SD themes."""
import argparse
import re
import struct
from pathlib import Path
ICON_HEADERS = [
"book.h",
"book24.h",
"bookmark.h",
"cover.h",
"file24.h",
"folder.h",
"folder24.h",
"hotspot.h",
"image24.h",
"library.h",
"recent.h",
"settings2.h",
"text24.h",
"transfer.h",
"wifi.h",
]
def parse_icon_header(path: Path):
text = path.read_text()
size_match = re.search(r"//\s*size:\s*(\d+)x(\d+)", text)
if not size_match:
raise ValueError(f"missing size comment in {path}")
width = int(size_match.group(1))
height = int(size_match.group(2))
bitmap_match = re.search(r"static\s+const\s+uint8_t\s+\w+\s*\[\]\s*=\s*\{(?P<body>.*?)\};", text, re.DOTALL)
if not bitmap_match:
raise ValueError(f"missing bitmap data in {path}")
bitmap_body = bitmap_match.group("body")
values = [int(m.group(1), 16) for m in re.finditer(r"0x([0-9A-Fa-f]{2})", bitmap_body)]
expected = ((width + 7) // 8) * height
if len(values) != expected:
raise ValueError(f"{path}: expected {expected} bytes, found {len(values)}")
return width, height, bytes(values)
def get_bit(bitmap: bytes, width: int, x: int, y: int) -> int:
stride = (width + 7) // 8
return (bitmap[y * stride + x // 8] >> (7 - (x % 8))) & 1
def set_bit(buf: bytearray, width: int, x: int, y: int, value: int):
stride = (width + 7) // 8
if value:
buf[y * stride + x // 8] |= 1 << (7 - (x % 8))
def rotate_1bit_cw(width: int, height: int, bitmap: bytes):
rotated_width = height
rotated_height = width
rotated = bytearray(((rotated_width + 7) // 8) * rotated_height)
for y in range(height):
for x in range(width):
set_bit(rotated, rotated_width, height - 1 - y, x, get_bit(bitmap, width, x, y))
return rotated_width, rotated_height, bytes(rotated)
def write_1bit_bmp(path: Path, width: int, height: int, bitmap: bytes):
src_stride = (width + 7) // 8
dst_stride = ((width + 31) // 32) * 4
pixel_bytes = dst_stride * height
pixel_offset = 14 + 40 + 8
file_size = pixel_offset + pixel_bytes
path.parent.mkdir(parents=True, exist_ok=True)
with path.open("wb") as out:
# BITMAPFILEHEADER
out.write(b"BM")
out.write(struct.pack("<IHHI", file_size, 0, 0, pixel_offset))
# BITMAPINFOHEADER. Negative height stores rows top-down.
out.write(struct.pack("<IiiHHIIiiII", 40, width, -height, 1, 1, 0, pixel_bytes, 0, 0, 2, 0))
# Palette index 0 = black, index 1 = white. Existing icon arrays use 1s
# for white/transparent background and 0s for ink.
out.write(bytes([0, 0, 0, 0, 255, 255, 255, 0]))
for y in range(height):
row = bitmap[y * src_stride : (y + 1) * src_stride]
out.write(row)
out.write(b"\x00" * (dst_stride - src_stride))
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--icons", default="src/components/icons")
parser.add_argument("--themes", default="../crosspoint-tools/public/themes")
args = parser.parse_args()
icon_root = Path(args.icons)
theme_root = Path(args.themes)
parsed = []
for header in ICON_HEADERS:
icon_path = icon_root / header
width, height, data = parse_icon_header(icon_path)
width, height, data = rotate_1bit_cw(width, height, data)
parsed.append((icon_path.stem, width, height, data))
for theme_dir in sorted(theme_root.iterdir()):
if not theme_dir.is_dir() or not (theme_dir / "theme.json").exists():
continue
for name, width, height, data in parsed:
write_1bit_bmp(theme_dir / "icons" / f"{name}.bmp", width, height, data)
if __name__ == "__main__":
main()
+66
View File
@@ -0,0 +1,66 @@
#!/usr/bin/env python3
"""Generate a themes.json manifest from SD theme package folders."""
import argparse
import json
import zlib
from pathlib import Path
def safe_theme_dirs(root: Path):
for child in sorted(root.iterdir()):
if not child.is_dir() or child.name.startswith(".") or child.name.startswith("_"):
continue
theme_json = child / "theme.json"
if theme_json.exists():
yield child
def build_manifest(root: Path, base_url: str):
themes = []
for theme_dir in safe_theme_dirs(root):
theme_doc = json.loads((theme_dir / "theme.json").read_text(encoding="utf-8"))
files = []
total = 0
for file_path in sorted(p for p in theme_dir.rglob("*") if p.is_file()):
rel = file_path.relative_to(theme_dir).as_posix()
data = file_path.read_bytes()
total += len(data)
files.append(
{
"path": rel,
"url": f"{theme_dir.name}/{rel}",
"size": len(data),
"crc32": zlib.crc32(data) & 0xFFFFFFFF,
}
)
themes.append(
{
"id": theme_doc["id"],
"name": theme_doc.get("name", theme_doc["id"]),
"version": theme_doc.get("version", 1),
"description": theme_doc.get("description", ""),
"files": files,
"totalSize": total,
}
)
return {"version": 1, "baseUrl": base_url, "themes": themes}
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--root", default="../crosspoint-tools/public/themes")
parser.add_argument("--base-url", required=True)
parser.add_argument("--output", default="../crosspoint-tools/public/themes/themes.json")
args = parser.parse_args()
manifest = build_manifest(Path(args.root), args.base_url)
output = Path(args.output)
output.parent.mkdir(parents=True, exist_ok=True)
output.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
if __name__ == "__main__":
main()
+8 -7
View File
@@ -65,6 +65,8 @@ class CrossPointSettings {
XTC_STATUS_BAR_MODE_COUNT XTC_STATUS_BAR_MODE_COUNT
}; };
enum STATUS_BAR_CLOCK_MODE { STATUS_BAR_CLOCK_HIDE = 0, STATUS_BAR_CLOCK_RIGHT = 1, STATUS_BAR_CLOCK_LEFT = 2 };
enum ORIENTATION { enum ORIENTATION {
PORTRAIT = 0, // 480x800 logical coordinates (current default) PORTRAIT = 0, // 480x800 logical coordinates (current default)
LANDSCAPE_CW = 1, // 800x480 logical coordinates, rotated 180° (swap top/bottom) LANDSCAPE_CW = 1, // 800x480 logical coordinates, rotated 180° (swap top/bottom)
@@ -159,7 +161,7 @@ class CrossPointSettings {
}; };
// UI Theme // UI Theme
enum UI_THEME { CLASSIC = 0, LYRA = 1, LYRA_3_COVERS = 2, ROUNDEDRAFF = 3 }; enum UI_THEME { CLASSIC = 0, LYRA = 1, LYRA_3_COVERS = 2, ROUNDEDRAFF = 3, UI_THEME_COUNT = 4 };
// Image rendering in EPUB reader // Image rendering in EPUB reader
enum IMAGE_RENDERING { IMAGES_DISPLAY = 0, IMAGES_PLACEHOLDER = 1, IMAGES_SUPPRESS = 2, IMAGE_RENDERING_COUNT }; enum IMAGE_RENDERING { IMAGES_DISPLAY = 0, IMAGES_PLACEHOLDER = 1, IMAGES_SUPPRESS = 2, IMAGE_RENDERING_COUNT };
@@ -188,7 +190,7 @@ class CrossPointSettings {
uint8_t statusBarBattery = 1; uint8_t statusBarBattery = 1;
uint8_t xtcStatusBarMode = XTC_STATUS_BAR_HIDE; uint8_t xtcStatusBarMode = XTC_STATUS_BAR_HIDE;
// Clock display in status bar (X3 only, requires DS3231 RTC) // Clock display in status bar (X3 only, requires DS3231 RTC)
uint8_t statusBarClock = 0; uint8_t statusBarClock = STATUS_BAR_CLOCK_HIDE;
// Clock UTC offset in quarter-hour steps, biased by 48 so it fits in uint8_t. // Clock UTC offset in quarter-hour steps, biased by 48 so it fits in uint8_t.
// Value 48 = UTC+0, 0 = UTC-12:00, 104 = UTC+14:00. // Value 48 = UTC+0, 0 = UTC-12:00, 104 = UTC+14:00.
// Quarter-hour granularity supports oddball zones like Nepal (+5:45) and Chatham (+12:45). // Quarter-hour granularity supports oddball zones like Nepal (+5:45) and Chatham (+12:45).
@@ -238,15 +240,12 @@ class CrossPointSettings {
// Long-press page turn button behavior // Long-press page turn button behavior
uint8_t longPressButtonBehavior = OFF; uint8_t longPressButtonBehavior = OFF;
// Long-press Confirm function in EPUB reader (cycles through LONG_PRESS_MENU_FUNCTION values). // Long-press Confirm function in EPUB reader (cycles through LONG_PRESS_MENU_FUNCTION values).
// Defaults to Bookmark to preserve the upstream long-press-Confirm-adds-bookmark behavior. // Defaults to Disabled so shortcut-based bookmark toggling remains opt-in.
uint8_t longPressMenuFunction = LP_MENU_BOOKMARK; uint8_t longPressMenuFunction = LP_MENU_DISABLED;
// UI Theme // UI Theme
uint8_t uiTheme = LYRA; uint8_t uiTheme = LYRA;
// Sunlight fading compensation // Sunlight fading compensation
uint8_t fadingFix = 0; uint8_t fadingFix = 0;
// Touch reader controls: tap zones for page back/forward + press-and-hold,
// mirroring the physical buttons. Touch devices only (hidden elsewhere).
uint8_t touchReaderControls = 1;
// Power button return from footnotes (1 = enabled, 0 = disabled) // Power button return from footnotes (1 = enabled, 0 = disabled)
uint8_t pwrBtnFootnoteBack = 1; uint8_t pwrBtnFootnoteBack = 1;
// Use book's embedded CSS styles for EPUB rendering (1 = enabled, 0 = disabled) // Use book's embedded CSS styles for EPUB rendering (1 = enabled, 0 = disabled)
@@ -255,6 +254,8 @@ class CrossPointSettings {
uint8_t focusReadingEnabled = 0; uint8_t focusReadingEnabled = 0;
// SD card font family name (empty = use built-in fontFamily) // SD card font family name (empty = use built-in fontFamily)
char sdFontFamilyName[32] = ""; char sdFontFamilyName[32] = "";
// SD card UI theme id/name (empty = use built-in Lyra)
char sdThemeName[32] = "";
// Show hidden files/directories (starting with '.') in the file browser (0 = hidden, 1 = show) // Show hidden files/directories (starting with '.') in the file browser (0 = hidden, 1 = show)
uint8_t showHiddenFiles = 0; uint8_t showHiddenFiles = 0;
// Remove a book from the Recent Books list when its End-of-Book screen is reached (0 = off, 1 = on) // Remove a book from the Recent Books list when its End-of-Book screen is reached (0 = off, 1 = on)
+19
View File
@@ -144,10 +144,16 @@ bool JsonSettingsIO::saveSettings(const CrossPointSettings& s, const char* path)
doc["frontButtonRight"] = s.frontButtonRight; doc["frontButtonRight"] = s.frontButtonRight;
// Font family — uses dynamic getter/setter in SettingsList so the generic loop skips it. // Font family — uses dynamic getter/setter in SettingsList so the generic loop skips it.
doc["fontFamily"] = s.fontFamily; doc["fontFamily"] = s.fontFamily;
// UI theme — uses dynamic getter/setter in SettingsList so the generic loop skips it.
doc["uiTheme"] = s.uiTheme;
// SD card font family name — not in SettingsList, save manually // SD card font family name — not in SettingsList, save manually
if (s.sdFontFamilyName[0] != '\0') { if (s.sdFontFamilyName[0] != '\0') {
doc["sdFontFamilyName"] = s.sdFontFamilyName; doc["sdFontFamilyName"] = s.sdFontFamilyName;
} }
// SD card UI theme id/name — dynamic setting, save manually.
if (s.sdThemeName[0] != '\0') {
doc["sdThemeName"] = s.sdThemeName;
}
// Language -- managed by LanguageSelectActivity, not in SettingsList. // Language -- managed by LanguageSelectActivity, not in SettingsList.
// Stored as ISO code string ("EN", "DE", ...) for stability across enum reorders. // Stored as ISO code string ("EN", "DE", ...) for stability across enum reorders.
@@ -246,10 +252,17 @@ bool JsonSettingsIO::loadSettings(CrossPointSettings& s, const char* json, bool*
// Font family — uses dynamic getter/setter in SettingsList so the generic loop skips it. // Font family — uses dynamic getter/setter in SettingsList so the generic loop skips it.
const uint8_t storedFontFamily = doc["fontFamily"] | (uint8_t)0; const uint8_t storedFontFamily = doc["fontFamily"] | (uint8_t)0;
s.fontFamily = clamp(storedFontFamily, CrossPointSettings::BUILTIN_FONT_COUNT, 0); s.fontFamily = clamp(storedFontFamily, CrossPointSettings::BUILTIN_FONT_COUNT, 0);
// UI theme — uses dynamic getter/setter in SettingsList so the generic loop skips it.
s.uiTheme = clamp(doc["uiTheme"] | (uint8_t)CrossPointSettings::LYRA, (uint8_t)CrossPointSettings::UI_THEME_COUNT,
(uint8_t)CrossPointSettings::LYRA);
// SD card font family name — not in SettingsList, load manually // SD card font family name — not in SettingsList, load manually
const char* sfn = doc["sdFontFamilyName"] | ""; const char* sfn = doc["sdFontFamilyName"] | "";
strncpy(s.sdFontFamilyName, sfn, sizeof(s.sdFontFamilyName) - 1); strncpy(s.sdFontFamilyName, sfn, sizeof(s.sdFontFamilyName) - 1);
s.sdFontFamilyName[sizeof(s.sdFontFamilyName) - 1] = '\0'; s.sdFontFamilyName[sizeof(s.sdFontFamilyName) - 1] = '\0';
// SD card UI theme id/name — not in SettingsList, load manually.
const char* stn = doc["sdThemeName"] | "";
strncpy(s.sdThemeName, stn, sizeof(s.sdThemeName) - 1);
s.sdThemeName[sizeof(s.sdThemeName) - 1] = '\0';
if (storedFontFamily == CrossPointSettings::LEGACY_OPENDYSLEXIC && s.sdFontFamilyName[0] == '\0') { if (storedFontFamily == CrossPointSettings::LEGACY_OPENDYSLEXIC && s.sdFontFamilyName[0] == '\0') {
s.fontFamily = CrossPointSettings::NOTOSERIF; s.fontFamily = CrossPointSettings::NOTOSERIF;
strncpy(s.sdFontFamilyName, "OpenDyslexic", sizeof(s.sdFontFamilyName) - 1); strncpy(s.sdFontFamilyName, "OpenDyslexic", sizeof(s.sdFontFamilyName) - 1);
@@ -423,6 +436,9 @@ bool JsonSettingsIO::saveBookmarks(const std::vector<BookmarkEntry>& bookmarks,
obj["xpath"] = bookmark.xpath; obj["xpath"] = bookmark.xpath;
obj["percentage"] = bookmark.percentage; obj["percentage"] = bookmark.percentage;
obj["summary"] = bookmark.summary; obj["summary"] = bookmark.summary;
obj["si"] = bookmark.computedSpineIndex;
obj["pc"] = bookmark.computedChapterPageCount;
obj["pp"] = bookmark.computedChapterProgress;
} }
String json; String json;
@@ -447,6 +463,9 @@ bool JsonSettingsIO::loadBookmarks(std::vector<BookmarkEntry>& bookmarks, const
bookmark.xpath = obj["xpath"] | std::string(""); bookmark.xpath = obj["xpath"] | std::string("");
bookmark.percentage = obj["percentage"] | static_cast<float>(0); bookmark.percentage = obj["percentage"] | static_cast<float>(0);
bookmark.summary = obj["summary"] | std::string(""); bookmark.summary = obj["summary"] | std::string("");
bookmark.computedSpineIndex = obj["si"] | static_cast<uint16_t>(0);
bookmark.computedChapterPageCount = obj["pc"] | static_cast<uint16_t>(0);
bookmark.computedChapterProgress = obj["pp"] | static_cast<uint16_t>(0);
} }
LOG_DBG("BKM", "Loaded %zu bookmarks from file", bookmarks.size()); LOG_DBG("BKM", "Loaded %zu bookmarks from file", bookmarks.size());
+3 -187
View File
@@ -1,12 +1,8 @@
#include "MappedInputManager.h" #include "MappedInputManager.h"
#include <FreeInkUI.h>
#include <GfxRenderer.h> #include <GfxRenderer.h>
#include <cstdlib>
#include "CrossPointSettings.h" #include "CrossPointSettings.h"
#include "components/TouchRegistry.h"
bool MappedInputManager::isNavDirectionSwapped() const { bool MappedInputManager::isNavDirectionSwapped() const {
// Key the swap on the orientation the screen is *actually* rendered at, not the persisted reader // Key the swap on the orientation the screen is *actually* rendered at, not the persisted reader
@@ -78,182 +74,9 @@ bool MappedInputManager::mapButton(const Button button, bool (HalGPIO::*fn)(uint
return false; return false;
} }
// Top-left corner fallback, as a fraction of the logical screen. Generous to hit. bool MappedInputManager::wasPressed(const Button button) const { return mapButton(button, &HalGPIO::wasPressed); }
static constexpr float BACK_GESTURE_FRAC_X = 0.22f;
static constexpr float BACK_GESTURE_FRAC_Y = 0.12f;
static constexpr float BOTTOM_EDGE_BACK_GESTURE_FRAC_Y = 0.14f;
static constexpr unsigned long TOUCH_DOWN_SELECT_DELAY_MS = 90;
static constexpr unsigned long TOUCH_HELD_OVERRIDE_WINDOW_MS = 250;
void MappedInputManager::rememberTouchHeldTime() const { bool MappedInputManager::wasReleased(const Button button) const { return mapButton(button, &HalGPIO::wasReleased); }
touchHeldOverrideValid = true;
touchHeldOverrideMs = gpio.lastTouchHeldMs();
touchHeldOverrideAt = millis();
}
bool MappedInputManager::wasBottomEdgeSwipeUp() const {
float nxs = 0.0f, nys = 0.0f, nxe = 0.0f, nye = 0.0f;
if (!gpio.wasSwipe(nxs, nys, nxe, nye)) return false;
int sx = 0, sy = 0, ex = 0, ey = 0;
renderer.tapToLogical(nxs, nys, sx, sy);
renderer.tapToLogical(nxe, nye, ex, ey);
const int screenHeight = renderer.getScreenHeight();
const int bottomEdgeTop = screenHeight - static_cast<int>(screenHeight * BOTTOM_EDGE_BACK_GESTURE_FRAC_Y);
const bool isBackSwipe = sy >= bottomEdgeTop && ey < sy && std::abs(ey - sy) > std::abs(ex - sx);
if (isBackSwipe) rememberTouchHeldTime();
return isBackSwipe;
}
bool MappedInputManager::wasBackGesture() const {
if (wasBottomEdgeSwipeUp()) return true;
float nx = 0.0f, ny = 0.0f;
if (!gpio.wasTouchTap(nx, ny)) return false;
int lx = 0, ly = 0;
renderer.tapToLogical(nx, ny, lx, ly);
// A tap on the theme's header Back target acts as Back.
int id = 0;
if (TouchRegistry::getInstance().hitTest(lx, ly, TouchRegistry::Back, id)) {
rememberTouchHeldTime();
return true;
}
// Else the top-left corner, for screens with no Back target (e.g. the reader).
const bool isTopLeftBack =
lx <= renderer.getScreenWidth() * BACK_GESTURE_FRAC_X && ly <= renderer.getScreenHeight() * BACK_GESTURE_FRAC_Y;
if (isTopLeftBack) rememberTouchHeldTime();
return isTopLeftBack;
}
bool MappedInputManager::wasItemTapped(int& id) const {
float nx = 0.0f, ny = 0.0f;
if (!gpio.wasTouchTap(nx, ny)) return false;
int lx = 0, ly = 0;
renderer.tapToLogical(nx, ny, lx, ly);
const bool hit = TouchRegistry::getInstance().hitTest(lx, ly, TouchRegistry::Item, id);
if (hit) rememberTouchHeldTime();
return hit;
}
bool MappedInputManager::wasItemTouchedDown(int& id) const {
float nx = 0.0f, ny = 0.0f;
unsigned long heldMs = 0;
if (!gpio.isTouchTapCandidate(nx, ny, heldMs)) {
touchSelectTracking = false;
touchSelectEmitted = false;
touchSelectId = -1;
return false;
}
if (!touchSelectTracking) {
float downNx = 0.0f, downNy = 0.0f;
if (!gpio.wasTouchDown(downNx, downNy)) return false;
int lx = 0, ly = 0;
renderer.tapToLogical(downNx, downNy, lx, ly);
int candidateId = -1;
if (!TouchRegistry::getInstance().hitTest(lx, ly, TouchRegistry::Item, candidateId)) {
touchSelectTracking = false;
touchSelectEmitted = false;
touchSelectId = -1;
return false;
}
touchSelectTracking = true;
touchSelectEmitted = false;
touchSelectId = candidateId;
}
if (touchSelectEmitted || heldMs < TOUCH_DOWN_SELECT_DELAY_MS) return false;
touchSelectEmitted = true;
id = touchSelectId;
return true;
}
bool MappedInputManager::wasItemLongPressed(int& id) const {
static constexpr unsigned long TOUCH_LONG_PRESS_MS = 500;
float nx = 0.0f, ny = 0.0f;
if (!gpio.wasTouchTap(nx, ny)) return false; // release frame
if (gpio.lastTouchHeldMs() < TOUCH_LONG_PRESS_MS) return false;
int lx = 0, ly = 0;
renderer.tapToLogical(nx, ny, lx, ly);
const bool hit = TouchRegistry::getInstance().hitTest(lx, ly, TouchRegistry::Item, id);
if (hit) rememberTouchHeldTime();
return hit;
}
bool MappedInputManager::wasTabTapped(int& id) const {
float nx = 0.0f, ny = 0.0f;
if (!gpio.wasTouchTap(nx, ny)) return false;
int lx = 0, ly = 0;
renderer.tapToLogical(nx, ny, lx, ly);
const bool hit = TouchRegistry::getInstance().hitTest(lx, ly, TouchRegistry::Tab, id);
if (hit) rememberTouchHeldTime();
return hit;
}
bool MappedInputManager::wasCoverTapped(int& id) const {
float nx = 0.0f, ny = 0.0f;
if (!gpio.wasTouchTap(nx, ny)) return false;
int lx = 0, ly = 0;
renderer.tapToLogical(nx, ny, lx, ly);
const bool hit = TouchRegistry::getInstance().hitTest(lx, ly, TouchRegistry::Cover, id);
if (hit) rememberTouchHeldTime();
return hit;
}
bool MappedInputManager::wasScreenTapped(int& x, int& y) const {
float nx = 0.0f, ny = 0.0f;
if (!gpio.wasTouchTap(nx, ny)) return false;
renderer.tapToLogical(nx, ny, x, y);
rememberTouchHeldTime();
return true;
}
bool MappedInputManager::wasListScroll(int& index, int count, int pageItems) const {
if (count <= 0) return false;
if (pageItems < 1) pageItems = 1;
if (wasBottomEdgeSwipeUp()) return false;
const SwipeDir swipe = wasSwipe();
if (swipe == SwipeDir::Up) {
return freeink::ui::listPageIndex(index, +1, count, pageItems);
}
if (swipe == SwipeDir::Down) {
return freeink::ui::listPageIndex(index, -1, count, pageItems);
}
return false;
}
MappedInputManager::SwipeDir MappedInputManager::wasSwipe() const {
if (wasBottomEdgeSwipeUp()) return SwipeDir::None;
float nxs = 0.0f, nys = 0.0f, nxe = 0.0f, nye = 0.0f;
if (!gpio.wasSwipe(nxs, nys, nxe, nye)) return SwipeDir::None;
// Map both endpoints into the logical frame so the direction follows what the
// user sees regardless of panel mount/orientation.
int sx = 0, sy = 0, ex = 0, ey = 0;
renderer.tapToLogical(nxs, nys, sx, sy);
renderer.tapToLogical(nxe, nye, ex, ey);
const int dx = ex - sx;
const int dy = ey - sy;
if (std::abs(dx) >= std::abs(dy)) {
return dx < 0 ? SwipeDir::Left : SwipeDir::Right;
}
return dy < 0 ? SwipeDir::Up : SwipeDir::Down;
}
bool MappedInputManager::wasPressed(const Button button) const {
// A top-left tap fires on the release frame; expose it on Back's press edge too
// so menus that act on wasPressed(Back) also respond. Deliberately NOT folded
// into isPressed, so a quick tap never satisfies the readers' long-press-home.
if (button == Button::Back && wasBackGesture()) return true;
return mapButton(button, &HalGPIO::wasPressed);
}
bool MappedInputManager::wasReleased(const Button button) const {
if (button == Button::Back && wasBackGesture()) return true;
return mapButton(button, &HalGPIO::wasReleased);
}
bool MappedInputManager::isPressed(const Button button) const { return mapButton(button, &HalGPIO::isPressed); } bool MappedInputManager::isPressed(const Button button) const { return mapButton(button, &HalGPIO::isPressed); }
@@ -261,14 +84,7 @@ bool MappedInputManager::wasAnyPressed() const { return gpio.wasAnyPressed(); }
bool MappedInputManager::wasAnyReleased() const { return gpio.wasAnyReleased(); } bool MappedInputManager::wasAnyReleased() const { return gpio.wasAnyReleased(); }
unsigned long MappedInputManager::getHeldTime() const { unsigned long MappedInputManager::getHeldTime() const { return gpio.getHeldTime(); }
if (!gpio.wasAnyPressed() && !gpio.wasAnyReleased() && touchHeldOverrideValid &&
millis() - touchHeldOverrideAt <= TOUCH_HELD_OVERRIDE_WINDOW_MS) {
return touchHeldOverrideMs;
}
touchHeldOverrideValid = false;
return gpio.getHeldTime();
}
MappedInputManager::Labels MappedInputManager::mapLabels(const char* back, const char* confirm, const char* previous, MappedInputManager::Labels MappedInputManager::mapLabels(const char* back, const char* confirm, const char* previous,
const char* next) const { const char* next) const {
-37
View File
@@ -7,7 +7,6 @@ class GfxRenderer;
class MappedInputManager { class MappedInputManager {
public: public:
enum class Button { Back, Confirm, Left, Right, Up, Down, Power, PageBack, PageForward, NavNext, NavPrevious }; enum class Button { Back, Confirm, Left, Right, Up, Down, Power, PageBack, PageForward, NavNext, NavPrevious };
enum class SwipeDir { None, Left, Right, Up, Down };
struct Labels { struct Labels {
const char* btn1; const char* btn1;
@@ -22,33 +21,6 @@ class MappedInputManager {
bool wasPressed(Button button) const; bool wasPressed(Button button) const;
bool wasReleased(Button button) const; bool wasReleased(Button button) const;
bool isPressed(Button button) const; bool isPressed(Button button) const;
// Touch "back" gesture: a tap on the theme's header Back target, or in the
// top-left corner, or a swipe up from the visible bottom edge. Folded into
// Back's edges, so every screen gets it for free.
bool wasBackGesture() const;
// True (and writes the id) if a tap this frame hit a TouchRegistry item.
// Activities treat the id as "select + activate". False on non-touch devices.
bool wasItemTapped(int& id) const;
// Stable touch-down candidate: fires once when a touch remains over an item
// briefly without crossing tap slop, so swipes do not show row selection.
bool wasItemTouchedDown(int& id) const;
// Subset of wasItemTapped's releases held past the long-press threshold (check
// this first). Distinguishes tap vs press-and-hold.
bool wasItemLongPressed(int& id) const;
// wasItemTapped for tab-bar tabs (id = tab index) and cover/card targets
// (id = item index). Distinct kinds so a screen with both doesn't confuse them.
bool wasTabTapped(int& id) const;
bool wasCoverTapped(int& id) const;
// True on a touch release anywhere on screen, with logical/oriented coords.
bool wasScreenTapped(int& x, int& y) const;
// Swipe direction in the current logical (oriented) frame, or None. A swipe also
// raises the tap helpers above, so check this first and consume it.
SwipeDir wasSwipe() const;
// Page-scroll a list selection by a vertical swipe (touch nav without buttons):
// swipe up advances down the list, swipe down moves up, by pageItems, clamped to
// [0, count-1]. Updates index and returns true when a vertical swipe occurred, so
// callers can requestUpdate() and return before the tap handlers run.
bool wasListScroll(int& index, int count, int pageItems) const;
bool wasAnyPressed() const; bool wasAnyPressed() const;
bool wasAnyReleased() const; bool wasAnyReleased() const;
unsigned long getHeldTime() const; unsigned long getHeldTime() const;
@@ -72,13 +44,4 @@ class MappedInputManager {
const GfxRenderer& renderer; const GfxRenderer& renderer;
bool mapButton(Button button, bool (HalGPIO::*fn)(uint8_t) const) const; bool mapButton(Button button, bool (HalGPIO::*fn)(uint8_t) const) const;
void rememberTouchHeldTime() const;
bool wasBottomEdgeSwipeUp() const;
mutable bool touchSelectTracking = false;
mutable bool touchSelectEmitted = false;
mutable int touchSelectId = -1;
mutable bool touchHeldOverrideValid = false;
mutable unsigned long touchHeldOverrideMs = 0;
mutable unsigned long touchHeldOverrideAt = 0;
}; };
+75 -30
View File
@@ -1,8 +1,6 @@
#pragma once #pragma once
#include <BoardConfig.h>
#include <HalClock.h> #include <HalClock.h>
#include <HalGPIO.h>
#include <HalTiltSensor.h> #include <HalTiltSensor.h>
#include <I18n.h> #include <I18n.h>
#include <SdCardFontRegistry.h> #include <SdCardFontRegistry.h>
@@ -15,6 +13,7 @@
#include "CrossPointSettings.h" #include "CrossPointSettings.h"
#include "KOReaderCredentialStore.h" #include "KOReaderCredentialStore.h"
#include "activities/settings/SettingsActivity.h" #include "activities/settings/SettingsActivity.h"
#include "components/themes/SdCardThemeRegistry.h"
// Build the font family setting dynamically. When registry is non-null, SD card fonts // Build the font family setting dynamically. When registry is non-null, SD card fonts
// are appended after the built-in fonts. Otherwise only built-in fonts are listed. // are appended after the built-in fonts. Otherwise only built-in fonts are listed.
@@ -92,6 +91,63 @@ inline SettingInfo buildFontFamilySetting(const SdCardFontRegistry* registry) {
return s; return s;
} }
// Build the UI theme setting dynamically. Firmware themes keep their existing
// indexes; SD card themes are appended after them.
inline SettingInfo buildUiThemeSetting(const SdCardThemeRegistry* registry) {
std::vector<std::string> allStringValues;
allStringValues.push_back(I18N.get(StrId::STR_THEME_CLASSIC));
allStringValues.push_back(I18N.get(StrId::STR_THEME_LYRA));
allStringValues.push_back(I18N.get(StrId::STR_THEME_LYRA_EXTENDED));
allStringValues.push_back(I18N.get(StrId::STR_THEME_ROUNDEDRAFF));
std::vector<std::string> sdThemeIds;
if (registry) {
const auto& themes = registry->getThemes();
sdThemeIds.reserve(themes.size());
for (const auto& theme : themes) {
allStringValues.push_back(theme.name);
sdThemeIds.push_back(theme.id);
}
}
SettingInfo s;
s.nameId = StrId::STR_UI_THEME;
s.type = SettingType::ENUM;
s.enumStringValues = std::move(allStringValues);
s.key = "uiTheme";
s.category = StrId::STR_CAT_DISPLAY;
s.valueGetter = [sdThemeIds]() -> uint8_t {
if (SETTINGS.sdThemeName[0] != '\0') {
for (int i = 0; i < static_cast<int>(sdThemeIds.size()); i++) {
if (sdThemeIds[i] == SETTINGS.sdThemeName) {
return static_cast<uint8_t>(CrossPointSettings::UI_THEME_COUNT + i);
}
}
}
return SETTINGS.uiTheme < CrossPointSettings::UI_THEME_COUNT ? SETTINGS.uiTheme : CrossPointSettings::LYRA;
};
s.valueSetter = [sdThemeIds](uint8_t v) {
if (v < CrossPointSettings::UI_THEME_COUNT) {
SETTINGS.uiTheme = v;
SETTINGS.sdThemeName[0] = '\0';
return;
}
SETTINGS.uiTheme = CrossPointSettings::UI_THEME::LYRA;
const int sdIdx = v - CrossPointSettings::UI_THEME_COUNT;
if (sdIdx < static_cast<int>(sdThemeIds.size())) {
strncpy(SETTINGS.sdThemeName, sdThemeIds[sdIdx].c_str(), sizeof(SETTINGS.sdThemeName) - 1);
SETTINGS.sdThemeName[sizeof(SETTINGS.sdThemeName) - 1] = '\0';
} else {
SETTINGS.sdThemeName[0] = '\0';
}
};
return s;
}
// Shared settings list used by both the device settings UI and the web settings API. // Shared settings list used by both the device settings UI and the web settings API.
// Each entry has a key (for JSON API) and category (for grouping). // Each entry has a key (for JSON API) and category (for grouping).
// ACTION-type entries and entries without a key are device-only. // ACTION-type entries and entries without a key are device-only.
@@ -101,7 +157,8 @@ inline SettingInfo buildFontFamilySetting(const SdCardFontRegistry* registry) {
// SdCardFontRegistry is supplied AND has SD card fonts installed, the // SdCardFontRegistry is supplied AND has SD card fonts installed, the
// font-family entry is replaced in a per-call copy with a registry-aware // font-family entry is replaced in a per-call copy with a registry-aware
// version. Callers without SD fonts pay only a vector copy. // version. Callers without SD fonts pay only a vector copy.
inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* registry = nullptr) { inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* fontRegistry = nullptr,
const SdCardThemeRegistry* themeRegistry = nullptr) {
static const std::vector<SettingInfo> baseList = [] { static const std::vector<SettingInfo> baseList = [] {
std::vector<SettingInfo> v = { std::vector<SettingInfo> v = {
// --- Display --- // --- Display ---
@@ -153,9 +210,10 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
StrId::STR_CAT_READER), StrId::STR_CAT_READER),
SettingInfo::Toggle(StrId::STR_HYPHENATION, &CrossPointSettings::hyphenationEnabled, "hyphenationEnabled", SettingInfo::Toggle(StrId::STR_HYPHENATION, &CrossPointSettings::hyphenationEnabled, "hyphenationEnabled",
StrId::STR_CAT_READER), StrId::STR_CAT_READER),
SettingInfo::Enum(StrId::STR_ORIENTATION, &CrossPointSettings::orientation, SettingInfo::Enum(
{StrId::STR_PORTRAIT, StrId::STR_LANDSCAPE_CW, StrId::STR_INVERTED, StrId::STR_LANDSCAPE_CCW}, StrId::STR_ORIENTATION, &CrossPointSettings::orientation,
"orientation", StrId::STR_CAT_READER), {StrId::STR_PORTRAIT, StrId::STR_LANDSCAPE_CW, StrId::STR_ORIENTATION_INVERTED, StrId::STR_LANDSCAPE_CCW},
"orientation", StrId::STR_CAT_READER),
SettingInfo::Toggle(StrId::STR_EXTRA_SPACING, &CrossPointSettings::extraParagraphSpacing, SettingInfo::Toggle(StrId::STR_EXTRA_SPACING, &CrossPointSettings::extraParagraphSpacing,
"extraParagraphSpacing", StrId::STR_CAT_READER), "extraParagraphSpacing", StrId::STR_CAT_READER),
SettingInfo::Toggle(StrId::STR_TEXT_AA, &CrossPointSettings::textAntiAliasing, "textAntiAliasing", SettingInfo::Toggle(StrId::STR_TEXT_AA, &CrossPointSettings::textAntiAliasing, "textAntiAliasing",
@@ -246,8 +304,9 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
StrId::STR_CUSTOMISE_STATUS_BAR), StrId::STR_CUSTOMISE_STATUS_BAR),
// Clock entries (web settings only; device UI uses ClockOffsetActivity for the offset). // Clock entries (web settings only; device UI uses ClockOffsetActivity for the offset).
// Range 0..104 = quarter-hour steps from UTC-12:00 to UTC+14:00, biased by 48. // Range 0..104 = quarter-hour steps from UTC-12:00 to UTC+14:00, biased by 48.
SettingInfo::Toggle(StrId::STR_CLOCK, &CrossPointSettings::statusBarClock, "statusBarClock", SettingInfo::Enum(StrId::STR_CLOCK, &CrossPointSettings::statusBarClock,
StrId::STR_CUSTOMISE_STATUS_BAR), {StrId::STR_HIDE, StrId::STR_DIR_LEFT, StrId::STR_DIR_RIGHT}, "statusBarClock",
StrId::STR_CUSTOMISE_STATUS_BAR),
SettingInfo::Value(StrId::STR_CLOCK_UTC_OFFSET, &CrossPointSettings::clockUtcOffsetQ, {0, 104, 1}, SettingInfo::Value(StrId::STR_CLOCK_UTC_OFFSET, &CrossPointSettings::clockUtcOffsetQ, {0, 104, 1},
"clockUtcOffsetQ", StrId::STR_CUSTOMISE_STATUS_BAR), "clockUtcOffsetQ", StrId::STR_CUSTOMISE_STATUS_BAR),
SettingInfo::Enum(StrId::STR_CLOCK_FORMAT, &CrossPointSettings::clockFormat, SettingInfo::Enum(StrId::STR_CLOCK_FORMAT, &CrossPointSettings::clockFormat,
@@ -258,26 +317,6 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
SettingInfo::Toggle(StrId::STR_CLOCK_SYNCED, &CrossPointSettings::clockHasBeenSynced, "clockHasBeenSynced", SettingInfo::Toggle(StrId::STR_CLOCK_SYNCED, &CrossPointSettings::clockHasBeenSynced, "clockHasBeenSynced",
StrId::STR_CUSTOMISE_STATUS_BAR), StrId::STR_CUSTOMISE_STATUS_BAR),
}; };
// Sunlight fading fix is Xteink-only (transflective panel); other devices get
// the touch reader controls toggle instead. Same gate as the reader runtime.
if (!gpio.isXteinkDevice()) {
v.erase(std::remove_if(v.begin(), v.end(),
[](const SettingInfo& s) { return s.nameId == StrId::STR_SUNLIGHT_FADING_FIX; }),
v.end());
for (auto it = v.begin(); it != v.end(); ++it) {
if (it->nameId == StrId::STR_SIDE_BTN_LAYOUT) {
v.insert(it, SettingInfo::Toggle(StrId::STR_TOUCH_READER_CONTROLS, &CrossPointSettings::touchReaderControls,
"touchReaderControls", StrId::STR_CAT_CONTROLS));
break;
}
}
}
if (BoardConfig::hasTouch()) {
v.erase(std::remove_if(v.begin(), v.end(),
[](const SettingInfo& s) { return s.nameId == StrId::STR_FRONT_BTN_FOLLOW_ORIENTATION; }),
v.end());
}
// Only show tilt page turn setting when the QMI8658 IMU is present (X3) // Only show tilt page turn setting when the QMI8658 IMU is present (X3)
if (halTiltSensor.isAvailable()) { if (halTiltSensor.isAvailable()) {
// Insert after the short power button setting (end of Controls section) // Insert after the short power button setting (end of Controls section)
@@ -294,10 +333,16 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
}(); }();
std::vector<SettingInfo> v = baseList; std::vector<SettingInfo> v = baseList;
if (registry && registry->getFamilyCount() > 0) { {
auto it = std::find_if(v.begin(), v.end(), [](const SettingInfo& s) { return s.nameId == StrId::STR_UI_THEME; });
if (it != v.end()) {
*it = buildUiThemeSetting(themeRegistry);
}
}
if (fontRegistry && fontRegistry->getFamilyCount() > 0) {
auto it = std::find_if(v.begin(), v.end(), [](const SettingInfo& s) { return s.nameId == StrId::STR_FONT_FAMILY; }); auto it = std::find_if(v.begin(), v.end(), [](const SettingInfo& s) { return s.nameId == StrId::STR_FONT_FAMILY; });
if (it != v.end()) { if (it != v.end()) {
*it = buildFontFamilySetting(registry); *it = buildFontFamilySetting(fontRegistry);
} }
} }
return v; return v;
+128
View File
@@ -0,0 +1,128 @@
#include "ThemeInstaller.h"
#include <HalStorage.h>
#include <Logging.h>
#include <cctype>
#include <cstdio>
#include <cstring>
#include "CrossPointSettings.h"
ThemeInstaller::ThemeInstaller(SdCardThemeRegistry& registry) : registry_(registry) {}
bool ThemeInstaller::isValidThemeId(const char* id) {
if (id == nullptr || id[0] == '\0') return false;
if (strstr(id, "..") != nullptr || strchr(id, '/') != nullptr || strchr(id, '\\') != nullptr) return false;
for (const char* p = id; *p; ++p) {
const char c = *p;
if (!std::isalnum(static_cast<unsigned char>(c)) && c != '-' && c != '_') return false;
}
return true;
}
bool ThemeInstaller::isValidRelativePath(const char* path) {
if (path == nullptr || path[0] == '\0' || path[0] == '/') return false;
if (strstr(path, "..") != nullptr || strchr(path, '\\') != nullptr) return false;
bool segmentHasChar = false;
for (const char* p = path; *p; ++p) {
const char c = *p;
if (c == '/') {
if (!segmentHasChar) return false;
segmentHasChar = false;
continue;
}
if (!std::isalnum(static_cast<unsigned char>(c)) && c != '-' && c != '_' && c != '.') return false;
segmentHasChar = true;
}
return segmentHasChar;
}
bool ThemeInstaller::ensureThemeDir(const char* themeId) {
if (!isValidThemeId(themeId)) return false;
const char* root = SdCardThemeRegistry::findThemeRoot(themeId);
if (!root) root = SdCardThemeRegistry::defaultWriteRoot();
if (!Storage.exists(root) && !Storage.mkdir(root)) {
LOG_ERR("THEME", "Failed to create themes dir: %s", root);
return false;
}
char dirPath[180];
const int written = snprintf(dirPath, sizeof(dirPath), "%s/%s", root, themeId);
if (written < 0 || static_cast<size_t>(written) >= sizeof(dirPath)) {
LOG_ERR("THEME", "Theme dir path too long: %s", themeId);
return false;
}
if (!Storage.exists(dirPath) && !Storage.mkdir(dirPath)) {
LOG_ERR("THEME", "Failed to create theme dir: %s", dirPath);
return false;
}
return true;
}
bool ThemeInstaller::ensureParentDirs(const char* fullPath) {
if (!fullPath) return false;
char dir[180];
const int written = snprintf(dir, sizeof(dir), "%s", fullPath);
if (written < 0 || static_cast<size_t>(written) >= sizeof(dir)) {
LOG_ERR("THEME", "Theme parent path too long");
return false;
}
char* slash = strrchr(dir, '/');
if (!slash) return true;
*slash = '\0';
return Storage.ensureDirectoryExists(dir);
}
bool ThemeInstaller::validateThemeFile(const char* path) {
HalFile file;
if (!Storage.openFileForRead("THEME", path, file)) return false;
const bool ok = file.fileSize() > 0;
file.close();
return ok;
}
bool ThemeInstaller::buildThemePath(const char* themeId, const char* relativePath, char* outBuf, size_t outBufSize) {
if (!themeId || !relativePath || !outBuf || outBufSize == 0) return false;
const char* root = SdCardThemeRegistry::findThemeRoot(themeId);
if (!root) root = SdCardThemeRegistry::defaultWriteRoot();
const int written = snprintf(outBuf, outBufSize, "%s/%s/%s", root, themeId, relativePath);
if (written < 0 || static_cast<size_t>(written) >= outBufSize) {
LOG_ERR("THEME", "Theme file path too long: %s/%s", themeId, relativePath);
return false;
}
return true;
}
ThemeInstaller::Error ThemeInstaller::deleteTheme(const char* themeId) {
if (!isValidThemeId(themeId)) return Error::INVALID_THEME_ID;
const char* roots[] = {SdCardThemeRegistry::THEMES_DIR_HIDDEN, SdCardThemeRegistry::THEMES_DIR_VISIBLE};
for (const char* root : roots) {
char dirPath[180];
const int written = snprintf(dirPath, sizeof(dirPath), "%s/%s", root, themeId);
if (written < 0 || static_cast<size_t>(written) >= sizeof(dirPath)) {
LOG_ERR("THEME", "Theme dir path too long: %s", themeId);
return Error::INVALID_THEME_ID;
}
if (!Storage.exists(dirPath)) continue;
if (!Storage.removeDir(dirPath)) {
LOG_ERR("THEME", "Failed to remove theme dir: %s", dirPath);
return Error::SD_WRITE_ERROR;
}
}
if (strcmp(SETTINGS.sdThemeName, themeId) == 0) {
SETTINGS.sdThemeName[0] = '\0';
SETTINGS.uiTheme = CrossPointSettings::LYRA;
SETTINGS.saveToFile();
}
return Error::OK;
}
void ThemeInstaller::refreshRegistry() { registry_.discover(); }
bool ThemeInstaller::isThemeInstalled(const char* themeId) const { return registry_.findTheme(themeId) != nullptr; }
+30
View File
@@ -0,0 +1,30 @@
#pragma once
#include <cstddef>
#include "components/themes/SdCardThemeRegistry.h"
class ThemeInstaller {
public:
enum class Error {
OK,
INVALID_THEME_ID,
INVALID_FILE,
SD_WRITE_ERROR,
};
explicit ThemeInstaller(SdCardThemeRegistry& registry);
static bool isValidThemeId(const char* id);
static bool isValidRelativePath(const char* path);
bool ensureThemeDir(const char* themeId);
bool ensureParentDirs(const char* fullPath);
bool validateThemeFile(const char* path);
static bool buildThemePath(const char* themeId, const char* relativePath, char* outBuf, size_t outBufSize);
Error deleteTheme(const char* themeId);
void refreshRegistry();
bool isThemeInstalled(const char* themeId) const;
private:
SdCardThemeRegistry& registry_;
};
+2 -1
View File
@@ -56,7 +56,8 @@ class Activity {
// Finish this activity and return to the previous one on the stack (if any) // Finish this activity and return to the previous one on the stack (if any)
void finish(); void finish();
// Convenience method to facilitate API transition to ActivityManager. // Convenience method to facilitate API transition to ActivityManager
// TODO: remove this in near future
void onGoHome(HomeMenuItem item = HomeMenuItem::NONE); void onGoHome(HomeMenuItem item = HomeMenuItem::NONE);
void onSelectBook(const std::string& path); void onSelectBook(const std::string& path);
}; };
+9 -16
View File
@@ -9,7 +9,7 @@
#include "boot_sleep/BootActivity.h" #include "boot_sleep/BootActivity.h"
#include "boot_sleep/SleepActivity.h" #include "boot_sleep/SleepActivity.h"
#include "browser/OpdsBookBrowserActivity.h" #include "browser/OpdsBookBrowserActivity.h"
#include "components/TouchRegistry.h" #include "components/UITheme.h"
#include "home/CrashActivity.h" #include "home/CrashActivity.h"
#include "home/FileBrowserActivity.h" #include "home/FileBrowserActivity.h"
#include "home/HomeActivity.h" #include "home/HomeActivity.h"
@@ -20,13 +20,6 @@
#include "settings/SettingsActivity.h" #include "settings/SettingsActivity.h"
#include "util/FullScreenMessageActivity.h" #include "util/FullScreenMessageActivity.h"
// taskENTER_CRITICAL needs a real spinlock on dual-core targets (classic ESP32,
// e.g. M5Paper). On the single-core ESP32-C3 a nullptr mux was tolerated, but
// the dual-core port acquires an inter-core spinlock and asserts on a null
// pointer (spinlock_acquire, spinlock.h:84). One shared spinlock guards the
// short waitingTaskHandle critical sections below.
static portMUX_TYPE activityMux = portMUX_INITIALIZER_UNLOCKED;
void ActivityManager::begin() { void ActivityManager::begin() {
xTaskCreate(&renderTaskTrampoline, "ActivityManagerRender", xTaskCreate(&renderTaskTrampoline, "ActivityManagerRender",
8192, // Stack size 8192, // Stack size
@@ -50,18 +43,14 @@ void ActivityManager::renderTaskLoop() {
RenderLock lock; RenderLock lock;
if (currentActivity) { if (currentActivity) {
HalPowerManager::Lock powerLock; // Ensure we don't go into low-power mode while rendering HalPowerManager::Lock powerLock; // Ensure we don't go into low-power mode while rendering
// Touch targets are rebuilt every frame: clear before the activity draws, then
// publish so the next loop() hit-tests against exactly what's on screen.
TouchRegistry::getInstance().beginFrame();
currentActivity->render(std::move(lock)); currentActivity->render(std::move(lock));
TouchRegistry::getInstance().publish();
} }
// Notify any task blocked in requestUpdateAndWait() that the render is done. // Notify any task blocked in requestUpdateAndWait() that the render is done.
TaskHandle_t waiter = nullptr; TaskHandle_t waiter = nullptr;
taskENTER_CRITICAL(&activityMux); taskENTER_CRITICAL(nullptr);
waiter = waitingTaskHandle; waiter = waitingTaskHandle;
waitingTaskHandle = nullptr; waitingTaskHandle = nullptr;
taskEXIT_CRITICAL(&activityMux); taskEXIT_CRITICAL(nullptr);
if (waiter) { if (waiter) {
xTaskNotify(waiter, 1, eIncrement); xTaskNotify(waiter, 1, eIncrement);
} }
@@ -182,6 +171,7 @@ void ActivityManager::replaceActivity(std::unique_ptr<Activity>&& newActivity) {
} }
void ActivityManager::goToFileTransfer() { void ActivityManager::goToFileTransfer() {
UITheme::getInstance().releaseSdThemeAssetMemory();
replaceActivity(std::make_unique<CrossPointWebServerActivity>(renderer, mappedInput)); replaceActivity(std::make_unique<CrossPointWebServerActivity>(renderer, mappedInput));
} }
@@ -196,6 +186,7 @@ void ActivityManager::goToRecentBooks() {
} }
void ActivityManager::goToBrowser() { void ActivityManager::goToBrowser() {
UITheme::getInstance().releaseSdThemeAssetMemory();
const auto& servers = OPDS_STORE.getServers(); const auto& servers = OPDS_STORE.getServers();
// Skip the server picker when there's only one server configured // Skip the server picker when there's only one server configured
if (servers.size() == 1) { if (servers.size() == 1) {
@@ -206,6 +197,7 @@ void ActivityManager::goToBrowser() {
} }
void ActivityManager::goToReader(std::string path) { void ActivityManager::goToReader(std::string path) {
UITheme::getInstance().releaseSdThemeAssetMemory();
replaceActivity(std::make_unique<ReaderActivity>(renderer, mappedInput, std::move(path))); replaceActivity(std::make_unique<ReaderActivity>(renderer, mappedInput, std::move(path)));
} }
@@ -235,6 +227,7 @@ void ActivityManager::goHome(HomeMenuItem initialMenuItem) {
initialMenuItem = HomeMenuItem::SETTINGS_MENU; initialMenuItem = HomeMenuItem::SETTINGS_MENU;
} }
} }
UITheme::getInstance().reload();
replaceActivity(std::make_unique<HomeActivity>(renderer, mappedInput, initialMenuItem)); replaceActivity(std::make_unique<HomeActivity>(renderer, mappedInput, initialMenuItem));
} }
void ActivityManager::goToCrashReport() { replaceActivity(std::make_unique<CrashActivity>(renderer, mappedInput)); } void ActivityManager::goToCrashReport() { replaceActivity(std::make_unique<CrashActivity>(renderer, mappedInput)); }
@@ -292,7 +285,7 @@ void ActivityManager::requestUpdateAndWait() {
} }
// Atomic section to perform checks // Atomic section to perform checks
taskENTER_CRITICAL(&activityMux); taskENTER_CRITICAL(nullptr);
auto currTaskHandler = xTaskGetCurrentTaskHandle(); auto currTaskHandler = xTaskGetCurrentTaskHandle();
auto mutexHolder = xSemaphoreGetMutexHolder(renderingMutex); auto mutexHolder = xSemaphoreGetMutexHolder(renderingMutex);
bool isRenderTask = (currTaskHandler == renderTaskHandle); bool isRenderTask = (currTaskHandler == renderTaskHandle);
@@ -301,7 +294,7 @@ void ActivityManager::requestUpdateAndWait() {
if (!alreadyWaiting && !isRenderTask && !holdingRenderLock) { if (!alreadyWaiting && !isRenderTask && !holdingRenderLock) {
waitingTaskHandle = currTaskHandler; waitingTaskHandle = currTaskHandler;
} }
taskEXIT_CRITICAL(&activityMux); taskEXIT_CRITICAL(nullptr);
// Render task cannot call requestUpdateAndWait() or it will cause a deadlock // Render task cannot call requestUpdateAndWait() or it will cause a deadlock
assert(!isRenderTask && "Render task cannot call requestUpdateAndWait()"); assert(!isRenderTask && "Render task cannot call requestUpdateAndWait()");
+9 -1
View File
@@ -218,7 +218,15 @@ void SleepActivity::renderBitmapSleepScreen(const Bitmap& bitmap) const {
renderer.invertScreen(); renderer.invertScreen();
} }
renderer.displayBuffer(HalDisplay::HALF_REFRESH); if (hasGreyscale) {
// OEM grayscale pipeline base: on X3 this displays the frame with the
// dedicated "AA-pre-BW(mid)" differential waveform, leaving every pixel
// in the calibrated state the gray nudge refresh expects; on X4 it is a
// plain HALF refresh (previous behavior).
renderer.displayGrayscaleBase(HalDisplay::HALF_REFRESH);
} else {
renderer.displayBuffer(HalDisplay::HALF_REFRESH);
}
if (hasGreyscale) { if (hasGreyscale) {
bitmap.rewindToData(); bitmap.rewindToData();
@@ -1,6 +1,5 @@
#include "OpdsBookBrowserActivity.h" #include "OpdsBookBrowserActivity.h"
#include <FreeInkUI.h>
#include <GfxRenderer.h> #include <GfxRenderer.h>
#include <I18n.h> #include <I18n.h>
#include <Logging.h> #include <Logging.h>
@@ -11,7 +10,6 @@
#include "SilentRestart.h" #include "SilentRestart.h"
#include "activities/network/WifiSelectionActivity.h" #include "activities/network/WifiSelectionActivity.h"
#include "activities/util/KeyboardEntryActivity.h" #include "activities/util/KeyboardEntryActivity.h"
#include "components/TouchRegistry.h"
#include "components/UITheme.h" #include "components/UITheme.h"
#include "fontIds.h" #include "fontIds.h"
#include "network/HttpDownloader.h" #include "network/HttpDownloader.h"
@@ -33,6 +31,7 @@ void OpdsBookBrowserActivity::onEnter() {
currentPath = ""; currentPath = "";
selectorIndex = 0; selectorIndex = 0;
consumeConfirm = false; consumeConfirm = false;
consumeBack = false;
errorMessage.clear(); errorMessage.clear();
statusMessage = tr(STR_CHECKING_WIFI); statusMessage = tr(STR_CHECKING_WIFI);
requestUpdate(); requestUpdate();
@@ -61,6 +60,10 @@ void OpdsBookBrowserActivity::loop() {
consumeConfirm = false; consumeConfirm = false;
return; return;
} }
if (consumeBack && mappedInput.wasReleased(MappedInputManager::Button::Back)) {
consumeBack = false;
return;
}
if (state == BrowserState::ERROR) { if (state == BrowserState::ERROR) {
if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) { if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
@@ -88,28 +91,11 @@ void OpdsBookBrowserActivity::loop() {
if (state == BrowserState::DOWNLOADING) return; if (state == BrowserState::DOWNLOADING) return;
if (state == BrowserState::BROWSING) { if (state == BrowserState::BROWSING) {
if (!entries.empty()) {
if (mappedInput.wasListScroll(selectorIndex, static_cast<int>(entries.size()), PAGE_ITEMS)) {
requestUpdate();
return;
}
int downId = -1;
if (mappedInput.wasItemTouchedDown(downId) &&
freeink::ui::listSelectIndex(selectorIndex, downId, static_cast<int>(entries.size()))) {
requestUpdate();
}
int tappedId = -1;
if (mappedInput.wasItemTapped(tappedId) && tappedId >= 0 && tappedId < static_cast<int>(entries.size())) {
selectorIndex = tappedId;
activateSelectedEntry();
return;
}
}
if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) { if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
activateSelectedEntry(); if (!entries.empty()) {
const auto& entry = entries[selectorIndex];
entry.type == OpdsEntryType::BOOK ? downloadBook(entry) : navigateToEntry(entry);
}
} else if (mappedInput.wasReleased(MappedInputManager::Button::Back)) { } else if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
navigateBack(); navigateBack();
} else if (mappedInput.wasReleased(MappedInputManager::Button::Left)) { } else if (mappedInput.wasReleased(MappedInputManager::Button::Left)) {
@@ -192,20 +178,13 @@ void OpdsBookBrowserActivity::render(RenderLock&&) {
std::string displayText = (entry.type == OpdsEntryType::NAVIGATION) ? "> " + entry.title : entry.title; std::string displayText = (entry.type == OpdsEntryType::NAVIGATION) ? "> " + entry.title : entry.title;
if (entry.type == OpdsEntryType::BOOK && !entry.author.empty()) displayText += " - " + entry.author; if (entry.type == OpdsEntryType::BOOK && !entry.author.empty()) displayText += " - " + entry.author;
auto item = renderer.truncatedText(UI_10_FONT_ID, displayText.c_str(), pageWidth - 40); auto item = renderer.truncatedText(UI_10_FONT_ID, displayText.c_str(), pageWidth - 40);
const int itemY = 60 + (i % PAGE_ITEMS) * 30; renderer.drawText(UI_10_FONT_ID, 20, 60 + (i % PAGE_ITEMS) * 30, item.c_str(),
renderer.drawText(UI_10_FONT_ID, 20, itemY, item.c_str(), i != static_cast<size_t>(selectorIndex)); i != static_cast<size_t>(selectorIndex));
TouchRegistry::getInstance().add(Rect{0, itemY - 2, pageWidth, 30}, static_cast<int>(i), TouchRegistry::Item);
} }
} }
renderer.displayBuffer(); renderer.displayBuffer();
} }
void OpdsBookBrowserActivity::activateSelectedEntry() {
if (entries.empty() || selectorIndex < 0 || selectorIndex >= static_cast<int>(entries.size())) return;
const auto& entry = entries[selectorIndex];
entry.type == OpdsEntryType::BOOK ? downloadBook(entry) : navigateToEntry(entry);
}
void OpdsBookBrowserActivity::fetchFeed(const std::string& path) { void OpdsBookBrowserActivity::fetchFeed(const std::string& path) {
if (server.url.empty()) { if (server.url.empty()) {
state = BrowserState::ERROR; state = BrowserState::ERROR;
@@ -33,6 +33,7 @@ class OpdsBookBrowserActivity final : public Activity {
std::string currentPath; std::string currentPath;
std::string searchTemplate; std::string searchTemplate;
bool consumeConfirm = false; bool consumeConfirm = false;
bool consumeBack = false; // Added missing member
int selectorIndex = 0; int selectorIndex = 0;
std::string errorMessage; std::string errorMessage;
std::string statusMessage; std::string statusMessage;
@@ -50,6 +51,5 @@ class OpdsBookBrowserActivity final : public Activity {
void downloadBook(const OpdsEntry& book); void downloadBook(const OpdsEntry& book);
void launchSearch(); void launchSearch();
void performSearch(const std::string& query); void performSearch(const std::string& query);
void activateSelectedEntry();
bool preventAutoSleep() override { return true; } bool preventAutoSleep() override { return true; }
}; };
+1 -3
View File
@@ -20,9 +20,7 @@ void CrashActivity::onEnter() {
} }
void CrashActivity::loop() { void CrashActivity::loop() {
int tapX = 0; if (mappedInput.isPressed(MappedInputManager::Button::Back)) {
int tapY = 0;
if (mappedInput.isPressed(MappedInputManager::Button::Back) || mappedInput.wasScreenTapped(tapX, tapY)) {
finish(); finish();
} }
} }
+49 -38
View File
@@ -7,6 +7,7 @@
#include <Memory.h> #include <Memory.h>
#include <algorithm> #include <algorithm>
#include <vector>
#include "CrossPointSettings.h" #include "CrossPointSettings.h"
#include "MappedInputManager.h" #include "MappedInputManager.h"
@@ -206,29 +207,7 @@ void FileBrowserActivity::loop() {
const int pathReserved = renderer.getLineHeight(SMALL_FONT_ID) + UITheme::getInstance().getMetrics().verticalSpacing; const int pathReserved = renderer.getLineHeight(SMALL_FONT_ID) + UITheme::getInstance().getMetrics().verticalSpacing;
const int pageItems = UITheme::getNumberOfItemsPerPage(renderer, true, false, true, false, pathReserved); const int pageItems = UITheme::getNumberOfItemsPerPage(renderer, true, false, true, false, pathReserved);
// Vertical swipe page-scrolls the list (touch nav without the side buttons). if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
int scrollIdx = static_cast<int>(selectorIndex);
if (mappedInput.wasListScroll(scrollIdx, static_cast<int>(files.size()), pageItems)) {
selectorIndex = scrollIdx;
requestUpdate();
return;
}
int downId = -1;
if (mappedInput.wasItemTouchedDown(downId) && downId >= 0 && downId < static_cast<int>(files.size())) {
selectorIndex = downId;
requestUpdate();
}
// A tap opens the tapped entry (held-time is 0 on a tap, so it takes the short-press
// open path below, never the long-press delete).
int tappedId = -1;
const bool tapped = mappedInput.wasItemTapped(tappedId);
if (tapped && tappedId >= 0 && tappedId < static_cast<int>(files.size())) {
selectorIndex = tappedId;
}
if (tapped || mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
if (lockNextConfirmRelease) { if (lockNextConfirmRelease) {
lockNextConfirmRelease = false; lockNextConfirmRelease = false;
return; return;
@@ -377,30 +356,60 @@ void FileBrowserActivity::render(RenderLock&&) {
(mode == Mode::PickFirmware) (mode == Mode::PickFirmware)
? std::string(tr(STR_SELECT_FIRMWARE_FILE)) ? std::string(tr(STR_SELECT_FIRMWARE_FILE))
: ((basepath == "/") ? std::string(tr(STR_SD_CARD)) : basepath.substr(basepath.rfind('/') + 1)); : ((basepath == "/") ? std::string(tr(STR_SD_CARD)) : basepath.substr(basepath.rfind('/') + 1));
GUI.drawHeader(renderer, Rect{0, metrics.topPadding, pageWidth, metrics.headerHeight}, folderName.c_str());
const ThemeScreenSpec* screenSpec = UITheme::getInstance().getScreenSpec(ThemeScreenKind::FileBrowser);
ThemeLayoutSlots slots;
Rect headerRect{0, metrics.topPadding, pageWidth, metrics.headerHeight};
Rect listRect;
Rect pathRect;
Rect buttonsRect{0, pageHeight - metrics.buttonHintsHeight, pageWidth, metrics.buttonHintsHeight};
const int pathLineHeight = renderer.getLineHeight(SMALL_FONT_ID); const int pathLineHeight = renderer.getLineHeight(SMALL_FONT_ID);
const int pathReserved = pathLineHeight + metrics.verticalSpacing; const int pathReserved = pathLineHeight + metrics.verticalSpacing;
const int contentTop = metrics.topPadding + metrics.headerHeight + metrics.verticalSpacing; if (screenSpec != nullptr) {
const int contentHeight = layoutThemeSlots(screenSpec->layout, Rect{0, 0, pageWidth, pageHeight}, metrics, slots);
pageHeight - contentTop - metrics.buttonHintsHeight - metrics.verticalSpacing - pathReserved; headerRect = normalizeThemeHeaderSlot(findThemeSlot(slots, "header"), metrics);
if (files.empty()) { listRect = findThemeSlot(slots, "list");
pathRect = findThemeSlot(slots, "path");
buttonsRect = findThemeSlot(slots, "buttons");
if (listRect.width <= 0 || listRect.height <= 0) {
LOG_ERR("FileBrowser", "Invalid SD file layout: slots=%d; using built-in layout", static_cast<int>(slots.size()));
screenSpec = nullptr;
}
}
if (screenSpec == nullptr) {
const int contentTop = metrics.topPadding + metrics.headerHeight + metrics.verticalSpacing;
const int contentHeight =
pageHeight - contentTop - metrics.buttonHintsHeight - metrics.verticalSpacing - pathReserved;
headerRect = Rect{0, metrics.topPadding, pageWidth, metrics.headerHeight};
listRect = Rect{0, contentTop, pageWidth, contentHeight};
pathRect = Rect{metrics.contentSidePadding,
pageHeight - metrics.buttonHintsHeight - metrics.verticalSpacing - pathLineHeight,
pageWidth - metrics.contentSidePadding * 2, pathLineHeight};
buttonsRect = Rect{0, pageHeight - metrics.buttonHintsHeight, pageWidth, metrics.buttonHintsHeight};
}
if (headerRect.width > 0 && headerRect.height > 0) {
GUI.drawHeader(renderer, headerRect, folderName.c_str());
}
if (listRect.width <= 0 || listRect.height <= 0) {
// Malformed theme layout: no list slot to draw into.
} else if (files.empty()) {
const char* emptyMsg = (mode == Mode::PickFirmware) ? tr(STR_NO_BIN_FILES) : tr(STR_NO_FILES_FOUND); const char* emptyMsg = (mode == Mode::PickFirmware) ? tr(STR_NO_BIN_FILES) : tr(STR_NO_FILES_FOUND);
renderer.drawText(UI_10_FONT_ID, metrics.contentSidePadding, contentTop + 20, emptyMsg); renderer.drawText(UI_10_FONT_ID, metrics.contentSidePadding, listRect.y + 20, emptyMsg);
} else { } else {
GUI.drawList( GUI.drawList(
renderer, Rect{0, contentTop, pageWidth, contentHeight}, files.size(), selectorIndex, renderer, listRect, files.size(), selectorIndex, [this](int index) { return getFileName(files[index]); },
[this](int index) { return getFileName(files[index]); }, nullptr, nullptr, [this](int index) { return UITheme::getFileIcon(files[index]); },
[this](int index) { return UITheme::getFileIcon(files[index]); },
[this](int index) { return getFileExtension(files[index]); }, false); [this](int index) { return getFileExtension(files[index]); }, false);
} }
// Full path display // Full path display
{ if (pathRect.width > 0 && pathRect.height > 0) {
const int pathY = pageHeight - metrics.buttonHintsHeight - metrics.verticalSpacing - pathLineHeight; const int pathY = pathRect.y;
const int separatorY = pathY - metrics.verticalSpacing / 2; const int separatorY = pathRect.y - metrics.verticalSpacing / 2;
renderer.drawLine(0, separatorY, pageWidth - 1, separatorY, 3, true); renderer.drawLine(0, separatorY, pageWidth - 1, separatorY, 3, true);
const int pathMaxWidth = pageWidth - metrics.contentSidePadding * 2; const int pathMaxWidth = pathRect.width;
// Left-truncate so the deepest directory is always visible // Left-truncate so the deepest directory is always visible
const char* pathStr = basepath.c_str(); const char* pathStr = basepath.c_str();
const char* pathDisplay = pathStr; const char* pathDisplay = pathStr;
@@ -419,7 +428,7 @@ void FileBrowserActivity::render(RenderLock&&) {
snprintf(leftTruncBuf, sizeof(leftTruncBuf), "%s%s", ellipsis, p); snprintf(leftTruncBuf, sizeof(leftTruncBuf), "%s%s", ellipsis, p);
pathDisplay = leftTruncBuf; pathDisplay = leftTruncBuf;
} }
renderer.drawText(SMALL_FONT_ID, metrics.contentSidePadding, pathY, pathDisplay); renderer.drawText(SMALL_FONT_ID, pathRect.x, pathY, pathDisplay);
} }
// Help text // Help text
@@ -430,7 +439,9 @@ void FileBrowserActivity::render(RenderLock&&) {
const char* confirmLabel = files.empty() ? "" : (selectingFirmwareFile ? tr(STR_SELECT) : tr(STR_OPEN)); const char* confirmLabel = files.empty() ? "" : (selectingFirmwareFile ? tr(STR_SELECT) : tr(STR_OPEN));
const auto labels = mappedInput.mapLabels(backLabel, confirmLabel, files.empty() ? "" : tr(STR_DIR_UP), const auto labels = mappedInput.mapLabels(backLabel, confirmLabel, files.empty() ? "" : tr(STR_DIR_UP),
files.empty() ? "" : tr(STR_DIR_DOWN)); files.empty() ? "" : tr(STR_DIR_DOWN));
GUI.drawButtonHints(renderer, labels.btn1, labels.btn2, labels.btn3, labels.btn4); if (buttonsRect.width > 0 && buttonsRect.height > 0) {
GUI.drawButtonHints(renderer, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
}
renderer.displayBuffer(); renderer.displayBuffer();
} }
+257 -104
View File
@@ -1,34 +1,40 @@
#include "HomeActivity.h" #include "HomeActivity.h"
#include <Bitmap.h>
#include <Epub.h> #include <Epub.h>
#include <FsHelpers.h> #include <FsHelpers.h>
#include <GfxRenderer.h> #include <GfxRenderer.h>
#include <HalStorage.h> #include <HalStorage.h>
#include <I18n.h> #include <I18n.h>
#include <Utf8.h> #include <Memory.h>
#include <Xtc.h> #include <Xtc.h>
#include <cstring> #include <algorithm>
#include <vector> #include <vector>
#include "CrossPointSettings.h"
#include "CrossPointState.h"
#include "MappedInputManager.h" #include "MappedInputManager.h"
#include "OpdsServerStore.h" #include "OpdsServerStore.h"
#include "RecentBooksStore.h" #include "RecentBooksStore.h"
#include "components/UITheme.h" #include "components/UITheme.h"
#include "fontIds.h"
int HomeActivity::getMenuItemCount() const { void HomeActivity::buildHomeActions(std::vector<ThemeHomeActionEntry>& actions) const {
int count = 4; // File Browser, Recents, File transfer, Settings buildThemeHomeActions(UITheme::getInstance().getHomeScreenSpec(), recentBooks, hasOpdsServers, actions);
if (!recentBooks.empty()) { }
count += recentBooks.size();
} const std::vector<ThemeHomeActionEntry>& HomeActivity::refreshHomeActions() {
if (hasOpdsServers) { buildHomeActions(homeActions);
count++; return homeActions;
} }
return count;
int HomeActivity::getMenuItemCount() { return static_cast<int>(refreshHomeActions().size()); }
bool HomeActivity::storeCoverBufferCallback(void* userData) {
auto* activity = static_cast<HomeActivity*>(userData);
return activity != nullptr && activity->storeCoverBuffer();
}
bool HomeActivity::restoreCoverBufferCallback(void* userData) {
auto* activity = static_cast<HomeActivity*>(userData);
return activity != nullptr && activity->restoreCoverBuffer();
} }
void HomeActivity::loadRecentBooks(int maxBooks) { void HomeActivity::loadRecentBooks(int maxBooks) {
@@ -51,7 +57,7 @@ void HomeActivity::loadRecentBooks(int maxBooks) {
} }
} }
void HomeActivity::loadRecentCovers(int coverHeight) { void HomeActivity::loadRecentCovers(const std::vector<int>& coverHeights) {
recentsLoading = true; recentsLoading = true;
bool showingLoading = false; bool showingLoading = false;
Rect popupRect; Rect popupRect;
@@ -59,8 +65,16 @@ void HomeActivity::loadRecentCovers(int coverHeight) {
int progress = 0; int progress = 0;
for (RecentBook& book : recentBooks) { for (RecentBook& book : recentBooks) {
if (!book.coverBmpPath.empty()) { if (!book.coverBmpPath.empty()) {
std::string coverPath = UITheme::getCoverThumbPath(book.coverBmpPath, coverHeight); bool hasMissingThumb = false;
if (!Storage.exists(coverPath.c_str())) { for (const int coverHeight : coverHeights) {
std::string coverPath = UITheme::getCoverThumbPath(book.coverBmpPath, coverHeight);
if (!Storage.exists(coverPath.c_str())) {
hasMissingThumb = true;
break;
}
}
if (hasMissingThumb) {
// If epub, try to load the metadata for title/author and cover // If epub, try to load the metadata for title/author and cover
if (FsHelpers::hasEpubExtension(book.path)) { if (FsHelpers::hasEpubExtension(book.path)) {
Epub epub(book.path, "/.crosspoint"); Epub epub(book.path, "/.crosspoint");
@@ -73,7 +87,13 @@ void HomeActivity::loadRecentCovers(int coverHeight) {
popupRect = GUI.drawPopup(renderer, tr(STR_LOADING_POPUP)); popupRect = GUI.drawPopup(renderer, tr(STR_LOADING_POPUP));
} }
GUI.fillPopupProgress(renderer, popupRect, 10 + progress * (90 / recentBooks.size())); GUI.fillPopupProgress(renderer, popupRect, 10 + progress * (90 / recentBooks.size()));
bool success = epub.generateThumbBmp(coverHeight); bool success = true;
for (const int coverHeight : coverHeights) {
std::string coverPath = UITheme::getCoverThumbPath(book.coverBmpPath, coverHeight);
if (!Storage.exists(coverPath.c_str())) {
success = epub.generateThumbBmp(coverHeight) && success;
}
}
if (!success) { if (!success) {
RECENT_BOOKS.updateBook(book.path, book.title, book.author, ""); RECENT_BOOKS.updateBook(book.path, book.title, book.author, "");
book.coverBmpPath = ""; book.coverBmpPath = "";
@@ -90,7 +110,13 @@ void HomeActivity::loadRecentCovers(int coverHeight) {
popupRect = GUI.drawPopup(renderer, tr(STR_LOADING_POPUP)); popupRect = GUI.drawPopup(renderer, tr(STR_LOADING_POPUP));
} }
GUI.fillPopupProgress(renderer, popupRect, 10 + progress * (90 / recentBooks.size())); GUI.fillPopupProgress(renderer, popupRect, 10 + progress * (90 / recentBooks.size()));
bool success = xtc.generateThumbBmp(coverHeight); bool success = true;
for (const int coverHeight : coverHeights) {
std::string coverPath = UITheme::getCoverThumbPath(book.coverBmpPath, coverHeight);
if (!Storage.exists(coverPath.c_str())) {
success = xtc.generateThumbBmp(coverHeight) && success;
}
}
if (!success) { if (!success) {
RECENT_BOOKS.updateBook(book.path, book.title, book.author, ""); RECENT_BOOKS.updateBook(book.path, book.title, book.author, "");
book.coverBmpPath = ""; book.coverBmpPath = "";
@@ -115,9 +141,46 @@ void HomeActivity::onEnter() {
const auto& metrics = UITheme::getInstance().getMetrics(); const auto& metrics = UITheme::getInstance().getMetrics();
loadRecentBooks(metrics.homeRecentBooksCount); loadRecentBooks(metrics.homeRecentBooksCount);
LOG_DBG("HOME", "Loaded %d/%d recent book(s) for home theme", static_cast<int>(recentBooks.size()),
metrics.homeRecentBooksCount);
const auto base = static_cast<int>(recentBooks.size()); const auto& actions = refreshHomeActions();
selectorIndex = initialMenuItem == HomeMenuItem::NONE ? 0 : base + menuItemToIndex(initialMenuItem, hasOpdsServers); const ThemeHomeScreenSpec* homeSpec = UITheme::getInstance().getHomeScreenSpec();
selectorIndex = 0;
bool hasWantedAction = initialMenuItem != HomeMenuItem::NONE;
const auto wantedAction = [this]() {
switch (initialMenuItem) {
case HomeMenuItem::RECENTS:
return ThemeHomeAction::RecentBooks;
case HomeMenuItem::OPDS_BROWSER:
return ThemeHomeAction::OpdsBrowser;
case HomeMenuItem::FILE_TRANSFER:
return ThemeHomeAction::FileTransfer;
case HomeMenuItem::SETTINGS_MENU:
return ThemeHomeAction::Settings;
case HomeMenuItem::FILE_BROWSER:
case HomeMenuItem::NONE:
default:
return ThemeHomeAction::FileBrowser;
}
}();
ThemeHomeAction selectedEntryAction = wantedAction;
if (!hasWantedAction && homeSpec != nullptr && homeSpec->hasInitialAction) {
hasWantedAction = true;
selectedEntryAction = homeSpec->initialAction;
}
if (hasWantedAction) {
for (int i = 0; i < static_cast<int>(actions.size()); ++i) {
if (actions[i].action == selectedEntryAction) {
selectorIndex = i;
break;
}
}
}
coverSelectorIndex = !recentBooks.empty() && selectorIndex < static_cast<int>(actions.size()) &&
actions[selectorIndex].action == ThemeHomeAction::RecentBook
? actions[selectorIndex].value
: 0;
// Trigger first update // Trigger first update
requestUpdate(); requestUpdate();
@@ -137,95 +200,124 @@ bool HomeActivity::storeCoverBuffer() {
freeCoverBuffer(); freeCoverBuffer();
const size_t needed = renderer.getRegionByteSize(coverRectX, coverRectY, coverRectW, coverRectH); const size_t needed = renderer.getRegionByteSize(coverRectX, coverRectY, coverRectW, coverRectH);
if (needed == 0) return false; if (needed == 0) return false;
coverBuffer = static_cast<uint8_t*>(malloc(needed)); coverBuffer = makeUniqueNoThrow<uint8_t[]>(needed);
if (!coverBuffer) { if (!coverBuffer) {
LOG_ERR("HOME", "OOM: cover buffer (%u bytes)", (unsigned)needed); LOG_ERR("HOME", "OOM: cover buffer (%u bytes)", (unsigned)needed);
return false; return false;
} }
coverBufferSize = needed; coverBufferSize = needed;
if (!renderer.copyRegionToBuffer(coverRectX, coverRectY, coverRectW, coverRectH, coverBuffer, coverBufferSize)) { if (!renderer.copyRegionToBuffer(coverRectX, coverRectY, coverRectW, coverRectH, coverBuffer.get(),
free(coverBuffer); coverBufferSize)) {
coverBuffer = nullptr; coverBuffer.reset();
coverBufferSize = 0; coverBufferSize = 0;
return false; return false;
} }
coverBufferSelectorIndex = coverSelectorIndex;
const auto& actions = refreshHomeActions();
coverBufferStripSelected = selectorIndex >= 0 && selectorIndex < static_cast<int>(actions.size()) &&
actions[selectorIndex].action == ThemeHomeAction::RecentBook;
return true; return true;
} }
bool HomeActivity::restoreCoverBuffer() { bool HomeActivity::restoreCoverBuffer() {
if (!coverBuffer || coverRectW <= 0 || coverRectH <= 0) return false; if (!coverBuffer || coverRectW <= 0 || coverRectH <= 0) return false;
return renderer.copyBufferToRegion(coverRectX, coverRectY, coverRectW, coverRectH, coverBuffer, coverBufferSize); return renderer.copyBufferToRegion(coverRectX, coverRectY, coverRectW, coverRectH, coverBuffer.get(),
coverBufferSize);
} }
void HomeActivity::freeCoverBuffer() { void HomeActivity::freeCoverBuffer() {
if (coverBuffer) { coverBuffer.reset();
free(coverBuffer);
coverBuffer = nullptr;
}
coverBufferSize = 0; coverBufferSize = 0;
coverBufferStored = false; coverBufferStored = false;
coverBufferSelectorIndex = -1;
coverBufferStripSelected = false;
} }
void HomeActivity::loop() { void HomeActivity::loop() {
const int menuCount = getMenuItemCount(); const int menuCount = getMenuItemCount();
const ThemeHomeScreenSpec* homeSpec = UITheme::getInstance().getHomeScreenSpec();
buttonNavigator.onNext([this, menuCount] { auto updateCoverSelection = [this]() {
selectorIndex = ButtonNavigator::nextIndex(selectorIndex, menuCount); const auto& actions = refreshHomeActions();
requestUpdate(); if (selectorIndex < static_cast<int>(actions.size()) &&
}); actions[selectorIndex].action == ThemeHomeAction::RecentBook) {
coverSelectorIndex = actions[selectorIndex].value;
}
};
buttonNavigator.onPrevious([this, menuCount] { auto moveWithin = [this, &updateCoverSelection](bool wantRecentBook, int delta) {
selectorIndex = ButtonNavigator::previousIndex(selectorIndex, menuCount); const auto& actions = refreshHomeActions();
requestUpdate(); if (actions.empty()) return;
});
// Tap a menu button to select + activate it. The button menu registers navigationIndices.clear();
// menu-local ids (drawn with selectorIndex offset by recentBooks.size()), so map navigationIndices.reserve(actions.size());
// back into the global selector space. for (int i = 0; i < static_cast<int>(actions.size()); ++i) {
int downId = -1; if ((actions[i].action == ThemeHomeAction::RecentBook) == wantRecentBook) {
if (mappedInput.wasItemTouchedDown(downId)) { navigationIndices.push_back(i);
selectorIndex = static_cast<int>(recentBooks.size()) + downId;
requestUpdate();
}
int tappedId = -1;
const bool tapped = mappedInput.wasItemTapped(tappedId);
if (tapped) {
selectorIndex = static_cast<int>(recentBooks.size()) + tappedId;
}
// A tap on the continue-reading cover selects that book (home selector index).
int coverId = -1;
const bool coverTapped = mappedInput.wasCoverTapped(coverId);
if (coverTapped && coverId >= 0 && coverId < static_cast<int>(recentBooks.size())) {
selectorIndex = coverId;
}
if (tapped || coverTapped || mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
if (selectorIndex < recentBooks.size()) {
onSelectBook(recentBooks[selectorIndex].path);
} else {
const int menuIndex = selectorIndex - static_cast<int>(recentBooks.size());
switch (indexToMenuItem(menuIndex, hasOpdsServers)) {
case HomeMenuItem::FILE_BROWSER:
onFileBrowserOpen();
break;
case HomeMenuItem::RECENTS:
onRecentsOpen();
break;
case HomeMenuItem::OPDS_BROWSER:
onOpdsBrowserOpen();
break;
case HomeMenuItem::FILE_TRANSFER:
onFileTransferOpen();
break;
case HomeMenuItem::SETTINGS_MENU:
onSettingsOpen();
break;
default:
break;
} }
} }
if (navigationIndices.empty()) return;
auto current = std::find(navigationIndices.begin(), navigationIndices.end(), selectorIndex);
int groupIndex = current == navigationIndices.end() ? (delta > 0 ? -1 : 0)
: static_cast<int>(current - navigationIndices.begin());
groupIndex =
(groupIndex + delta + static_cast<int>(navigationIndices.size())) % static_cast<int>(navigationIndices.size());
selectorIndex = navigationIndices[groupIndex];
updateCoverSelection();
requestUpdate();
};
if (homeSpec != nullptr && homeSpec->navigation == ThemeHomeNavigationMode::SplitAxis) {
buttonNavigator.onPressAndContinuous({MappedInputManager::Button::Right}, [moveWithin] { moveWithin(false, 1); });
buttonNavigator.onPressAndContinuous({MappedInputManager::Button::Left}, [moveWithin] { moveWithin(false, -1); });
buttonNavigator.onPressAndContinuous({MappedInputManager::Button::Down}, [moveWithin] { moveWithin(true, 1); });
buttonNavigator.onPressAndContinuous({MappedInputManager::Button::Up}, [moveWithin] { moveWithin(true, -1); });
} else if (homeSpec != nullptr && homeSpec->navigation == ThemeHomeNavigationMode::CarouselAxis) {
buttonNavigator.onPressAndContinuous({MappedInputManager::Button::Right}, [moveWithin] { moveWithin(true, 1); });
buttonNavigator.onPressAndContinuous({MappedInputManager::Button::Left}, [moveWithin] { moveWithin(true, -1); });
buttonNavigator.onPressAndContinuous({MappedInputManager::Button::Down}, [moveWithin] { moveWithin(false, 1); });
buttonNavigator.onPressAndContinuous({MappedInputManager::Button::Up}, [moveWithin] { moveWithin(false, -1); });
} else {
buttonNavigator.onNext([this, menuCount, &updateCoverSelection] {
selectorIndex = ButtonNavigator::nextIndex(selectorIndex, menuCount);
updateCoverSelection();
requestUpdate();
});
buttonNavigator.onPrevious([this, menuCount, &updateCoverSelection] {
selectorIndex = ButtonNavigator::previousIndex(selectorIndex, menuCount);
updateCoverSelection();
requestUpdate();
});
}
if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
const auto& actions = refreshHomeActions();
if (selectorIndex < 0 || selectorIndex >= static_cast<int>(actions.size())) return;
const auto& entry = actions[selectorIndex];
switch (entry.action) {
case ThemeHomeAction::RecentBook:
if (entry.value >= 0 && entry.value < static_cast<int>(recentBooks.size()))
onSelectBook(recentBooks[entry.value].path);
break;
case ThemeHomeAction::RecentBooks:
onRecentsOpen();
break;
case ThemeHomeAction::OpdsBrowser:
onOpdsBrowserOpen();
break;
case ThemeHomeAction::FileTransfer:
onFileTransferOpen();
break;
case ThemeHomeAction::Settings:
onSettingsOpen();
break;
case ThemeHomeAction::FileBrowser:
default:
onFileBrowserOpen();
break;
}
} }
} }
@@ -233,29 +325,91 @@ void HomeActivity::render(RenderLock&&) {
const auto& metrics = UITheme::getInstance().getMetrics(); const auto& metrics = UITheme::getInstance().getMetrics();
const auto pageWidth = renderer.getScreenWidth(); const auto pageWidth = renderer.getScreenWidth();
const auto pageHeight = renderer.getScreenHeight(); const auto pageHeight = renderer.getScreenHeight();
constexpr int coverCacheBleed = 12;
const ThemeHomeScreenSpec* homeSpec = UITheme::getInstance().getHomeScreenSpec();
if (homeSpec != nullptr) {
const auto& actions = refreshHomeActions();
ThemeHomeRenderContext context{renderer,
mappedInput,
metrics,
*homeSpec,
recentBooks,
actions,
hasOpdsServers,
selectorIndex,
coverSelectorIndex,
coverRendered,
coverBufferStored,
coverBufferSelectorIndex,
coverBufferStripSelected,
coverRectX,
coverRectY,
coverRectW,
coverRectH,
this,
&HomeActivity::storeCoverBufferCallback,
&HomeActivity::restoreCoverBufferCallback};
if (renderThemeHome(context)) {
if (!firstRenderDone) {
firstRenderDone = true;
requestUpdate();
} else if (!recentsLoaded && !recentsLoading && !UITheme::getInstance().getHomeCoverThumbHeights().empty()) {
recentsLoading = true;
loadRecentCovers(UITheme::getInstance().getHomeCoverThumbHeights());
}
return;
}
}
const bool hasCoverArea = metrics.homeCoverTileHeight > 0 && metrics.homeCoverHeight > 0;
renderer.clearScreen(); renderer.clearScreen();
bool bufferRestored = coverBufferStored && restoreCoverBuffer();
GUI.drawHeader(renderer, Rect{0, metrics.topPadding, pageWidth, metrics.homeTopPadding},
metrics.homeContinueReadingInMenu && !recentBooks.empty() ? recentBooks[0].title.c_str() : nullptr);
// Record the tile rect so storeCoverBuffer (called from the theme) knows // Record the tile rect so storeCoverBuffer (called from the theme) knows
// which sub-region of the framebuffer to snapshot. ~16 KB in Portrait // which sub-region of the framebuffer to snapshot. Include a small bleed
// instead of the 48 KB full framebuffer the previous bind captured. // because cover-strip themes can draw selection outlines just outside the
// nominal cover tile.
coverRectX = 0; coverRectX = 0;
coverRectY = metrics.homeTopPadding; coverRectY = hasCoverArea ? std::max(0, metrics.homeTopPadding - coverCacheBleed) : 0;
coverRectW = pageWidth; coverRectW = pageWidth;
coverRectH = metrics.homeCoverTileHeight; coverRectH = hasCoverArea
? std::min(pageHeight - coverRectY,
metrics.homeCoverTileHeight + (metrics.homeTopPadding - coverRectY) + coverCacheBleed)
: 0;
GUI.drawRecentBookCover(renderer, Rect{0, metrics.homeTopPadding, pageWidth, metrics.homeCoverTileHeight}, GUI.drawHeader(renderer, Rect{0, metrics.topPadding, pageWidth, metrics.homeTopPadding},
recentBooks, selectorIndex, coverRendered, coverBufferStored, bufferRestored, metrics.homeContinueReadingInMenu && metrics.homeShowContinueReadingHeader && !recentBooks.empty()
std::bind(&HomeActivity::storeCoverBuffer, this)); ? recentBooks[std::min(coverSelectorIndex, static_cast<int>(recentBooks.size()) - 1)].title.c_str()
: nullptr);
const bool selectorSensitiveCoverCache = GUI.homeCoverCacheDependsOnSelector();
const bool coverStripSelected = metrics.homeContinueReadingInMenu
? selectorIndex == 0 && !recentBooks.empty()
: selectorIndex < static_cast<int>(recentBooks.size());
const bool coverCacheMatches = !selectorSensitiveCoverCache || (coverBufferSelectorIndex == coverSelectorIndex &&
coverBufferStripSelected == coverStripSelected);
if (hasCoverArea && coverBufferStored && !coverCacheMatches) {
freeCoverBuffer();
coverRendered = false;
}
bool bufferRestored = hasCoverArea && coverBufferStored && coverCacheMatches && restoreCoverBuffer();
if (hasCoverArea) {
GUI.drawRecentBookCover(
renderer, Rect{0, metrics.homeTopPadding, pageWidth, metrics.homeCoverTileHeight}, recentBooks,
coverSelectorIndex, coverRendered, coverBufferStored, bufferRestored, [this]() { return storeCoverBuffer(); },
coverStripSelected);
} else {
coverRendered = false;
coverBufferStored = false;
bufferRestored = false;
}
// Build menu items dynamically // Build menu items dynamically
std::vector<const char*> menuItems = {tr(STR_BROWSE_FILES), tr(STR_MENU_RECENT_BOOKS), tr(STR_FILE_TRANSFER), std::vector<const char*> menuItems = {tr(STR_BROWSE_FILES), tr(STR_MENU_RECENT_BOOKS), tr(STR_FILE_TRANSFER),
tr(STR_SETTINGS_TITLE)}; tr(STR_SETTINGS_TITLE)};
std::vector<UIIcon> menuIcons = {Folder, Book, Transfer, Settings}; std::vector<UIIcon> menuIcons = {Folder, Recent, Transfer, Settings};
if (hasOpdsServers) { if (hasOpdsServers) {
menuItems.insert(menuItems.begin() + 2, tr(STR_OPDS_BROWSER)); menuItems.insert(menuItems.begin() + 2, tr(STR_OPDS_BROWSER));
@@ -268,13 +422,12 @@ void HomeActivity::render(RenderLock&&) {
menuIcons.insert(menuIcons.begin(), Book); menuIcons.insert(menuIcons.begin(), Book);
} }
// Menu fills the space between the cover and the bottom reserve (button hints
// when shown, else a margin). Sizing it to the real remaining height lets
// drawButtonMenu fit the items, so a scaled-up menu never runs off the bottom.
const int menuY = metrics.homeTopPadding + metrics.homeCoverTileHeight + metrics.homeMenuTopOffset;
const int bottomReserve = (BaseTheme::showButtonHints() ? metrics.buttonHintsHeight : 0) + metrics.verticalSpacing;
GUI.drawButtonMenu( GUI.drawButtonMenu(
renderer, Rect{0, menuY, pageWidth, pageHeight - menuY - bottomReserve}, static_cast<int>(menuItems.size()), renderer,
Rect{0, metrics.homeTopPadding + metrics.homeCoverTileHeight + metrics.homeMenuTopOffset, pageWidth,
pageHeight - (metrics.headerHeight + metrics.homeTopPadding + metrics.verticalSpacing +
metrics.homeMenuTopOffset + metrics.buttonHintsHeight)},
static_cast<int>(menuItems.size()),
metrics.homeContinueReadingInMenu ? selectorIndex : selectorIndex - recentBooks.size(), metrics.homeContinueReadingInMenu ? selectorIndex : selectorIndex - recentBooks.size(),
[&menuItems](int index) { return std::string(menuItems[index]); }, [&menuItems](int index) { return std::string(menuItems[index]); },
[&menuIcons](int index) { return menuIcons[index]; }); [&menuIcons](int index) { return menuIcons[index]; });
@@ -287,9 +440,9 @@ void HomeActivity::render(RenderLock&&) {
if (!firstRenderDone) { if (!firstRenderDone) {
firstRenderDone = true; firstRenderDone = true;
requestUpdate(); requestUpdate();
} else if (!recentsLoaded && !recentsLoading) { } else if (!recentsLoaded && !recentsLoading && !UITheme::getInstance().getHomeCoverThumbHeights().empty()) {
recentsLoading = true; recentsLoading = true;
loadRecentCovers(metrics.homeCoverHeight); loadRecentCovers(UITheme::getInstance().getHomeCoverThumbHeights());
} }
} }
+20 -36
View File
@@ -1,25 +1,28 @@
#pragma once #pragma once
#include <functional> #include <memory>
#include <vector> #include <vector>
#include "./FileBrowserActivity.h" #include "./FileBrowserActivity.h"
#include "./ThemeHomeRenderer.h"
#include "activities/Activity.h" #include "activities/Activity.h"
#include "util/ButtonNavigator.h" #include "util/ButtonNavigator.h"
struct RecentBook; struct RecentBook;
struct Rect;
class HomeActivity final : public Activity { class HomeActivity final : public Activity {
ButtonNavigator buttonNavigator; ButtonNavigator buttonNavigator;
int selectorIndex = 0; int selectorIndex = 0;
int coverSelectorIndex = 0;
bool recentsLoading = false; bool recentsLoading = false;
bool recentsLoaded = false; bool recentsLoaded = false;
bool firstRenderDone = false; bool firstRenderDone = false;
bool hasOpdsServers = false; bool hasOpdsServers = false;
bool coverRendered = false; // Track if cover has been rendered once bool coverRendered = false;
bool coverBufferStored = false; // Track if cover buffer is stored bool coverBufferStored = false;
uint8_t* coverBuffer = nullptr; // HomeActivity's own buffer for cover image std::unique_ptr<uint8_t[]> coverBuffer;
size_t coverBufferSize = 0; // Bytes allocated to coverBuffer size_t coverBufferSize = 0;
int coverBufferSelectorIndex = -1;
bool coverBufferStripSelected = false;
// Logical rect last passed to drawRecentBookCover. The cover snapshot only // Logical rect last passed to drawRecentBookCover. The cover snapshot only
// needs to cover this region, not the entire framebuffer, so we cache the // needs to cover this region, not the entire framebuffer, so we cache the
// tile instead of all 48 KB. Set in render() before the call. // tile instead of all 48 KB. Set in render() before the call.
@@ -28,33 +31,10 @@ class HomeActivity final : public Activity {
int coverRectW = 0; int coverRectW = 0;
int coverRectH = 0; int coverRectH = 0;
std::vector<RecentBook> recentBooks; std::vector<RecentBook> recentBooks;
std::vector<ThemeHomeActionEntry> homeActions;
std::vector<int> navigationIndices;
const HomeMenuItem initialMenuItem; const HomeMenuItem initialMenuItem;
// Convert HomeMenuItem to menu index (used in onEnter)
static int menuItemToIndex(HomeMenuItem item, bool hasOpdsUrl) {
int i = 0;
if (item == HomeMenuItem::FILE_BROWSER) return i;
++i;
if (item == HomeMenuItem::RECENTS) return i;
++i;
if (item == HomeMenuItem::OPDS_BROWSER) return hasOpdsUrl ? i : 0;
if (hasOpdsUrl) ++i;
if (item == HomeMenuItem::FILE_TRANSFER) return i;
++i;
if (item == HomeMenuItem::SETTINGS_MENU) return i;
return 0;
}
// Convert menu index to HomeMenuItem (used in loop)
static HomeMenuItem indexToMenuItem(int idx, bool hasOpdsUrl) {
int i = 0;
if (idx == i++) return HomeMenuItem::FILE_BROWSER;
if (idx == i++) return HomeMenuItem::RECENTS;
if (hasOpdsUrl && idx == i++) return HomeMenuItem::OPDS_BROWSER;
if (idx == i++) return HomeMenuItem::FILE_TRANSFER;
if (idx == i) return HomeMenuItem::SETTINGS_MENU;
return HomeMenuItem::NONE;
}
void onSelectBook(const std::string& path); void onSelectBook(const std::string& path);
void onFileBrowserOpen(); void onFileBrowserOpen();
void onRecentsOpen(); void onRecentsOpen();
@@ -62,12 +42,16 @@ class HomeActivity final : public Activity {
void onFileTransferOpen(); void onFileTransferOpen();
void onOpdsBrowserOpen(); void onOpdsBrowserOpen();
int getMenuItemCount() const; void buildHomeActions(std::vector<ThemeHomeActionEntry>& actions) const;
bool storeCoverBuffer(); // Store frame buffer for cover image const std::vector<ThemeHomeActionEntry>& refreshHomeActions();
bool restoreCoverBuffer(); // Restore frame buffer from stored cover int getMenuItemCount();
void freeCoverBuffer(); // Free the stored cover buffer static bool storeCoverBufferCallback(void* userData);
static bool restoreCoverBufferCallback(void* userData);
bool storeCoverBuffer();
bool restoreCoverBuffer();
void freeCoverBuffer();
void loadRecentBooks(int maxBooks); void loadRecentBooks(int maxBooks);
void loadRecentCovers(int coverHeight); void loadRecentCovers(const std::vector<int>& coverHeights);
public: public:
explicit HomeActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, explicit HomeActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
@@ -0,0 +1,91 @@
#include "RecentBookCoverPainter.h"
#include <Bitmap.h>
#include <GfxRenderer.h>
#include <HalStorage.h>
#include <algorithm>
#include "RecentBooksStore.h"
#include "components/UITheme.h"
#include "components/icons/cover.h"
namespace {
constexpr int kCoverIconSourceSize = 32;
void drawScaledCoverIcon(const GfxRenderer& renderer, int x, int y, int size) {
if (size <= 0) return;
constexpr int bytesPerRow = kCoverIconSourceSize / 8;
for (int destY = 0; destY < size; ++destY) {
const int sourceY = destY * kCoverIconSourceSize / size;
for (int destX = 0; destX < size; ++destX) {
const int sourceX = destX * kCoverIconSourceSize / size;
const uint8_t rowByte = CoverIcon[sourceY * bytesPerRow + sourceX / 8];
const bool background = (rowByte >> (7 - (sourceX % 8))) & 0x01;
if (background) continue;
renderer.drawPixel(x + size - 1 - destY, y + destX, true);
}
}
}
} // namespace
void drawDefaultRecentCover(const GfxRenderer& renderer, freeink::ui::Rect rect, int placeholderIconSize) {
renderer.fillRect(rect.x, rect.y, rect.width, rect.height, false);
const freeink::ui::Rect coverRect = rect;
renderer.drawRect(coverRect.x, coverRect.y, coverRect.width, coverRect.height, true);
renderer.fillRect(coverRect.x, coverRect.y + coverRect.height / 3, coverRect.width, 2 * coverRect.height / 3, true);
const int whiteBandHeight = std::max(1, coverRect.height / 3);
const int maxIconSize = std::max(1, std::min({coverRect.width - 12, whiteBandHeight - 4, coverRect.height - 12}));
const int iconSize = std::min(placeholderIconSize > 0 ? placeholderIconSize : 32, maxIconSize);
drawScaledCoverIcon(renderer, coverRect.x + std::max(0, (coverRect.width - iconSize) / 2),
coverRect.y + std::max(0, (whiteBandHeight - iconSize) / 2), iconSize);
}
bool paintRecentBookCoverByIndex(freeink::ui::Rect rect, int bookIndex, void* userData) {
auto* data = static_cast<RecentBookCoverPainterData*>(userData);
if (data == nullptr || data->renderer == nullptr || data->books == nullptr) return false;
if (bookIndex < 0 || bookIndex >= static_cast<int>(data->books->size())) return false;
const RecentBook& book = (*data->books)[bookIndex];
if (book.coverBmpPath.empty()) {
drawDefaultRecentCover(*data->renderer, rect, data->placeholderIconSize);
return true;
}
const int thumbHeight = data->coverHeight > 0 ? data->coverHeight : rect.height;
const std::string coverBmpPath = UITheme::getCoverThumbPath(book.coverBmpPath, thumbHeight);
HalFile file;
if (!Storage.openFileForRead("HOME", coverBmpPath, file)) {
drawDefaultRecentCover(*data->renderer, rect, data->placeholderIconSize);
return true;
}
Bitmap bitmap(file);
if (bitmap.parseHeaders() != BmpReaderError::Ok) {
drawDefaultRecentCover(*data->renderer, rect, data->placeholderIconSize);
return true;
}
data->renderer->fillRect(rect.x, rect.y, rect.width, rect.height, false);
float cropX = 0.0f;
float cropY = 0.0f;
const float bitmapAspect = static_cast<float>(bitmap.getWidth()) / static_cast<float>(bitmap.getHeight());
const float targetAspect = static_cast<float>(rect.width) / static_cast<float>(rect.height);
if (bitmapAspect > targetAspect) {
cropX = std::max(0.0f, 1.0f - targetAspect / bitmapAspect);
} else if (bitmapAspect < targetAspect) {
cropY = std::max(0.0f, 1.0f - bitmapAspect / targetAspect);
}
data->renderer->drawBitmap(bitmap, rect.x, rect.y, rect.width, rect.height, cropX, cropY);
return true;
}
bool paintRecentCoverGridCover(freeink::ui::DrawTarget&, freeink::ui::Rect rect, const freeink::ui::CoverGridItem& item,
uint16_t, void* userData) {
return paintRecentBookCoverByIndex(rect, item.actionValue, userData);
}
bool paintBookCardCover(freeink::ui::DrawTarget&, freeink::ui::Rect rect, const freeink::ui::BookCardProps& props,
void* userData) {
return paintRecentBookCoverByIndex(rect, props.value, userData);
}
@@ -0,0 +1,22 @@
#pragma once
#include <FreeInkUI.h>
#include <vector>
class GfxRenderer;
struct RecentBook;
struct RecentBookCoverPainterData {
const GfxRenderer* renderer = nullptr;
const std::vector<RecentBook>* books = nullptr;
int coverHeight = 0;
int placeholderIconSize = 0;
};
void drawDefaultRecentCover(const GfxRenderer& renderer, freeink::ui::Rect rect, int placeholderIconSize = 0);
bool paintRecentBookCoverByIndex(freeink::ui::Rect rect, int bookIndex, void* userData);
bool paintRecentCoverGridCover(freeink::ui::DrawTarget& target, freeink::ui::Rect rect,
const freeink::ui::CoverGridItem& item, uint16_t index, void* userData);
bool paintBookCardCover(freeink::ui::DrawTarget& target, freeink::ui::Rect rect,
const freeink::ui::BookCardProps& props, void* userData);
+166 -31
View File
@@ -1,13 +1,17 @@
#include "RecentBooksActivity.h" #include "RecentBooksActivity.h"
#include <FreeInkUIGfxRenderer.h>
#include <GfxRenderer.h> #include <GfxRenderer.h>
#include <HalStorage.h> #include <HalStorage.h>
#include <I18n.h> #include <I18n.h>
#include <Logging.h>
#include <algorithm> #include <algorithm>
#include <memory> #include <memory>
#include <vector>
#include "MappedInputManager.h" #include "MappedInputManager.h"
#include "RecentBookCoverPainter.h"
#include "RecentBooksStore.h" #include "RecentBooksStore.h"
#include "activities/util/ConfirmationActivity.h" #include "activities/util/ConfirmationActivity.h"
#include "components/UITheme.h" #include "components/UITheme.h"
@@ -16,10 +20,118 @@
namespace { namespace {
// Hold threshold for the long-press "remove from list" action (firmware convention). // Hold threshold for the long-press "remove from list" action (firmware convention).
constexpr unsigned long LONG_PRESS_MS = 1000; constexpr unsigned long LONG_PRESS_MS = 1000;
struct RecentBooksRects {
Rect header;
Rect list;
Rect buttons;
bool themed = false;
};
struct RecentBooksCoverGridItemProviderData {
const std::vector<RecentBook>* recentBooks = nullptr;
};
freeink::ui::CoverGridItem provideRecentBooksCoverGridItem(uint16_t index, void* userData) {
auto* data = static_cast<RecentBooksCoverGridItemProviderData*>(userData);
if (data == nullptr || data->recentBooks == nullptr || index >= data->recentBooks->size()) return {};
return freeink::ui::coverGridItem((*data->recentBooks)[index].title.c_str(), index);
}
const ThemeCoverGridWidgetSpec* recentBooksCoverGridWidget(const ThemeScreenSpec* screenSpec) {
if (screenSpec == nullptr) return nullptr;
const auto it = std::find_if(screenSpec->widgets.begin(), screenSpec->widgets.end(),
[](const auto& widget) { return widget.type == ThemeScreenWidgetType::CoverGrid; });
return it == screenSpec->widgets.end() ? nullptr : &it->coverGrid;
}
ThemeCoverGridWidgetSpec normalizedRecentBooksCoverGridSpec(const ThemeCoverGridWidgetSpec& source) {
ThemeCoverGridWidgetSpec spec = source;
if (!spec.configured) {
spec.columns = 3;
spec.gap = 14;
spec.rowGap = 20;
spec.coverWidth = 92;
spec.coverHeight = 132;
spec.rowHeight = 172;
spec.labelHeight = 34;
spec.labelLines = 2;
spec.selectedRadius = 0;
spec.selectionStyle = ThemeWidgetSelectionStyle::CoverFrame;
spec.cellInset.top = 5;
spec.labelInset.left = 5;
spec.labelInset.right = 5;
}
spec.columns = std::max(1, spec.columns);
spec.rowGap = spec.rowGap >= 0 ? spec.rowGap : std::max(0, spec.gap);
spec.coverHeight = spec.coverHeight > 0 ? spec.coverHeight : 132;
spec.coverWidth = spec.coverWidth > 0 ? spec.coverWidth : std::max(1, spec.coverHeight * 62 / 100);
spec.placeholderIconSize = std::max(0, spec.placeholderIconSize);
spec.labelHeight = std::max(0, spec.labelHeight);
spec.labelGap = std::max(0, spec.labelGap);
spec.labelLines = std::max(1, std::min(3, spec.labelLines));
spec.rowHeight = spec.rowHeight > 0 ? spec.rowHeight : spec.coverHeight + spec.labelHeight + 6;
return spec;
}
RecentBooksRects resolveRecentBooksRects(GfxRenderer& renderer, const ThemeMetrics& metrics,
const ThemeScreenSpec*& screenSpec) {
const auto pageWidth = renderer.getScreenWidth();
const auto pageHeight = renderer.getScreenHeight();
RecentBooksRects rects;
if (screenSpec != nullptr) {
ThemeLayoutSlots slots;
layoutThemeSlots(screenSpec->layout, Rect{0, 0, pageWidth, pageHeight}, metrics, slots);
rects.header = normalizeThemeHeaderSlot(findThemeSlot(slots, "header"), metrics);
rects.list = findThemeSlot(slots, "list");
rects.buttons = findThemeSlot(slots, "buttons");
if (rects.list.width > 0 && rects.list.height > 0) {
rects.themed = true;
return rects;
}
LOG_ERR("RecentBooks", "Invalid SD recent layout: slots=%d; using built-in layout", static_cast<int>(slots.size()));
screenSpec = nullptr;
}
const int contentTop = metrics.topPadding + metrics.headerHeight + metrics.verticalSpacing;
const int contentHeight = pageHeight - contentTop - metrics.buttonHintsHeight - metrics.verticalSpacing;
rects.header = Rect{0, metrics.topPadding, pageWidth, metrics.headerHeight};
rects.list = Rect{0, contentTop, pageWidth, contentHeight};
rects.buttons = Rect{0, pageHeight - metrics.buttonHintsHeight, pageWidth, metrics.buttonHintsHeight};
return rects;
}
int recentBooksCoverGridPageItems(Rect listRect, const ThemeCoverGridWidgetSpec& spec) {
return std::max<int>(1, freeink::ui::coverGridVisibleCells(
freeink::ui::makeRect(listRect.x, listRect.y, listRect.width, listRect.height),
std::min<int>(std::max(1, spec.columns), 12), freeink::ui::clampI16(spec.rowHeight, 1),
freeink::ui::clampI16(spec.rowGap)));
}
freeink::ui::Insets toFreeInkInsets(const ThemeEdgeInsets& insets) {
return freeink::ui::makeInsets(insets.top, insets.right, insets.bottom, insets.left);
}
freeink::ui::StyleSet recentBooksGridStyles(const ThemeCoverGridWidgetSpec& spec) {
return freeink::ui::selectedOutlineListRowStyles(spec.selectedRadius);
}
} // namespace } // namespace
void RecentBooksActivity::loadRecentBooks() { recentBooks = RECENT_BOOKS.getBooks(); } void RecentBooksActivity::loadRecentBooks() { recentBooks = RECENT_BOOKS.getBooks(); }
int RecentBooksActivity::getPageItems() {
auto& theme = UITheme::getInstance();
const ThemeScreenSpec* screenSpec = theme.getScreenSpec(ThemeScreenKind::RecentBooks);
const auto rects = resolveRecentBooksRects(renderer, theme.getMetrics(), screenSpec);
if (rects.themed) {
const ThemeCoverGridWidgetSpec* grid = recentBooksCoverGridWidget(screenSpec);
if (grid != nullptr) return recentBooksCoverGridPageItems(rects.list, normalizedRecentBooksCoverGridSpec(*grid));
}
return theme.getNumberOfItemsPerPage(renderer, true, false, true, true);
}
void RecentBooksActivity::onEnter() { void RecentBooksActivity::onEnter() {
Activity::onEnter(); Activity::onEnter();
@@ -42,15 +154,7 @@ void RecentBooksActivity::onExit() {
} }
void RecentBooksActivity::loop() { void RecentBooksActivity::loop() {
const int pageItems = UITheme::getInstance().getNumberOfItemsPerPage(renderer, true, false, true, true); const int pageItems = getPageItems();
// Vertical swipe page-scrolls the list (touch nav without the side buttons).
int scrollIdx = static_cast<int>(selectorIndex);
if (mappedInput.wasListScroll(scrollIdx, static_cast<int>(recentBooks.size()), pageItems)) {
selectorIndex = scrollIdx;
requestUpdate();
return;
}
// After a long-press has fired, swallow input until Confirm is physically released // After a long-press has fired, swallow input until Confirm is physically released
// (so the release doesn't also open the book; re-arm only once the button is up). // (so the release doesn't also open the book; re-arm only once the button is up).
@@ -71,16 +175,7 @@ void RecentBooksActivity::loop() {
return; return;
} }
int downId = -1; if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
if (mappedInput.wasItemTouchedDown(downId) && downId >= 0 && downId < static_cast<int>(recentBooks.size())) {
selectorIndex = downId;
requestUpdate();
}
int tappedId = -1;
const bool tapped = mappedInput.wasItemTapped(tappedId);
if (tapped && tappedId >= 0 && tappedId < static_cast<int>(recentBooks.size())) selectorIndex = tappedId;
if (tapped || mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
if (!recentBooks.empty() && selectorIndex < static_cast<int>(recentBooks.size())) { if (!recentBooks.empty() && selectorIndex < static_cast<int>(recentBooks.size())) {
LOG_DBG("RBA", "Selected recent book: %s", recentBooks[selectorIndex].path.c_str()); LOG_DBG("RBA", "Selected recent book: %s", recentBooks[selectorIndex].path.c_str());
onSelectBook(recentBooks[selectorIndex].path); onSelectBook(recentBooks[selectorIndex].path);
@@ -141,28 +236,68 @@ void RecentBooksActivity::promptRemoveBook(const std::string& path, const std::s
void RecentBooksActivity::render(RenderLock&&) { void RecentBooksActivity::render(RenderLock&&) {
renderer.clearScreen(); renderer.clearScreen();
const auto pageWidth = renderer.getScreenWidth(); auto& theme = UITheme::getInstance();
const auto pageHeight = renderer.getScreenHeight(); const auto& metrics = theme.getMetrics();
const auto& metrics = UITheme::getInstance().getMetrics(); const ThemeScreenSpec* screenSpec = theme.getScreenSpec(ThemeScreenKind::RecentBooks);
const auto rects = resolveRecentBooksRects(renderer, metrics, screenSpec);
const ThemeCoverGridWidgetSpec* coverGridWidget = rects.themed ? recentBooksCoverGridWidget(screenSpec) : nullptr;
GUI.drawHeader(renderer, Rect{0, metrics.topPadding, pageWidth, metrics.headerHeight}, tr(STR_MENU_RECENT_BOOKS)); if (rects.header.width > 0 && rects.header.height > 0) {
GUI.drawHeader(renderer, rects.header, tr(STR_MENU_RECENT_BOOKS));
const int contentTop = metrics.topPadding + metrics.headerHeight + metrics.verticalSpacing; }
const int contentHeight = pageHeight - contentTop - metrics.buttonHintsHeight - metrics.verticalSpacing;
// Recent tab // Recent tab
if (recentBooks.empty()) { if (rects.list.width <= 0 || rects.list.height <= 0) {
renderer.drawText(UI_10_FONT_ID, metrics.contentSidePadding, contentTop + 20, tr(STR_NO_RECENT_BOOKS)); // Malformed theme layout: no list slot to draw into.
} else if (recentBooks.empty()) {
renderer.drawText(UI_10_FONT_ID, metrics.contentSidePadding, rects.list.y + 20, tr(STR_NO_RECENT_BOOKS));
} else if (coverGridWidget != nullptr) {
#if FREEINK_HAVE_GFX_RENDERER
const auto gridSpec = normalizedRecentBooksCoverGridSpec(*coverGridWidget);
freeink::ui::GfxRendererFrame<> ui(renderer, SMALL_FONT_ID, UI_10_FONT_ID, UI_12_FONT_ID);
RecentBookCoverPainterData painterData{
&renderer, &recentBooks, UITheme::getInstance().getRecentBooksCoverThumbHeight(), gridSpec.placeholderIconSize};
RecentBooksCoverGridItemProviderData itemProviderData{&recentBooks};
const int pageItems = recentBooksCoverGridPageItems(rects.list, gridSpec);
freeink::ui::CoverGridProps props;
props.itemProvider = provideRecentBooksCoverGridItem;
props.itemProviderUserData = &itemProviderData;
props.count = static_cast<uint16_t>(std::min<size_t>(recentBooks.size(), 65535));
props.topIndex = freeink::ui::coverGridTopIndexFor(
static_cast<uint16_t>(selectorIndex), static_cast<uint16_t>(std::min<size_t>(recentBooks.size(), 65535)),
std::min<int>(std::max(1, gridSpec.columns), 12), static_cast<uint16_t>(pageItems));
props.selectedIndex = static_cast<int16_t>(selectorIndex);
props.columns = static_cast<uint8_t>(std::min(std::max(1, gridSpec.columns), 12));
props.gap = freeink::ui::clampI16(gridSpec.gap);
props.rowGap = freeink::ui::clampI16(gridSpec.rowGap);
props.cellInset = toFreeInkInsets(gridSpec.cellInset);
props.labelInset = toFreeInkInsets(gridSpec.labelInset);
props.coverSize = freeink::ui::makeSize(gridSpec.coverWidth, gridSpec.coverHeight);
props.rowHeight = freeink::ui::clampI16(gridSpec.rowHeight, 1);
props.labelHeight = freeink::ui::clampI16(gridSpec.labelHeight);
props.labelGap = freeink::ui::clampI16(gridSpec.labelGap);
props.titleText.font = freeink::ui::GfxRendererTarget::FONT_SMALL;
props.titleText.maxLines = static_cast<uint8_t>(std::max(1, std::min(3, gridSpec.labelLines)));
props.cellStyles = recentBooksGridStyles(gridSpec);
props.selectionIndicator = freeink::ui::CoverGridSelectionIndicator::CoverFrame;
props.selectedCoverFrameRadius = freeink::ui::clampRadius(gridSpec.selectedRadius);
props.coverPainter = paintRecentCoverGridCover;
props.coverPainterUserData = &painterData;
freeink::ui::coverGrid(
ui.frame, freeink::ui::makeRect(rects.list.x, rects.list.y, rects.list.width, rects.list.height), props);
#endif
} else { } else {
GUI.drawList( GUI.drawList(
renderer, Rect{0, contentTop, pageWidth, contentHeight}, recentBooks.size(), selectorIndex, renderer, rects.list, recentBooks.size(), selectorIndex, [this](int index) { return recentBooks[index].title; },
[this](int index) { return recentBooks[index].title; }, [this](int index) { return recentBooks[index].author; }, [this](int index) { return recentBooks[index].author; },
[this](int index) { return UITheme::getFileIcon(recentBooks[index].path); }); [this](int index) { return UITheme::getFileIcon(recentBooks[index].path); });
} }
// Help text // Help text
const auto labels = mappedInput.mapLabels(tr(STR_HOME), tr(STR_OPEN), tr(STR_DIR_UP), tr(STR_DIR_DOWN)); const auto labels = mappedInput.mapLabels(tr(STR_HOME), tr(STR_OPEN), tr(STR_DIR_UP), tr(STR_DIR_DOWN));
GUI.drawButtonHints(renderer, labels.btn1, labels.btn2, labels.btn3, labels.btn4); if (rects.buttons.width > 0 && rects.buttons.height > 0) {
GUI.drawButtonHints(renderer, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
}
renderer.displayBuffer(); renderer.displayBuffer();
} }
@@ -24,6 +24,7 @@ class RecentBooksActivity final : public Activity {
// Data loading // Data loading
void loadRecentBooks(); void loadRecentBooks();
int getPageItems();
// Show an OK/Cancel prompt to remove the given book from the Recent Books list. // Show an OK/Cancel prompt to remove the given book from the Recent Books list.
void promptRemoveBook(const std::string& path, const std::string& title); void promptRemoveBook(const std::string& path, const std::string& title);
+561
View File
@@ -0,0 +1,561 @@
#include "ThemeHomeRenderer.h"
#include <FreeInkUIGfxRenderer.h>
#include <GfxRenderer.h>
#include <HalClock.h>
#include <I18n.h>
#include <Logging.h>
#include <algorithm>
#include <array>
#include <cstring>
#include <vector>
#include "CrossPointSettings.h"
#include "MappedInputManager.h"
#include "RecentBookCoverPainter.h"
#include "RecentBooksStore.h"
#include "components/UITheme.h"
#include "components/icons/book.h"
#include "components/icons/folder.h"
#include "components/icons/library.h"
#include "components/icons/recent.h"
#include "components/icons/settings2.h"
#include "components/icons/transfer.h"
#include "fontIds.h"
namespace {
constexpr int kCoverCacheBleed = 12;
const char* defaultLauncherLabel(ThemeHomeAction action) {
switch (action) {
case ThemeHomeAction::RecentBooks:
return tr(STR_MENU_RECENT_BOOKS);
case ThemeHomeAction::OpdsBrowser:
return tr(STR_OPDS_BROWSER);
case ThemeHomeAction::FileTransfer:
return tr(STR_FILE_TRANSFER);
case ThemeHomeAction::Settings:
return tr(STR_SETTINGS_TITLE);
case ThemeHomeAction::RecentBook:
return tr(STR_CONTINUE_READING);
case ThemeHomeAction::FileBrowser:
default:
return tr(STR_BROWSE_FILES);
}
}
const char* buttonHintLabel(ThemeButtonHintLabel label, const char* fallback) {
switch (label) {
case ThemeButtonHintLabel::Empty:
return "";
case ThemeButtonHintLabel::Back:
return tr(STR_BACK);
case ThemeButtonHintLabel::Home:
return tr(STR_HOME);
case ThemeButtonHintLabel::Select:
return tr(STR_SELECT);
case ThemeButtonHintLabel::Confirm:
return tr(STR_CONFIRM);
case ThemeButtonHintLabel::Open:
return tr(STR_OPEN);
case ThemeButtonHintLabel::Toggle:
return tr(STR_TOGGLE);
case ThemeButtonHintLabel::Up:
return tr(STR_DIR_UP);
case ThemeButtonHintLabel::Down:
return tr(STR_DIR_DOWN);
case ThemeButtonHintLabel::Left:
return tr(STR_DIR_LEFT);
case ThemeButtonHintLabel::Right:
return tr(STR_DIR_RIGHT);
case ThemeButtonHintLabel::Default:
default:
return fallback;
}
}
UIIcon defaultLauncherIcon(ThemeHomeAction action) {
switch (action) {
case ThemeHomeAction::RecentBooks:
return UIIcon::Recent;
case ThemeHomeAction::OpdsBrowser:
return UIIcon::Library;
case ThemeHomeAction::FileTransfer:
return UIIcon::Transfer;
case ThemeHomeAction::Settings:
return UIIcon::Settings;
case ThemeHomeAction::RecentBook:
return UIIcon::Book;
case ThemeHomeAction::FileBrowser:
default:
return UIIcon::Folder;
}
}
std::string homeHeaderTitle(const ThemeMetrics& metrics, const std::vector<RecentBook>& recentBooks,
const int coverSelectorIndex) {
if (metrics.homeContinueReadingInMenu && metrics.homeShowContinueReadingHeader && !recentBooks.empty()) {
return recentBooks[std::min(coverSelectorIndex, static_cast<int>(recentBooks.size()) - 1)].title;
}
return "";
}
Rect placedWidgetRect(Rect slot, const ThemeHomeWidgetSpec& widget) {
slot.x += widget.offsetX - widget.bleed.left;
slot.y += widget.offsetY - widget.bleed.top;
slot.width += widget.bleed.left + widget.bleed.right;
slot.height += widget.bleed.top + widget.bleed.bottom;
slot.x += widget.inset.left;
slot.y += widget.inset.top;
slot.width -= widget.inset.left + widget.inset.right;
slot.height -= widget.inset.top + widget.inset.bottom;
return slot;
}
freeink::ui::Insets toFreeInkInsets(const ThemeEdgeInsets& insets) {
return freeink::ui::makeInsets(insets.top, insets.right, insets.bottom, insets.left);
}
freeink::ui::StyleSet widgetSelectionStyles(ThemeWidgetSelectionStyle selectionStyle, int selectedRadius) {
if (selectionStyle == ThemeWidgetSelectionStyle::Outline) {
return freeink::ui::selectedOutlineListRowStyles(selectedRadius);
}
if (selectionStyle == ThemeWidgetSelectionStyle::None) return freeink::ui::selectedPlainListRowStyles();
return freeink::ui::defaultListRowStyles();
}
freeink::ui::CoverGridSelectionIndicator coverGridSelectionIndicator(ThemeWidgetSelectionStyle selectionStyle) {
return selectionStyle == ThemeWidgetSelectionStyle::CoverFrame ? freeink::ui::CoverGridSelectionIndicator::CoverFrame
: freeink::ui::CoverGridSelectionIndicator::Cell;
}
const uint8_t* homeTabIcon(UIIcon icon) {
switch (icon) {
case UIIcon::Folder:
return FolderIcon;
case UIIcon::Book:
return BookIcon;
case UIIcon::Recent:
return RecentIcon;
case UIIcon::Library:
return LibraryIcon;
case UIIcon::Transfer:
return TransferIcon;
case UIIcon::Settings:
return Settings2Icon;
default:
return nullptr;
}
}
struct HomeIconTabPainterData {
const GfxRenderer* renderer = nullptr;
const ThemeHomeLauncherSpec* const* launchers = nullptr;
size_t launcherCount = 0;
};
struct HomeCoverGridItemProviderData {
const std::vector<RecentBook>* recentBooks = nullptr;
int startIndex = 0;
};
freeink::ui::CoverGridItem provideHomeCoverGridItem(uint16_t index, void* userData) {
auto* data = static_cast<HomeCoverGridItemProviderData*>(userData);
if (data == nullptr || data->recentBooks == nullptr) return {};
const int bookIndex = data->startIndex + static_cast<int>(index);
if (bookIndex < 0 || bookIndex >= static_cast<int>(data->recentBooks->size())) return {};
return freeink::ui::coverGridItem((*data->recentBooks)[bookIndex].title.c_str(), bookIndex);
}
bool paintHomeIconTab(freeink::ui::DrawTarget&, freeink::ui::Rect rect, const freeink::ui::TabItem& tab, uint8_t,
void* userData) {
auto* data = static_cast<HomeIconTabPainterData*>(userData);
if (data == nullptr || data->renderer == nullptr || data->launchers == nullptr) return false;
const int index = tab.value;
if (index < 0 || index >= static_cast<int>(data->launcherCount)) return false;
const auto& launcher = *data->launchers[index];
const uint8_t* icon =
homeTabIcon(launcher.icon == UIIcon::None ? defaultLauncherIcon(launcher.action) : launcher.icon);
if (icon == nullptr) return false;
data->renderer->drawIcon(icon, rect.x, rect.y, rect.width, rect.height);
return true;
}
struct WidgetRenderEntry {
const ThemeHomeWidgetSpec* widget;
int actionOffset;
size_t order;
};
struct WidgetRenderEntries {
std::array<WidgetRenderEntry, kMaxThemeWidgets> items;
size_t count = 0;
void push(const WidgetRenderEntry& entry) {
if (count >= items.size()) return;
items[count++] = entry;
}
};
bool themeHomeActionVisible(ThemeHomeAction action, bool hasOpdsServers, bool hasRecentBooks) {
if (action == ThemeHomeAction::OpdsBrowser) return hasOpdsServers;
if (action == ThemeHomeAction::RecentBook) return hasRecentBooks;
return true;
}
WidgetRenderEntries buildRenderEntries(const ThemeHomeScreenSpec& spec, const std::vector<RecentBook>& recentBooks,
bool hasOpdsServers) {
WidgetRenderEntries entries;
int nextActionOffset = 0;
for (size_t i = 0; i < spec.widgets.size(); ++i) {
const auto& widget = spec.widgets[i];
const int widgetActionOffset = nextActionOffset;
if (widget.type == ThemeHomeWidgetType::Recents) {
nextActionOffset += static_cast<int>(recentBooks.size());
} else if (widget.type == ThemeHomeWidgetType::FeaturedBookCard) {
if (std::max(0, widget.featured.startIndex) < static_cast<int>(recentBooks.size())) ++nextActionOffset;
} else if (widget.type == ThemeHomeWidgetType::RecentCoverGrid) {
const int maxItems = widget.coverGrid.rows > 0 ? widget.coverGrid.rows * std::max(1, widget.coverGrid.columns)
: static_cast<int>(recentBooks.size());
const int startIndex = std::max(0, widget.coverGrid.startIndex);
nextActionOffset += std::min({std::max(0, static_cast<int>(recentBooks.size()) - startIndex), maxItems,
static_cast<int>(kMaxThemeCoverGridItems)});
} else if (widget.type == ThemeHomeWidgetType::LauncherList || widget.type == ThemeHomeWidgetType::LauncherGrid) {
nextActionOffset += static_cast<int>(
std::count_if(widget.launcher.items.begin(), widget.launcher.items.end(), [&](const auto& launcher) {
return themeHomeActionVisible(launcher.action, hasOpdsServers, !recentBooks.empty());
}));
}
entries.push(WidgetRenderEntry{&widget, widgetActionOffset, i});
}
std::stable_sort(entries.items.begin(), entries.items.begin() + entries.count, [](const auto& a, const auto& b) {
if (a.widget->layer != b.widget->layer) return a.widget->layer < b.widget->layer;
return a.order < b.order;
});
return entries;
}
} // namespace
void buildThemeHomeActions(const ThemeHomeScreenSpec* spec, const std::vector<RecentBook>& recentBooks,
bool hasOpdsServers, std::vector<ThemeHomeActionEntry>& actions) {
actions.clear();
if (spec != nullptr) {
for (const auto& widget : spec->widgets) {
if (widget.type == ThemeHomeWidgetType::Recents) {
for (int i = 0; i < static_cast<int>(recentBooks.size()); ++i) {
actions.push_back(ThemeHomeActionEntry{ThemeHomeAction::RecentBook, i});
}
} else if (widget.type == ThemeHomeWidgetType::FeaturedBookCard) {
const int index = std::max(0, widget.featured.startIndex);
if (index < static_cast<int>(recentBooks.size())) {
actions.push_back(ThemeHomeActionEntry{ThemeHomeAction::RecentBook, index});
}
} else if (widget.type == ThemeHomeWidgetType::RecentCoverGrid) {
const int maxItems = widget.coverGrid.rows > 0 ? widget.coverGrid.rows * std::max(1, widget.coverGrid.columns)
: static_cast<int>(recentBooks.size());
const int startIndex = std::max(0, widget.coverGrid.startIndex);
for (int i = 0; startIndex + i < static_cast<int>(recentBooks.size()) && i < maxItems &&
i < static_cast<int>(kMaxThemeCoverGridItems);
++i) {
actions.push_back(ThemeHomeActionEntry{ThemeHomeAction::RecentBook, startIndex + i});
}
} else if (widget.type == ThemeHomeWidgetType::LauncherList || widget.type == ThemeHomeWidgetType::LauncherGrid) {
for (const auto& launcher : widget.launcher.items) {
if (themeHomeActionVisible(launcher.action, hasOpdsServers, !recentBooks.empty())) {
actions.push_back(ThemeHomeActionEntry{launcher.action, 0});
}
}
}
}
if (!actions.empty()) return;
}
for (int i = 0; i < static_cast<int>(recentBooks.size()); ++i) {
actions.push_back(ThemeHomeActionEntry{ThemeHomeAction::RecentBook, i});
}
actions.push_back(ThemeHomeActionEntry{ThemeHomeAction::FileBrowser, 0});
actions.push_back(ThemeHomeActionEntry{ThemeHomeAction::RecentBooks, 0});
if (hasOpdsServers) actions.push_back(ThemeHomeActionEntry{ThemeHomeAction::OpdsBrowser, 0});
actions.push_back(ThemeHomeActionEntry{ThemeHomeAction::FileTransfer, 0});
actions.push_back(ThemeHomeActionEntry{ThemeHomeAction::Settings, 0});
}
bool renderThemeHome(ThemeHomeRenderContext& ctx) {
const auto pageWidth = ctx.renderer.getScreenWidth();
const auto pageHeight = ctx.renderer.getScreenHeight();
ThemeLayoutSlots slots;
layoutThemeSlots(ctx.spec.layout, Rect{0, 0, pageWidth, pageHeight}, ctx.metrics, slots);
if (slots.empty()) {
const auto& layout = ctx.spec.layout;
const auto& first = layout.children.empty() ? layout : layout.children.front();
LOG_ERR("HOME",
"SD home layout emitted no slots: page=%dx%d children=%d firstId=%s firstType=%d firstSize=%d firstFlex=%d",
pageWidth, pageHeight, static_cast<int>(layout.children.size()), first.id.c_str(),
static_cast<int>(first.sizeType), first.size, first.flex);
}
const bool sdHomeUsable = !slots.empty() && !ctx.actions.empty();
if (!sdHomeUsable) {
LOG_ERR("HOME", "Invalid SD home layout: widgets=%d slots=%d actions=%d; using built-in layout",
static_cast<int>(ctx.spec.widgets.size()), static_cast<int>(slots.size()),
static_cast<int>(ctx.actions.size()));
return false;
}
ctx.renderer.clearScreen();
ctx.coverRectX = 0;
ctx.coverRectY = 0;
ctx.coverRectW = 0;
ctx.coverRectH = 0;
const auto renderWidgets = buildRenderEntries(ctx.spec, ctx.recentBooks, ctx.hasOpdsServers);
for (size_t renderIndex = 0; renderIndex < renderWidgets.count; ++renderIndex) {
const auto& entry = renderWidgets.items[renderIndex];
const auto& widget = *entry.widget;
Rect slot = placedWidgetRect(findThemeSlot(slots, widget.slot), widget);
if (slot.width <= 0 || slot.height <= 0) continue;
if (widget.type == ThemeHomeWidgetType::Header) {
const auto title = homeHeaderTitle(ctx.metrics, ctx.recentBooks, ctx.coverSelectorIndex);
GUI.drawHeader(ctx.renderer, slot, title.empty() ? nullptr : title.c_str());
} else if (widget.type == ThemeHomeWidgetType::HeaderTitle) {
const auto title = homeHeaderTitle(ctx.metrics, ctx.recentBooks, ctx.coverSelectorIndex);
if (!title.empty()) {
const auto truncated = ctx.renderer.truncatedText(UI_10_FONT_ID, title.c_str(), slot.width);
const int textWidth = ctx.renderer.getTextWidth(UI_10_FONT_ID, truncated.c_str());
ctx.renderer.drawText(UI_10_FONT_ID, slot.x + std::max(0, (slot.width - textWidth) / 2),
slot.y + std::max(0, (slot.height - ctx.renderer.getLineHeight(UI_10_FONT_ID)) / 2),
truncated.c_str());
}
} else if (widget.type == ThemeHomeWidgetType::Battery) {
const bool showBatteryPercentage =
SETTINGS.hideBatteryPercentage != CrossPointSettings::HIDE_BATTERY_PERCENTAGE::HIDE_ALWAYS;
const int batteryX = slot.x + std::max(0, slot.width - ctx.metrics.batteryWidth);
GUI.drawBatteryRight(ctx.renderer, Rect{batteryX, slot.y, ctx.metrics.batteryWidth, ctx.metrics.batteryHeight},
showBatteryPercentage);
} else if (widget.type == ThemeHomeWidgetType::Clock) {
if (halClock.isAvailable()) {
char timeBuf[9];
if (halClock.formatTime(timeBuf, sizeof(timeBuf), SETTINGS.clockUtcOffsetQ, SETTINGS.clockFormat == 1)) {
auto clockText = ctx.renderer.truncatedText(SMALL_FONT_ID, timeBuf, slot.width);
const int textWidth = ctx.renderer.getTextWidth(SMALL_FONT_ID, clockText.c_str());
ctx.renderer.drawText(SMALL_FONT_ID, slot.x + std::max(0, (slot.width - textWidth) / 2), slot.y,
clockText.c_str());
}
}
} else if (widget.type == ThemeHomeWidgetType::Recents) {
const bool hasCoverArea = slot.height > 0 && ctx.metrics.homeCoverHeight > 0;
ctx.coverRectX = 0;
ctx.coverRectY = std::max(0, slot.y - kCoverCacheBleed);
ctx.coverRectW = pageWidth;
ctx.coverRectH =
std::min(pageHeight - ctx.coverRectY, slot.height + (slot.y - ctx.coverRectY) + kCoverCacheBleed);
const bool selectorSensitiveCoverCache = GUI.homeCoverCacheDependsOnSelector();
const bool coverStripSelected = ctx.selectorIndex >= entry.actionOffset &&
ctx.selectorIndex < entry.actionOffset + static_cast<int>(ctx.recentBooks.size());
if (coverStripSelected) {
ctx.coverSelectorIndex = ctx.actions[ctx.selectorIndex].value;
}
const bool coverCacheMatches =
!selectorSensitiveCoverCache || (ctx.coverBufferSelectorIndex == ctx.coverSelectorIndex &&
ctx.coverBufferStripSelected == coverStripSelected);
if (hasCoverArea && ctx.coverBufferStored && !coverCacheMatches) {
ctx.coverBufferStored = false;
ctx.coverRendered = false;
}
bool bufferRestored = hasCoverArea && ctx.coverBufferStored && coverCacheMatches &&
ctx.restoreCoverBuffer != nullptr && ctx.restoreCoverBuffer(ctx.coverBufferUserData);
if (hasCoverArea) {
GUI.drawRecentBookCover(
ctx.renderer, slot, ctx.recentBooks, ctx.coverSelectorIndex, ctx.coverRendered, ctx.coverBufferStored,
bufferRestored,
[store = ctx.storeCoverBuffer, userData = ctx.coverBufferUserData]() {
return store != nullptr && store(userData);
},
coverStripSelected);
}
} else if (widget.type == ThemeHomeWidgetType::FeaturedBookCard) {
const int bookIndex = std::max(0, widget.featured.startIndex);
if (bookIndex < static_cast<int>(ctx.recentBooks.size())) {
const bool selected = ctx.selectorIndex >= entry.actionOffset && ctx.selectorIndex < entry.actionOffset + 1 &&
ctx.actions[ctx.selectorIndex].value == bookIndex;
ctx.renderer.drawText(UI_10_FONT_ID, slot.x, slot.y, tr(STR_CONTINUE_READING), true, EpdFontFamily::BOLD);
#if FREEINK_HAVE_GFX_RENDERER
const int labelH = ctx.renderer.getLineHeight(UI_10_FONT_ID) + std::max(0, widget.featured.titleGap);
const int coverHeight =
widget.featured.coverHeight > 0 ? widget.featured.coverHeight : std::max(1, slot.height - labelH - 8);
const int coverWidth =
widget.featured.coverWidth > 0 ? widget.featured.coverWidth : std::max(1, coverHeight * 62 / 100);
freeink::ui::GfxRendererFrame<> ui(ctx.renderer, SMALL_FONT_ID, UI_10_FONT_ID, UI_12_FONT_ID);
RecentBookCoverPainterData painterData{&ctx.renderer, &ctx.recentBooks,
UITheme::getInstance().getHomeCoverThumbHeight(),
widget.featured.placeholderIconSize};
freeink::ui::BookCardProps props;
props.title = ctx.recentBooks[bookIndex].title.c_str();
props.author = ctx.recentBooks[bookIndex].author.c_str();
props.progressMax = 0;
props.value = static_cast<int16_t>(bookIndex);
props.state = selected ? freeink::ui::StateSelected : freeink::ui::StateNormal;
props.coverSize = freeink::ui::makeSize(coverWidth, coverHeight);
props.padding = freeink::ui::makeInsets(0);
props.gap = freeink::ui::clampI16(widget.featured.coverGap);
props.titleText.font = freeink::ui::GfxRendererTarget::FONT_TITLE;
props.titleText.maxLines = 2;
props.authorText.font = freeink::ui::GfxRendererTarget::FONT_BODY;
props.centerTextVertically = true;
props.selectionIndicator = freeink::ui::BookCardSelectionIndicator::CoverFrame;
props.selectedCoverFrameRadius = freeink::ui::clampRadius(widget.featured.selectedRadius);
props.coverPainter = paintBookCardCover;
props.coverPainterUserData = &painterData;
freeink::ui::StyleSet styles =
widgetSelectionStyles(ThemeWidgetSelectionStyle::Outline, widget.featured.selectedRadius);
styles.normal.background = freeink::ui::Paint::solid(freeink::ui::Color::White);
props.styles = styles;
const int cardH = std::min(std::max(1, slot.height - labelH), coverHeight);
freeink::ui::bookCard(ui.frame, freeink::ui::makeRect(slot.x, slot.y + labelH, slot.width, cardH), props);
#endif
}
} else if (widget.type == ThemeHomeWidgetType::RecentCoverGrid) {
const int columns = std::max(1, widget.coverGrid.columns);
const int rows = widget.coverGrid.rows > 0
? widget.coverGrid.rows
: std::max(1, (static_cast<int>(ctx.recentBooks.size()) + columns - 1) / columns);
const int startIndex = std::max(0, widget.coverGrid.startIndex);
const int maxItems = std::min({std::max(0, static_cast<int>(ctx.recentBooks.size()) - startIndex), rows * columns,
static_cast<int>(kMaxThemeCoverGridItems)});
if (maxItems > 0) {
const int selectedLocal =
ctx.selectorIndex >= entry.actionOffset && ctx.selectorIndex < entry.actionOffset + maxItems
? ctx.actions[ctx.selectorIndex].value - startIndex
: -1;
const int coverHeight =
widget.coverGrid.coverHeight > 0
? widget.coverGrid.coverHeight
: std::max(1, (slot.height - std::max(0, widget.coverGrid.gap) * (rows - 1)) / rows -
widget.coverGrid.labelHeight);
const int coverWidth =
widget.coverGrid.coverWidth > 0 ? widget.coverGrid.coverWidth : std::max(1, coverHeight * 62 / 100);
const int rowHeight = widget.coverGrid.rowHeight > 0
? widget.coverGrid.rowHeight
: coverHeight + std::max(0, widget.coverGrid.labelHeight) + 6;
#if FREEINK_HAVE_GFX_RENDERER
freeink::ui::GfxRendererFrame<> ui(ctx.renderer, SMALL_FONT_ID, UI_10_FONT_ID, UI_12_FONT_ID);
RecentBookCoverPainterData painterData{&ctx.renderer, &ctx.recentBooks,
UITheme::getInstance().getHomeCoverThumbHeight(),
widget.coverGrid.placeholderIconSize};
HomeCoverGridItemProviderData itemProviderData{&ctx.recentBooks, startIndex};
freeink::ui::CoverGridProps props;
props.itemProvider = provideHomeCoverGridItem;
props.itemProviderUserData = &itemProviderData;
props.count = static_cast<uint16_t>(maxItems);
props.selectedIndex = static_cast<int16_t>(selectedLocal);
props.columns = static_cast<uint8_t>(std::min(columns, 12));
props.gap = freeink::ui::clampI16(widget.coverGrid.gap);
props.rowGap =
freeink::ui::clampI16(widget.coverGrid.rowGap >= 0 ? widget.coverGrid.rowGap : widget.coverGrid.gap);
props.cellInset = toFreeInkInsets(widget.coverGrid.cellInset);
props.labelInset = toFreeInkInsets(widget.coverGrid.labelInset);
props.coverSize = freeink::ui::makeSize(coverWidth, coverHeight);
props.rowHeight = freeink::ui::clampI16(rowHeight, 1);
props.labelHeight = freeink::ui::clampI16(widget.coverGrid.labelHeight);
props.labelGap = freeink::ui::clampI16(widget.coverGrid.labelGap);
props.titleText.font = freeink::ui::GfxRendererTarget::FONT_SMALL;
props.titleText.maxLines = static_cast<uint8_t>(std::max(1, std::min(3, widget.coverGrid.labelLines)));
props.cellStyles = widgetSelectionStyles(widget.coverGrid.selectionStyle, widget.coverGrid.selectedRadius);
props.selectionIndicator = coverGridSelectionIndicator(widget.coverGrid.selectionStyle);
props.selectedCoverFrameRadius = freeink::ui::clampRadius(widget.coverGrid.selectedRadius);
props.coverPainter = paintRecentCoverGridCover;
props.coverPainterUserData = &painterData;
freeink::ui::coverGrid(ui.frame, freeink::ui::makeRect(slot.x, slot.y, slot.width, slot.height), props);
#endif
}
} else if (widget.type == ThemeHomeWidgetType::LauncherList || widget.type == ThemeHomeWidgetType::LauncherGrid) {
std::array<const ThemeHomeLauncherSpec*, kMaxThemeLauncherItems> launchers;
size_t launcherCount = 0;
for (const auto& launcher : widget.launcher.items) {
if (themeHomeActionVisible(launcher.action, ctx.hasOpdsServers, !ctx.recentBooks.empty())) {
if (launcherCount < launchers.size()) launchers[launcherCount++] = &launcher;
}
}
const int selectedLocal = ctx.selectorIndex >= entry.actionOffset &&
ctx.selectorIndex < entry.actionOffset + static_cast<int>(launcherCount)
? ctx.selectorIndex - entry.actionOffset
: -1;
if (widget.launcher.presentation == ThemeLauncherPresentation::IconTabs) {
#if FREEINK_HAVE_GFX_RENDERER
std::array<freeink::ui::TabItem, kMaxThemeLauncherItems> items;
size_t itemCount = 0;
for (int i = 0; i < static_cast<int>(launcherCount); ++i) {
items[itemCount++] = freeink::ui::tabItem(i, selectedLocal == i);
}
freeink::ui::GfxRendererFrame<> ui(ctx.renderer, SMALL_FONT_ID, UI_10_FONT_ID, UI_12_FONT_ID);
freeink::ui::StyleSet styles = freeink::ui::outlinedButtonStyles(widget.launcher.selectedRadius);
HomeIconTabPainterData painterData{&ctx.renderer, launchers.data(), launcherCount};
freeink::ui::TabBarProps props;
props.tabs = items.data();
props.count = static_cast<uint8_t>(std::min<size_t>(itemCount, 255));
props.tabStyles = styles;
props.gap = freeink::ui::clampI16(widget.launcher.gap);
props.iconSize = freeink::ui::clampI16(widget.launcher.iconSize, 1);
props.tabInset = freeink::ui::makeInsets(4);
props.iconPainter = paintHomeIconTab;
props.iconPainterUserData = &painterData;
freeink::ui::tabBar(ui.frame, freeink::ui::makeRect(slot.x, slot.y, slot.width, slot.height), props);
#endif
} else if (widget.type == ThemeHomeWidgetType::LauncherGrid) {
const int columns = std::max(1, widget.launcher.columns);
const int rows = widget.launcher.rows > 0
? widget.launcher.rows
: std::max(1, (static_cast<int>(launcherCount) + columns - 1) / columns);
const int gap = std::max(0, widget.launcher.gap);
const int cellW = std::max(1, (slot.width - gap * (columns - 1)) / columns);
const int cellH = std::max(1, (slot.height - gap * (rows - 1)) / rows);
for (int i = 0; i < static_cast<int>(launcherCount); ++i) {
const int col = i % columns;
const int row = i / columns;
if (row >= rows) break;
Rect cell{slot.x + col * (cellW + gap), slot.y + row * (cellH + gap),
col == columns - 1 ? slot.x + slot.width - (slot.x + col * (cellW + gap)) : cellW, cellH};
GUI.drawButtonMenu(
ctx.renderer, cell, 1, selectedLocal == i ? 0 : -1,
[&launchers, i](int) {
return launchers[i]->text.empty() ? std::string(defaultLauncherLabel(launchers[i]->action))
: launchers[i]->text;
},
[&launchers, i](int) {
return launchers[i]->icon == UIIcon::None ? defaultLauncherIcon(launchers[i]->action)
: launchers[i]->icon;
});
}
} else {
GUI.drawButtonMenu(
ctx.renderer, slot, static_cast<int>(launcherCount), selectedLocal,
[&launchers](int index) {
return launchers[index]->text.empty() ? std::string(defaultLauncherLabel(launchers[index]->action))
: launchers[index]->text;
},
[&launchers](int index) {
return launchers[index]->icon == UIIcon::None ? defaultLauncherIcon(launchers[index]->action)
: launchers[index]->icon;
});
}
} else if (widget.type == ThemeHomeWidgetType::ButtonHints) {
const bool horizontalBottomHints = ctx.spec.navigation == ThemeHomeNavigationMode::SplitAxis ||
ctx.spec.navigation == ThemeHomeNavigationMode::CarouselAxis;
const auto labels = ctx.mappedInput.mapLabels(
buttonHintLabel(widget.buttonHints.back, ""), buttonHintLabel(widget.buttonHints.confirm, tr(STR_SELECT)),
buttonHintLabel(widget.buttonHints.previous, horizontalBottomHints ? tr(STR_DIR_LEFT) : tr(STR_DIR_UP)),
buttonHintLabel(widget.buttonHints.next, horizontalBottomHints ? tr(STR_DIR_RIGHT) : tr(STR_DIR_DOWN)));
GUI.drawButtonHints(ctx.renderer, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
}
}
ctx.renderer.displayBuffer();
return true;
}
+44
View File
@@ -0,0 +1,44 @@
#pragma once
#include <vector>
#include "components/themes/ThemeLayout.h"
class GfxRenderer;
class MappedInputManager;
struct RecentBook;
struct ThemeHomeActionEntry {
ThemeHomeAction action = ThemeHomeAction::FileBrowser;
int value = 0;
};
using ThemeHomeBufferCallback = bool (*)(void*);
void buildThemeHomeActions(const ThemeHomeScreenSpec* spec, const std::vector<RecentBook>& recentBooks,
bool hasOpdsServers, std::vector<ThemeHomeActionEntry>& actions);
struct ThemeHomeRenderContext {
GfxRenderer& renderer;
MappedInputManager& mappedInput;
const ThemeMetrics& metrics;
const ThemeHomeScreenSpec& spec;
const std::vector<RecentBook>& recentBooks;
const std::vector<ThemeHomeActionEntry>& actions;
bool hasOpdsServers = false;
int selectorIndex = 0;
int& coverSelectorIndex;
bool& coverRendered;
bool& coverBufferStored;
int coverBufferSelectorIndex = -1;
bool coverBufferStripSelected = false;
int& coverRectX;
int& coverRectY;
int& coverRectW;
int& coverRectH;
void* coverBufferUserData = nullptr;
ThemeHomeBufferCallback storeCoverBuffer = nullptr;
ThemeHomeBufferCallback restoreCoverBuffer = nullptr;
};
bool renderThemeHome(ThemeHomeRenderContext& ctx);
@@ -4,13 +4,13 @@
#include <GfxRenderer.h> #include <GfxRenderer.h>
#include <I18n.h> #include <I18n.h>
#include <WiFi.h> #include <WiFi.h>
#include <esp_task_wdt.h>
#include "MappedInputManager.h" #include "MappedInputManager.h"
#include "SilentRestart.h" #include "SilentRestart.h"
#include "WifiSelectionActivity.h" #include "WifiSelectionActivity.h"
#include "components/UITheme.h" #include "components/UITheme.h"
#include "fontIds.h" #include "fontIds.h"
#include "network/TaskWatchdog.h"
namespace { namespace {
constexpr const char* HOSTNAME = "crosspoint"; constexpr const char* HOSTNAME = "crosspoint";
@@ -110,12 +110,12 @@ void CalibreConnectActivity::loop() {
LOG_DBG("CAL", "WARNING: %lu ms gap since last handleClient", timeSinceLastHandleClient); LOG_DBG("CAL", "WARNING: %lu ms gap since last handleClient", timeSinceLastHandleClient);
} }
feedTaskWatchdog(); esp_task_wdt_reset();
constexpr int MAX_ITERATIONS = 80; constexpr int MAX_ITERATIONS = 80;
for (int i = 0; i < MAX_ITERATIONS && webServer->isRunning(); i++) { for (int i = 0; i < MAX_ITERATIONS && webServer->isRunning(); i++) {
webServer->handleClient(); webServer->handleClient();
if ((i & 0x07) == 0x07) { if ((i & 0x07) == 0x07) {
feedTaskWatchdog(); esp_task_wdt_reset();
} }
if ((i & 0x0F) == 0x0F) { if ((i & 0x0F) == 0x0F) {
yield(); yield();
@@ -5,6 +5,7 @@
#include <GfxRenderer.h> #include <GfxRenderer.h>
#include <I18n.h> #include <I18n.h>
#include <WiFi.h> #include <WiFi.h>
#include <esp_task_wdt.h>
#include <cstddef> #include <cstddef>
@@ -15,7 +16,6 @@
#include "activities/network/CalibreConnectActivity.h" #include "activities/network/CalibreConnectActivity.h"
#include "components/UITheme.h" #include "components/UITheme.h"
#include "fontIds.h" #include "fontIds.h"
#include "network/TaskWatchdog.h"
#include "util/QrUtils.h" #include "util/QrUtils.h"
namespace { namespace {
@@ -328,7 +328,7 @@ void CrossPointWebServerActivity::loop() {
} }
// Reset watchdog BEFORE processing - HTTP header parsing can be slow // Reset watchdog BEFORE processing - HTTP header parsing can be slow
feedTaskWatchdog(); esp_task_wdt_reset();
// Process HTTP requests in tight loop for maximum throughput // Process HTTP requests in tight loop for maximum throughput
// More iterations = more data processed per main loop cycle // More iterations = more data processed per main loop cycle
@@ -337,7 +337,7 @@ void CrossPointWebServerActivity::loop() {
webServer->handleClient(); webServer->handleClient();
// Reset watchdog every 32 iterations // Reset watchdog every 32 iterations
if ((i & 0x1F) == 0x1F) { if ((i & 0x1F) == 0x1F) {
feedTaskWatchdog(); esp_task_wdt_reset();
} }
// Yield and check for exit button every 64 iterations // Yield and check for exit button every 64 iterations
if ((i & 0x3F) == 0x3F) { if ((i & 0x3F) == 0x3F) {
@@ -30,17 +30,8 @@ void NetworkModeSelectionActivity::loop() {
return; return;
} }
int downId = -1; // Handle confirm button - select current option
if (mappedInput.wasItemTouchedDown(downId) && downId >= 0 && downId < static_cast<int>(MENU_ITEM_COUNT)) { if (mappedInput.wasPressed(MappedInputManager::Button::Confirm)) {
selectedIndex = downId;
requestUpdate();
}
// Handle confirm button (or a tap) - select current option
int tappedId = -1;
const bool tapped = mappedInput.wasItemTapped(tappedId);
if (tapped && tappedId >= 0 && tappedId < static_cast<int>(MENU_ITEM_COUNT)) selectedIndex = tappedId;
if (tapped || mappedInput.wasPressed(MappedInputManager::Button::Confirm)) {
NetworkMode mode = NetworkMode::JOIN_NETWORK; NetworkMode mode = NetworkMode::JOIN_NETWORK;
if (selectedIndex == 1) { if (selectedIndex == 1) {
mode = NetworkMode::CONNECT_CALIBRE; mode = NetworkMode::CONNECT_CALIBRE;
@@ -51,6 +42,7 @@ void NetworkModeSelectionActivity::loop() {
return; return;
} }
// Handle navigation
buttonNavigator.onNext([this] { buttonNavigator.onNext([this] {
selectedIndex = ButtonNavigator::nextIndex(selectedIndex, MENU_ITEM_COUNT); selectedIndex = ButtonNavigator::nextIndex(selectedIndex, MENU_ITEM_COUNT);
requestUpdate(); requestUpdate();
@@ -85,6 +77,7 @@ void NetworkModeSelectionActivity::render(RenderLock&&) {
[](int index) { return std::string(I18N.get(menuItems[index])); }, [](int index) { return std::string(I18N.get(menuItems[index])); },
[](int index) { return std::string(I18N.get(menuDescs[index])); }, [](int index) { return menuIcons[index]; }); [](int index) { return std::string(I18N.get(menuDescs[index])); }, [](int index) { return menuIcons[index]; });
// Draw help text at bottom
const auto labels = mappedInput.mapLabels(tr(STR_BACK), tr(STR_SELECT), tr(STR_DIR_UP), tr(STR_DIR_DOWN)); const auto labels = mappedInput.mapLabels(tr(STR_BACK), tr(STR_SELECT), tr(STR_DIR_UP), tr(STR_DIR_DOWN));
GUI.drawButtonHints(renderer, labels.btn1, labels.btn2, labels.btn3, labels.btn4); GUI.drawButtonHints(renderer, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
@@ -409,27 +409,6 @@ void WifiSelectionActivity::loop() {
// Handle network list state // Handle network list state
if (state == WifiSelectionState::NETWORK_LIST) { if (state == WifiSelectionState::NETWORK_LIST) {
// Vertical swipe page-scrolls the network list (touch nav without the side buttons).
int scrollIdx = static_cast<int>(selectedNetworkIndex);
if (mappedInput.wasListScroll(scrollIdx, static_cast<int>(networks.size()),
UITheme::getInstance().getNumberOfItemsPerPage(renderer, true, false, true, false))) {
selectedNetworkIndex = scrollIdx;
requestUpdate();
return;
}
// Touch: stable press highlights; tap selects it (like Confirm). Drag/scroll contacts do not preselect a row.
int downId = -1;
if (mappedInput.wasItemTouchedDown(downId) && downId >= 0 && downId < static_cast<int>(networks.size())) {
selectedNetworkIndex = downId;
requestUpdate();
}
int tappedId = -1;
if (mappedInput.wasItemTapped(tappedId) && tappedId >= 0 && tappedId < static_cast<int>(networks.size())) {
selectedNetworkIndex = tappedId;
selectNetwork(selectedNetworkIndex);
return;
}
// Check for Back button to exit (cancel) // Check for Back button to exit (cancel)
if (mappedInput.wasPressed(MappedInputManager::Button::Back)) { if (mappedInput.wasPressed(MappedInputManager::Button::Back)) {
onComplete(false); onComplete(false);
@@ -463,6 +442,7 @@ void WifiSelectionActivity::loop() {
} }
} }
// Handle navigation
buttonNavigator.onNext([this] { buttonNavigator.onNext([this] {
selectedNetworkIndex = ButtonNavigator::nextIndex(selectedNetworkIndex, networks.size()); selectedNetworkIndex = ButtonNavigator::nextIndex(selectedNetworkIndex, networks.size());
requestUpdate(); requestUpdate();
+158 -62
View File
@@ -41,6 +41,8 @@ namespace {
// pagesPerRefresh now comes from SETTINGS.getRefreshFrequency() // pagesPerRefresh now comes from SETTINGS.getRefreshFrequency()
// pages per minute, first item is 1 to prevent division by zero if accessed // pages per minute, first item is 1 to prevent division by zero if accessed
constexpr int PAGE_TURN_RATES[] = {1, 1, 3, 6, 12}; constexpr int PAGE_TURN_RATES[] = {1, 1, 3, 6, 12};
constexpr size_t initialBookmarkCacheCapacity = 16;
constexpr float bookmarkProgressEpsilon = 0.0001f;
int clampPercent(int percent) { int clampPercent(int percent) {
if (percent < 0) { if (percent < 0) {
@@ -63,6 +65,36 @@ bool isInReadFolder(const std::string& path) {
return path.size() > n && path.compare(0, n, READ_FOLDER) == 0 && path[n] == '/'; return path.size() > n && path.compare(0, n, READ_FOLDER) == 0 && path[n] == '/';
} }
struct ProgressRange {
float start;
float end;
};
ProgressRange getPageProgressRange(const std::shared_ptr<Epub>& epub, const int spineIndex, const int page,
const int pageCount) {
if (pageCount <= 1) {
return {epub->calculateProgress(spineIndex, 0.0f), epub->calculateProgress(spineIndex, 1.0f)};
}
const float step = 1.0f / static_cast<float>(pageCount - 1);
const float anchor = std::clamp(static_cast<float>(page) * step, 0.0f, 1.0f);
const float start = std::max(0.0f, anchor - (step * 0.5f));
const float end = std::min(1.0f, anchor + (step * 0.5f));
return {epub->calculateProgress(spineIndex, start), epub->calculateProgress(spineIndex, end)};
}
bool bookmarkMatchesProgress(const BookmarkEntry& bookmark, const int spineIndex, const int page, const int pageCount,
const ProgressRange& pageRange) {
if (bookmark.computedSpineIndex == spineIndex && bookmark.computedChapterPageCount == pageCount &&
bookmark.computedChapterProgress == page) {
return true;
}
const float bookmarkProgress = std::clamp(bookmark.percentage, 0.0f, 1.0f);
return bookmarkProgress + bookmarkProgressEpsilon >= pageRange.start &&
bookmarkProgress - bookmarkProgressEpsilon <= pageRange.end;
}
// Pick a non-colliding destination path inside /Read/ for a finished book. // Pick a non-colliding destination path inside /Read/ for a finished book.
// Mirrors the suffixing scheme used elsewhere: "name.epub" -> "name (2).epub", etc. // Mirrors the suffixing scheme used elsewhere: "name.epub" -> "name (2).epub", etc.
std::string buildReadFolderDestination(const std::string& srcPath) { std::string buildReadFolderDestination(const std::string& srcPath) {
@@ -165,6 +197,8 @@ void EpubReaderActivity::onEnter() {
APP_STATE.saveToFile(); APP_STATE.saveToFile();
RECENT_BOOKS.addBook(epub->getPath(), epub->getTitle(), epub->getAuthor(), epub->getThumbBmpPath()); RECENT_BOOKS.addBook(epub->getPath(), epub->getTitle(), epub->getAuthor(), epub->getThumbBmpPath());
loadCachedBookmarks();
// Trigger first update // Trigger first update
requestUpdate(); requestUpdate();
} }
@@ -177,6 +211,14 @@ void EpubReaderActivity::onExit() {
APP_STATE.readerActivityLoadCount = 0; APP_STATE.readerActivityLoadCount = 0;
APP_STATE.saveToFile(); APP_STATE.saveToFile();
// Leaving mid-footnote loses the in-RAM return stack on deep sleep; persist the
// pre-footnote position so the book reopens at the link origin, not the footnote.
if (footnoteDepth > 0 && epub) {
const SavedPosition& origin = savedPositions[0];
saveProgress(origin.spineIndex, origin.pageNumber, 0);
}
section.reset(); section.reset();
if (pendingReadFolderMove && epub) { if (pendingReadFolderMove && epub) {
const std::string srcPath = epub->getPath(); const std::string srcPath = epub->getPath();
@@ -256,14 +298,10 @@ void EpubReaderActivity::loop() {
requestUpdate(); requestUpdate();
} }
// Touch page nav (idempotent within a frame, so read here and again below). The // Enter reader menu activity on short-press Confirm. A long-press that fired a bound
// top-left Back corner is consumed by wasReleased(Back) above, never reaching here. // function (bookmark or KOReader sync) sets ignoreNextConfirmRelease so the release
const auto touch = ReaderUtils::detectTouchPageTurn(renderer); // following the hold does not also open the menu.
if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
// Enter reader menu activity on short-press Confirm release, or a center touch-and-hold. A
// long-press that fired a bound function (bookmark or KOReader sync) sets ignoreNextConfirmRelease
// so the release following the hold does not also open the menu.
if (mappedInput.wasReleased(MappedInputManager::Button::Confirm) || ReaderUtils::isTouchMenuGesture(touch)) {
if (ignoreNextConfirmRelease) { if (ignoreNextConfirmRelease) {
ignoreNextConfirmRelease = false; ignoreNextConfirmRelease = false;
} else { } else {
@@ -277,7 +315,7 @@ void EpubReaderActivity::loop() {
const int bookProgressPercent = clampPercent(static_cast<int>(bookProgress + 0.5f)); const int bookProgressPercent = clampPercent(static_cast<int>(bookProgress + 0.5f));
startActivityForResult(std::make_unique<EpubReaderMenuActivity>( startActivityForResult(std::make_unique<EpubReaderMenuActivity>(
renderer, mappedInput, epub->getTitle(), currentPage, totalPages, bookProgressPercent, renderer, mappedInput, epub->getTitle(), currentPage, totalPages, bookProgressPercent,
SETTINGS.orientation, !currentPageFootnotes.empty()), SETTINGS.orientation, !currentPageFootnotes.empty(), !cachedBookmarks.empty()),
[this](const ActivityResult& result) { [this](const ActivityResult& result) {
// Always apply orientation change even if the menu was cancelled // Always apply orientation change even if the menu was cancelled
const auto& menu = std::get<MenuResult>(result.data); const auto& menu = std::get<MenuResult>(result.data);
@@ -362,9 +400,7 @@ void EpubReaderActivity::loop() {
return; return;
} }
auto [prevTriggered, nextTriggered, fromTilt] = ReaderUtils::detectPageTurn(mappedInput); const auto [prevTriggered, nextTriggered, fromTilt] = ReaderUtils::detectPageTurn(mappedInput);
prevTriggered = prevTriggered || touch.prev;
nextTriggered = nextTriggered || touch.next;
if (!prevTriggered && !nextTriggered) { if (!prevTriggered && !nextTriggered) {
return; return;
} }
@@ -382,8 +418,7 @@ void EpubReaderActivity::loop() {
return; return;
} }
const unsigned long heldMs = (touch.prev || touch.next) ? touch.heldMs : mappedInput.getHeldTime(); const bool longPress = !fromTilt && mappedInput.getHeldTime() > ReaderUtils::SKIP_HOLD_MS;
const bool longPress = !fromTilt && heldMs > ReaderUtils::SKIP_HOLD_MS;
// Don't skip chapter after screenshot // Don't skip chapter after screenshot
if (gpio.wasReleased(HalGPIO::BTN_POWER) && gpio.wasReleased(HalGPIO::BTN_DOWN)) { if (gpio.wasReleased(HalGPIO::BTN_POWER) && gpio.wasReleased(HalGPIO::BTN_DOWN)) {
@@ -499,6 +534,7 @@ void EpubReaderActivity::jumpToPercent(int percent) {
void EpubReaderActivity::onReaderMenuConfirm(EpubReaderMenuActivity::MenuAction action) { void EpubReaderActivity::onReaderMenuConfirm(EpubReaderMenuActivity::MenuAction action) {
auto progressChangeResultHandler = [this](const ActivityResult& result) { auto progressChangeResultHandler = [this](const ActivityResult& result) {
loadCachedBookmarks();
if (!result.isCancelled) { if (!result.isCancelled) {
const auto& sync = std::get<ProgressChangeResult>(result.data); const auto& sync = std::get<ProgressChangeResult>(result.data);
if (currentSpineIndex != sync.spineIndex || (section && section->currentPage != sync.page)) { if (currentSpineIndex != sync.spineIndex || (section && section->currentPage != sync.page)) {
@@ -614,6 +650,10 @@ void EpubReaderActivity::onReaderMenuConfirm(EpubReaderMenuActivity::MenuAction
progressChangeResultHandler); progressChangeResultHandler);
break; break;
} }
case EpubReaderMenuActivity::MenuAction::TOGGLE_BOOKMARK: {
addBookmark();
break;
}
} }
} }
@@ -748,6 +788,7 @@ void EpubReaderActivity::pageTurn(bool isForwardTurn) {
requestUpdate(); requestUpdate();
} }
// TODO: Failure handling
void EpubReaderActivity::render(RenderLock&& lock) { void EpubReaderActivity::render(RenderLock&& lock) {
if (!epub) { if (!epub) {
return; return;
@@ -900,6 +941,8 @@ void EpubReaderActivity::render(RenderLock&& lock) {
return; return;
} }
updateBookmarkFlag();
{ {
auto p = section->loadPageFromSectionFile(); auto p = section->loadPageFromSectionFile();
if (!p) { if (!p) {
@@ -931,7 +974,7 @@ void EpubReaderActivity::render(RenderLock&& lock) {
} }
if (showBookmarkMessage) { if (showBookmarkMessage) {
GUI.drawPopup(renderer, tr(STR_BOOKMARK_ADDED)); GUI.drawPopup(renderer, bookmarkRemoved ? tr(STR_BOOKMARK_REMOVED) : tr(STR_BOOKMARK_ADDED));
} }
} }
@@ -974,22 +1017,31 @@ void EpubReaderActivity::renderContents(std::unique_ptr<Page> page, const int or
const int orientedMarginRight, const int orientedMarginBottom, const int orientedMarginRight, const int orientedMarginBottom,
const int orientedMarginLeft) { const int orientedMarginLeft) {
const auto t0 = millis(); const auto t0 = millis();
const int fontId = SETTINGS.getReaderFontId();
// Font prewarm: scan pass accumulates text, then prewarm, then real render // Font prewarm: scan pass accumulates text, then prewarm, then real render
auto* fcm = renderer.getFontCacheManager(); auto* fcm = renderer.getFontCacheManager();
auto scope = fcm->createPrewarmScope(); auto scope = fcm->createPrewarmScope();
page->render(renderer, SETTINGS.getReaderFontId(), orientedMarginLeft, orientedMarginTop); // scan pass page->render(renderer, fontId, orientedMarginLeft, orientedMarginTop); // scan pass
scope.endScanAndPrewarm(); scope.endScanAndPrewarm();
const auto tPrewarm = millis(); const auto tPrewarm = millis();
// Force special handling for pages with images when anti-aliasing is on const bool pageHasImages = page->hasImages();
bool imagePageWithAA = page->hasImages() && SETTINGS.textAntiAliasing; const bool needsTextGrayscale = SETTINGS.textAntiAliasing;
const bool needsAnyGrayscale = needsTextGrayscale || pageHasImages;
auto renderGrayscalePass = [&]() {
if (needsTextGrayscale) {
page->render(renderer, fontId, orientedMarginLeft, orientedMarginTop);
} else {
page->renderImages(renderer, fontId, orientedMarginLeft, orientedMarginTop);
}
};
page->render(renderer, SETTINGS.getReaderFontId(), orientedMarginLeft, orientedMarginTop); page->render(renderer, fontId, orientedMarginLeft, orientedMarginTop);
renderStatusBar(); renderStatusBar();
const auto tBwRender = millis(); const auto tBwRender = millis();
if (imagePageWithAA) { if (pageHasImages) {
// Double FAST_REFRESH with selective image blanking (pablohc's technique): // Double FAST_REFRESH with selective image blanking (pablohc's technique):
// HALF_REFRESH sets particles too firmly for the grayscale LUT to adjust. // HALF_REFRESH sets particles too firmly for the grayscale LUT to adjust.
// Instead, blank only the image area and do two fast refreshes. // Instead, blank only the image area and do two fast refreshes.
@@ -1002,7 +1054,7 @@ void EpubReaderActivity::renderContents(std::unique_ptr<Page> page, const int or
// Re-render page content to restore images into the blanked area // Re-render page content to restore images into the blanked area
// Status bar is not re-rendered here to avoid reading stale dynamic values (e.g. battery %) // Status bar is not re-rendered here to avoid reading stale dynamic values (e.g. battery %)
page->render(renderer, SETTINGS.getReaderFontId(), orientedMarginLeft, orientedMarginTop); page->render(renderer, fontId, orientedMarginLeft, orientedMarginTop);
renderer.displayBuffer(HalDisplay::FAST_REFRESH); renderer.displayBuffer(HalDisplay::FAST_REFRESH);
} else { } else {
renderer.displayBuffer(HalDisplay::HALF_REFRESH); renderer.displayBuffer(HalDisplay::HALF_REFRESH);
@@ -1026,7 +1078,7 @@ void EpubReaderActivity::renderContents(std::unique_ptr<Page> page, const int or
// per plane, but renderCharImpl culls out-of-band glyphs before decode so the // per plane, but renderCharImpl culls out-of-band glyphs before decode so the
// cost stays close to one render. Both text (drawPixel) and images // cost stays close to one render. Both text (drawPixel) and images
// (DirectPixelWriter) honor the active strip target. // (DirectPixelWriter) honor the active strip target.
if (SETTINGS.textAntiAliasing && renderer.supportsStripGrayscale()) { if (needsAnyGrayscale && renderer.supportsStripGrayscale()) {
constexpr int STRIP_ROWS = 80; constexpr int STRIP_ROWS = 80;
const int gh = renderer.getDisplayHeight(); const int gh = renderer.getDisplayHeight();
const int gwBytes = renderer.getDisplayWidthBytes(); const int gwBytes = renderer.getDisplayWidthBytes();
@@ -1035,6 +1087,11 @@ void EpubReaderActivity::renderContents(std::unique_ptr<Page> page, const int or
if (!scratch) { if (!scratch) {
LOG_ERR("ERS", "OOM: grayscale strip scratch (%d bytes); skipping AA this page", gwBytes * STRIP_ROWS); LOG_ERR("ERS", "OOM: grayscale strip scratch (%d bytes); skipping AA this page", gwBytes * STRIP_ROWS);
} else { } else {
// [#2190] Headroom probe: tiled scratch is ~8 KB here; the full-frame
// alternative would need ~52 KB total (chunked at 8 KB). Compare free vs
// ~52 KB and largest_block vs 8 KB to see if X3 could afford full-frame.
LOG_INF("ERS", "Grayscale heap @render: free=%u largest_block=%u scratch=%d", (unsigned)ESP.getFreeHeap(),
(unsigned)ESP.getMaxAllocHeap(), gwBytes * STRIP_ROWS);
// Bands may be streamed in any order: X4 windows each via setRamArea, X3 // Bands may be streamed in any order: X4 windows each via setRamArea, X3
// via PTL. // via PTL.
renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB); renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB);
@@ -1042,7 +1099,7 @@ void EpubReaderActivity::renderContents(std::unique_ptr<Page> page, const int or
const int rows = (gh - y < STRIP_ROWS) ? (gh - y) : STRIP_ROWS; const int rows = (gh - y < STRIP_ROWS) ? (gh - y) : STRIP_ROWS;
renderer.beginStripTarget(scratch.get(), y, rows); renderer.beginStripTarget(scratch.get(), y, rows);
renderer.clearScreen(0x00); renderer.clearScreen(0x00);
page->render(renderer, SETTINGS.getReaderFontId(), orientedMarginLeft, orientedMarginTop); renderGrayscalePass();
renderer.endStripTarget(); renderer.endStripTarget();
renderer.writeGrayscalePlaneStrip(true, scratch.get(), y, rows); renderer.writeGrayscalePlaneStrip(true, scratch.get(), y, rows);
} }
@@ -1054,7 +1111,7 @@ void EpubReaderActivity::renderContents(std::unique_ptr<Page> page, const int or
const int rows = (gh - y < STRIP_ROWS) ? (gh - y) : STRIP_ROWS; const int rows = (gh - y < STRIP_ROWS) ? (gh - y) : STRIP_ROWS;
renderer.beginStripTarget(scratch.get(), y, rows); renderer.beginStripTarget(scratch.get(), y, rows);
renderer.clearScreen(0x00); renderer.clearScreen(0x00);
page->render(renderer, SETTINGS.getReaderFontId(), orientedMarginLeft, orientedMarginTop); renderGrayscalePass();
renderer.endStripTarget(); renderer.endStripTarget();
renderer.writeGrayscalePlaneStrip(false, scratch.get(), y, rows); renderer.writeGrayscalePlaneStrip(false, scratch.get(), y, rows);
} }
@@ -1079,22 +1136,28 @@ void EpubReaderActivity::renderContents(std::unique_ptr<Page> page, const int or
} else { } else {
// Fallback path for a controller without strip support. grayscale rendering // Fallback path for a controller without strip support. grayscale rendering
// TODO: Only do this if font supports it // TODO: Only do this if font supports it
if (SETTINGS.textAntiAliasing) { if (needsAnyGrayscale) {
// Save the BW frame before the grayscale passes overwrite it, restore // Save the BW frame before the grayscale passes overwrite it, restore
// after. Only needed when grayscale actually renders. // after. Only needed when grayscale actually renders.
renderer.storeBwBuffer(); if (!renderer.storeBwBuffer()) {
LOG_ERR("ERS", "Failed to store BW buffer for grayscale render; skipping grayscale this page");
const auto tEnd = millis();
LOG_DBG("ERS", "Page render: prewarm=%lums bw_render=%lums display=%lums total=%lums", tPrewarm - t0,
tBwRender - tPrewarm, tDisplay - tBwRender, tEnd - t0);
return;
}
const auto tBwStore = millis(); const auto tBwStore = millis();
renderer.clearScreen(0x00); renderer.clearScreen(0x00);
renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB); renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB);
page->render(renderer, SETTINGS.getReaderFontId(), orientedMarginLeft, orientedMarginTop); renderGrayscalePass();
renderer.copyGrayscaleLsbBuffers(); renderer.copyGrayscaleLsbBuffers();
const auto tGrayLsb = millis(); const auto tGrayLsb = millis();
// Render and copy to MSB buffer // Render and copy to MSB buffer
renderer.clearScreen(0x00); renderer.clearScreen(0x00);
renderer.setRenderMode(GfxRenderer::GRAYSCALE_MSB); renderer.setRenderMode(GfxRenderer::GRAYSCALE_MSB);
page->render(renderer, SETTINGS.getReaderFontId(), orientedMarginLeft, orientedMarginTop); renderGrayscalePass();
renderer.copyGrayscaleMsbBuffers(); renderer.copyGrayscaleMsbBuffers();
const auto tGrayMsb = millis(); const auto tGrayMsb = millis();
@@ -1112,8 +1175,8 @@ void EpubReaderActivity::renderContents(std::unique_ptr<Page> page, const int or
tPrewarm - t0, tBwRender - tPrewarm, tDisplay - tBwRender, tBwStore - tDisplay, tGrayLsb - tBwStore, tPrewarm - t0, tBwRender - tPrewarm, tDisplay - tBwRender, tBwStore - tDisplay, tGrayLsb - tBwStore,
tGrayMsb - tGrayLsb, tGrayDisplay - tGrayMsb, tBwRestore - tGrayDisplay, tEnd - t0); tGrayMsb - tGrayLsb, tGrayDisplay - tGrayMsb, tBwRestore - tGrayDisplay, tEnd - t0);
} else { } else {
// No anti-aliasing: BW frame already displayed above, no grayscale to // No text AA and no images: BW frame already displayed above, no grayscale
// render, so no save/restore. // to render, so no save/restore.
const auto tEnd = millis(); const auto tEnd = millis();
LOG_DBG("ERS", "Page render: prewarm=%lums bw_render=%lums display=%lums total=%lums", tPrewarm - t0, LOG_DBG("ERS", "Page render: prewarm=%lums bw_render=%lums display=%lums total=%lums", tPrewarm - t0,
tBwRender - tPrewarm, tDisplay - tBwRender, tEnd - t0); tBwRender - tPrewarm, tDisplay - tBwRender, tEnd - t0);
@@ -1155,7 +1218,7 @@ void EpubReaderActivity::renderStatusBar() const {
title = epub->getTitle(); title = epub->getTitle();
} }
GUI.drawStatusBar(renderer, bookProgress, currentPage, pageCount, title, 0, textYOffset); GUI.drawStatusBar(renderer, bookProgress, currentPage, pageCount, title, 0, textYOffset, true, currentPageBookmarked);
} }
void EpubReaderActivity::navigateToHref(const std::string& hrefStr, const bool savePosition) { void EpubReaderActivity::navigateToHref(const std::string& hrefStr, const bool savePosition) {
@@ -1217,11 +1280,31 @@ void EpubReaderActivity::restoreSavedPosition() {
requestUpdate(); requestUpdate();
} }
void EpubReaderActivity::loadCachedBookmarks() {
cachedBookmarks.clear();
if (cachedBookmarks.capacity() < initialBookmarkCacheCapacity) {
cachedBookmarks.reserve(initialBookmarkCacheCapacity);
}
if (!epub) {
currentPageBookmarked = false;
return;
}
const std::string bmPath = BookmarkUtil::getBookmarkPath(epub->getPath());
if (Storage.exists(bmPath.c_str())) {
String json = Storage.readFile(bmPath.c_str());
if (!json.isEmpty()) {
JsonSettingsIO::loadBookmarks(cachedBookmarks, json.c_str());
}
}
updateBookmarkFlag();
}
void EpubReaderActivity::addBookmark() { void EpubReaderActivity::addBookmark() {
if (!section || !epub) { if (!section || !epub) {
return; return;
} }
LOG_DBG("ERS", "Adding bookmark at spine %d, page %d", currentSpineIndex, section ? section->currentPage : -1); LOG_DBG("ERS", "Toggle bookmark at spine %d, page %d", currentSpineIndex, section ? section->currentPage : -1);
int currentPage; int currentPage;
int pageCount; int pageCount;
{ {
@@ -1230,45 +1313,58 @@ void EpubReaderActivity::addBookmark() {
currentPage = section->currentPage; currentPage = section->currentPage;
} }
std::string pageText; SavedProgressPosition progress = ProgressMapper::toSavedProgress(epub, getCurrentPosition());
if (currentPage >= 0 && currentPage < pageCount) { const ProgressRange pageRange = getPageProgressRange(epub, currentSpineIndex, currentPage, pageCount);
pageText = section->getTextFromSectionFile();
const size_t bookmarkCountBeforeToggle = cachedBookmarks.size();
cachedBookmarks.erase(std::remove_if(cachedBookmarks.begin(), cachedBookmarks.end(),
[&](const BookmarkEntry& b) {
return bookmarkMatchesProgress(b, currentSpineIndex, currentPage, pageCount,
pageRange);
}),
cachedBookmarks.end());
if (cachedBookmarks.size() != bookmarkCountBeforeToggle) {
bookmarkRemoved = true;
currentPageBookmarked = false;
} else {
std::string pageText;
if (currentPage >= 0 && currentPage < pageCount) {
pageText = section->getTextFromSectionFile();
}
BookmarkEntry entry;
entry.percentage = progress.percentage;
entry.xpath = progress.xpath;
entry.summary = BookmarkUtil::sanitizeBookmarkSummary(pageText);
entry.computedSpineIndex = currentSpineIndex;
entry.computedChapterPageCount = pageCount;
entry.computedChapterProgress = currentPage;
cachedBookmarks.insert(cachedBookmarks.begin(), entry);
bookmarkRemoved = false;
currentPageBookmarked = true;
} }
SavedProgressPosition progress = ProgressMapper::toSavedProgress(epub, getCurrentPosition());
BookmarkEntry entry;
entry.percentage = progress.percentage;
entry.xpath = progress.xpath;
entry.summary = BookmarkUtil::sanitizeBookmarkSummary(pageText);
// Add bookmark
const std::string path = BookmarkUtil::getBookmarkPath(epub->getPath()); const std::string path = BookmarkUtil::getBookmarkPath(epub->getPath());
LOG_DBG("ERS", "Bookmark path: %s", path.c_str());
const std::string bookmarksDir = BookmarkUtil::getBookmarksDir(); const std::string bookmarksDir = BookmarkUtil::getBookmarksDir();
Storage.mkdir(bookmarksDir.c_str()); Storage.mkdir(bookmarksDir.c_str());
std::vector<BookmarkEntry> bookmarks; const bool ok = JsonSettingsIO::saveBookmarks(cachedBookmarks, path.c_str());
if (Storage.exists(path.c_str())) { if (!ok) {
LOG_DBG("ERS", "Existing bookmark file found, loading bookmarks"); LOG_ERR("ERS", "Failed to save bookmarks to: %s", path.c_str());
String json = Storage.readFile(path.c_str());
if (!json.isEmpty()) {
JsonSettingsIO::loadBookmarks(bookmarks, json.c_str());
}
} else {
LOG_DBG("ERS", "No existing bookmark file, starting with empty bookmark list");
} }
bookmarks.insert(bookmarks.begin(), entry);
LOG_DBG("ERS", "Saving bookmark to file: %s", path.c_str());
const bool ok = JsonSettingsIO::saveBookmarks(bookmarks, path.c_str());
if (ok) {
showBookmarkMessage = true;
} else {
LOG_ERR("ERS", "Failed to save bookmark to: %s", path.c_str());
}
requestUpdate(); requestUpdate();
} }
void EpubReaderActivity::updateBookmarkFlag() {
if (!section || !epub || cachedBookmarks.empty()) {
currentPageBookmarked = false;
return;
}
const ProgressRange pageRange =
getPageProgressRange(epub, currentSpineIndex, section->currentPage, section->pageCount);
currentPageBookmarked = std::any_of(cachedBookmarks.begin(), cachedBookmarks.end(), [&](const BookmarkEntry& b) {
return bookmarkMatchesProgress(b, currentSpineIndex, section->currentPage, section->pageCount, pageRange);
});
}
ScreenshotInfo EpubReaderActivity::getScreenshotInfo() const { ScreenshotInfo EpubReaderActivity::getScreenshotInfo() const {
ScreenshotInfo info; ScreenshotInfo info;
info.readerType = ScreenshotInfo::ReaderType::Epub; info.readerType = ScreenshotInfo::ReaderType::Epub;
@@ -5,6 +5,7 @@
#include <optional> #include <optional>
#include "BookmarkEntry.h"
#include "EpubReaderMenuActivity.h" #include "EpubReaderMenuActivity.h"
#include "ProgressMapper.h" #include "ProgressMapper.h"
#include "activities/Activity.h" #include "activities/Activity.h"
@@ -34,6 +35,9 @@ class EpubReaderActivity final : public Activity {
bool automaticPageTurnActive = false; bool automaticPageTurnActive = false;
bool showBookmarkMessage = false; bool showBookmarkMessage = false;
bool ignoreNextConfirmRelease = false; bool ignoreNextConfirmRelease = false;
bool currentPageBookmarked = false;
bool bookmarkRemoved = false; // true when last toggle removed (controls popup text)
std::vector<BookmarkEntry> cachedBookmarks;
// Tracks whether this book is currently removed from Recent Books by the // Tracks whether this book is currently removed from Recent Books by the
// removeReadBooksFromRecents feature (set at End-of-Book, cleared if paged back in). // removeReadBooksFromRecents feature (set at End-of-Book, cleared if paged back in).
bool recentsEntryRemoved = false; bool recentsEntryRemoved = false;
@@ -66,7 +70,9 @@ class EpubReaderActivity final : public Activity {
void applyOrientation(uint8_t orientation); void applyOrientation(uint8_t orientation);
void toggleAutoPageTurn(uint8_t selectedPageTurnOption); void toggleAutoPageTurn(uint8_t selectedPageTurnOption);
void pageTurn(bool isForwardTurn); void pageTurn(bool isForwardTurn);
void loadCachedBookmarks();
void addBookmark(); void addBookmark();
void updateBookmarkFlag();
// Footnote navigation // Footnote navigation
void navigateToHref(const std::string& href, bool savePosition = false); void navigateToHref(const std::string& href, bool savePosition = false);
@@ -39,14 +39,6 @@ void EpubReaderBookmarksActivity::onEnter() {
bookmarks.shrink_to_fit(); bookmarks.shrink_to_fit();
} else { } else {
JsonSettingsIO::loadBookmarks(bookmarks, json.c_str()); JsonSettingsIO::loadBookmarks(bookmarks, json.c_str());
// pre-compute bookmark page values for quicker rendering
for (auto& bookmark : bookmarks) {
CrossPointPosition pos = ProgressMapper::toCrossPoint(epub, {bookmark.xpath, bookmark.percentage}, renderer);
bookmark.computedSpineIndex = pos.spineIndex;
bookmark.computedChapterPageCount = pos.totalPages;
bookmark.computedChapterProgress = pos.pageNumber;
}
} }
} else { } else {
LOG_DBG("EPB", "No bookmark file found at %s, starting with empty bookmarks", path.c_str()); LOG_DBG("EPB", "No bookmark file found at %s, starting with empty bookmarks", path.c_str());
@@ -93,6 +85,14 @@ void EpubReaderBookmarksActivity::loop() {
selectorIndex--; selectorIndex--;
} }
if (bookmarks.empty()) {
ActivityResult result;
result.isCancelled = true;
setResult(std::move(result));
finish();
return;
}
requestUpdate(); requestUpdate();
confirmingDelete = DELETE_MODE_OFF; confirmingDelete = DELETE_MODE_OFF;
return; return;
@@ -103,24 +103,7 @@ void EpubReaderBookmarksActivity::loop() {
} }
} }
if (confirmingDelete < DELETE_MODE_DISPLAY) { if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) { // Open
// Vertical swipe page-scrolls the list (touch nav without the side buttons).
const int pageItems = GUI.getListPageItems(getListHeight(renderer), true);
if (mappedInput.wasListScroll(selectorIndex, static_cast<int>(bookmarks.size()), pageItems)) {
requestUpdate();
return;
}
int downId = -1;
if (mappedInput.wasItemTouchedDown(downId) && downId >= 0 && downId < static_cast<int>(bookmarks.size())) {
selectorIndex = downId;
requestUpdate();
}
}
int tappedId = -1;
const bool tapped = (confirmingDelete < DELETE_MODE_DISPLAY) && mappedInput.wasItemTapped(tappedId);
if (tapped && tappedId >= 0 && tappedId < static_cast<int>(bookmarks.size())) selectorIndex = tappedId;
if (tapped || mappedInput.wasReleased(MappedInputManager::Button::Confirm)) { // Open
if (bookmarks.empty()) { if (bookmarks.empty()) {
return; return;
} }
@@ -203,9 +186,12 @@ void EpubReaderBookmarksActivity::render(RenderLock&&) {
auto bookmark = bookmarks.at(confirmingDelete >= DELETE_MODE_DISPLAY ? selectorIndex : index); auto bookmark = bookmarks.at(confirmingDelete >= DELETE_MODE_DISPLAY ? selectorIndex : index);
auto tocIndex = epub->getTocIndexForSpineIndex(bookmark.computedSpineIndex); auto tocIndex = epub->getTocIndexForSpineIndex(bookmark.computedSpineIndex);
auto tocTitle = (tocIndex >= 0) ? (epub->getTocItem(tocIndex)).title : tr(STR_UNNAMED); auto tocTitle = (tocIndex >= 0) ? (epub->getTocItem(tocIndex)).title : tr(STR_UNNAMED);
return std::to_string((int)(std::clamp(bookmark.percentage, 0.0f, 1.0f) * 100.0f + 0.5f)) + "% - " + std::string subtitle = std::to_string((int)(std::clamp(bookmark.percentage, 0.0f, 1.0f) * 100.0f + 0.5f)) + "% - ";
std::to_string(bookmark.computedChapterProgress + 1) + "/" + if (bookmark.computedChapterPageCount > 0) {
std::to_string(bookmark.computedChapterPageCount) + " - " + tocTitle; subtitle += std::to_string(bookmark.computedChapterProgress + 1) + "/" +
std::to_string(bookmark.computedChapterPageCount) + " - ";
}
return subtitle + tocTitle;
}; };
const auto getBookmarkIcon = [isPortrait](int index) { const auto getBookmarkIcon = [isPortrait](int index) {
// only enabled icon in portrait mode due to limitation with rotating icons for other orientations // only enabled icon in portrait mode due to limitation with rotating icons for other orientations
@@ -225,11 +211,8 @@ void EpubReaderBookmarksActivity::render(RenderLock&&) {
getBookmarkTitle, getBookmarkSubtitle, getBookmarkIcon); getBookmarkTitle, getBookmarkSubtitle, getBookmarkIcon);
GUI.drawHelpText(renderer, Rect{contentX, pageHeight - hintGutterBottom, contentWidth, LINE_HEIGHT}, GUI.drawHelpText(renderer, Rect{contentX, pageHeight - hintGutterBottom, contentWidth, LINE_HEIGHT},
tr(STR_HOLD_CONFIRM_TO_DELETE)); tr(STR_HOLD_OPEN_TO_DELETE));
} }
} else {
GUI.drawHelpText(renderer, Rect{contentX, LINE_HEIGHT * 2, contentWidth, LINE_HEIGHT},
tr(STR_BOOKMARK_INSTRUCTIONS));
} }
const auto backLabel = confirmingDelete >= DELETE_MODE_DISPLAY ? tr(STR_CANCEL) : tr(STR_BACK); const auto backLabel = confirmingDelete >= DELETE_MODE_DISPLAY ? tr(STR_CANCEL) : tr(STR_BACK);
@@ -3,39 +3,11 @@
#include <GfxRenderer.h> #include <GfxRenderer.h>
#include <I18n.h> #include <I18n.h>
#include <algorithm>
#include "MappedInputManager.h" #include "MappedInputManager.h"
#include "components/UITheme.h" #include "components/UITheme.h"
#include "fontIds.h" #include "fontIds.h"
int EpubReaderChapterSelectionActivity::getTotalItems() const { return epub ? epub->getTocItemsCount() : 0; } int EpubReaderChapterSelectionActivity::getTotalItems() const { return epub->getTocItemsCount(); }
void EpubReaderChapterSelectionActivity::cancelAndFinish() {
ActivityResult result;
result.isCancelled = true;
setResult(std::move(result));
finish();
}
void EpubReaderChapterSelectionActivity::activateSelection(int index) {
const int totalItems = getTotalItems();
if (!epub || totalItems <= 0) {
cancelAndFinish();
return;
}
index = std::clamp(index, 0, totalItems - 1);
const auto tocItem = epub->getTocItem(index);
if (tocItem.spineIndex < 0 || tocItem.spineIndex >= epub->getSpineItemsCount()) {
cancelAndFinish();
return;
}
selectorIndex = index;
setResult(ChapterResult{tocItem.spineIndex, tocItem.anchor});
finish();
}
void EpubReaderChapterSelectionActivity::onEnter() { void EpubReaderChapterSelectionActivity::onEnter() {
Activity::onEnter(); Activity::onEnter();
@@ -58,38 +30,23 @@ void EpubReaderChapterSelectionActivity::onExit() { Activity::onExit(); }
void EpubReaderChapterSelectionActivity::loop() { void EpubReaderChapterSelectionActivity::loop() {
const int pageItems = UITheme::getInstance().getNumberOfItemsPerPage(renderer, true, false, true, false); const int pageItems = UITheme::getInstance().getNumberOfItemsPerPage(renderer, true, false, true, false);
const int totalItems = getTotalItems(); const int totalItems = getTotalItems();
if (!epub || totalItems <= 0) {
if (mappedInput.wasReleased(MappedInputManager::Button::Back)) { if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
cancelAndFinish(); const auto tocItem = epub->getTocItem(selectorIndex);
if (tocItem.spineIndex == -1) {
ActivityResult result;
result.isCancelled = true;
setResult(std::move(result));
finish();
} else {
setResult(ChapterResult{tocItem.spineIndex, tocItem.anchor});
finish();
} }
return;
}
// Vertical swipe page-scrolls the list (touch nav without the side buttons).
if (mappedInput.wasListScroll(selectorIndex, totalItems, pageItems)) {
requestUpdate();
return;
}
int downId = -1;
if (mappedInput.wasItemTouchedDown(downId) && downId >= 0 && downId < totalItems) {
selectorIndex = downId;
requestUpdate();
}
int tappedId = -1;
const bool tapped = mappedInput.wasItemTapped(tappedId);
const bool validTap = tapped && tappedId >= 0 && tappedId < totalItems;
const bool confirm = mappedInput.wasReleased(MappedInputManager::Button::Confirm);
if (validTap) {
selectorIndex = tappedId;
}
if (validTap || confirm) {
activateSelection(selectorIndex);
return;
} else if (mappedInput.wasReleased(MappedInputManager::Button::Back)) { } else if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
cancelAndFinish(); ActivityResult result;
return; result.isCancelled = true;
setResult(std::move(result));
finish();
} }
buttonNavigator.onNextRelease([this, totalItems] { buttonNavigator.onNextRelease([this, totalItems] {
@@ -126,12 +83,10 @@ void EpubReaderChapterSelectionActivity::render(RenderLock&&) {
const int contentHeight = screen.height - contentTop - metrics.verticalSpacing; const int contentHeight = screen.height - contentTop - metrics.verticalSpacing;
const int totalItems = getTotalItems(); const int totalItems = getTotalItems();
const int displayIndex = totalItems > 0 ? std::clamp(selectorIndex, 0, totalItems - 1) : 0; GUI.drawList(renderer, Rect{screen.x, contentTop, screen.width, contentHeight}, totalItems, selectorIndex,
GUI.drawList(renderer, Rect{screen.x, contentTop, screen.width, contentHeight}, totalItems, displayIndex,
[this](int index) { [this](int index) {
auto item = epub->getTocItem(index); auto item = epub->getTocItem(index);
const int level = item.level > 0 ? item.level - 1 : 0; std::string indent((item.level - 1) * 2, ' ');
std::string indent(level * 2, ' ');
return indent + item.title; return indent + item.title;
}); });
@@ -19,8 +19,6 @@ class EpubReaderChapterSelectionActivity final : public Activity {
// Total TOC items count // Total TOC items count
int getTotalItems() const; int getTotalItems() const;
void cancelAndFinish();
void activateSelection(int index);
public: public:
explicit EpubReaderChapterSelectionActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, explicit EpubReaderChapterSelectionActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
@@ -1,13 +1,11 @@
#include "EpubReaderFootnotesActivity.h" #include "EpubReaderFootnotesActivity.h"
#include <FreeInkUI.h>
#include <GfxRenderer.h> #include <GfxRenderer.h>
#include <I18n.h> #include <I18n.h>
#include <algorithm> #include <algorithm>
#include "MappedInputManager.h" #include "MappedInputManager.h"
#include "components/TouchRegistry.h"
#include "components/UITheme.h" #include "components/UITheme.h"
#include "fontIds.h" #include "fontIds.h"
@@ -20,30 +18,6 @@ void EpubReaderFootnotesActivity::onEnter() {
void EpubReaderFootnotesActivity::onExit() { Activity::onExit(); } void EpubReaderFootnotesActivity::onExit() { Activity::onExit(); }
void EpubReaderFootnotesActivity::loop() { void EpubReaderFootnotesActivity::loop() {
constexpr int lineHeight = 36;
const auto orientation = renderer.getOrientation();
const bool isPortraitInverted = orientation == GfxRenderer::Orientation::PortraitInverted;
const int contentY = isPortraitInverted ? 50 : 0;
const int visibleCount = std::max(1, (renderer.getScreenHeight() - contentY) / lineHeight);
if (mappedInput.wasListScroll(selectedIndex, static_cast<int>(footnotes.size()), visibleCount)) {
requestUpdate();
return;
}
int downId = -1;
if (mappedInput.wasItemTouchedDown(downId) &&
freeink::ui::listSelectIndex(selectedIndex, downId, static_cast<int>(footnotes.size()))) {
requestUpdate();
}
int tappedId = -1;
if (mappedInput.wasItemTapped(tappedId) && tappedId >= 0 && tappedId < static_cast<int>(footnotes.size())) {
selectedIndex = tappedId;
setResult(FootnoteResult{footnotes[selectedIndex].href});
finish();
return;
}
if (mappedInput.wasReleased(MappedInputManager::Button::Back)) { if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
ActivityResult result; ActivityResult result;
result.isCancelled = true; result.isCancelled = true;
@@ -128,7 +102,6 @@ void EpubReaderFootnotesActivity::render(RenderLock&&) {
label = tr(STR_LINK); label = tr(STR_LINK);
} }
renderer.drawText(UI_10_FONT_ID, marginLeft, y + 4, label.c_str(), !isSelected); renderer.drawText(UI_10_FONT_ID, marginLeft, y + 4, label.c_str(), !isSelected);
TouchRegistry::getInstance().add(Rect{contentX, y, contentWidth, lineHeight}, i, TouchRegistry::Item);
} }
const auto labels = mappedInput.mapLabels(tr(STR_BACK), tr(STR_SELECT), "", ""); const auto labels = mappedInput.mapLabels(tr(STR_BACK), tr(STR_SELECT), "", "");
Loaded 100 of 174 files, more files were not shown because too many files have changed in this diff. Show more