Cut release 0.5.1

* Move to smart pointers and split out ParsedText class

* Cleanup ParsedText

* Fix clearCache functions and clear section cache if page load fails

* Bump Page and Section file versions

* Combine removeDir implementations in Epub

* Adjust screen margins

.clangd

@@ -0,0 +1,2 @@
+CompileFlags:
+    Add: [-std=c++2a]

README.md

@@ -36,7 +36,34 @@ This project is **not affiliated with Xteink**; it's built as a community projec
 - [ ] WiFi connectivity
 - [ ] BLE connectivity
 
-## Getting Started
+## Installing
+
+### Web (latest firmware)
+
+1. Connect your Xteink X4 to your computer via USB-C
+2. Go to https://xteink.dve.al/ and click "Flash CrossPoint firmware"
+
+To revert back to the official firmware, you can flash the latest official firmware from https://xteink.dve.al/, or swap
+back to the other partition using the "Swap boot partition" button here https://xteink.dve.al/debug.
+
+### Web (specific firmware version)
+
+1. Connect your Xteink X4 to your computer via USB-C
+2. Download the `firmware.bin` file from the release of your choice via the [releases page](https://github.com/daveallie/crosspoint-reader/releases)
+3. Go to https://xteink.dve.al/ and flash the firmware file using the "OTA fast flash controls" section
+
+To revert back to the official firmware, you can flash the latest official firmware from https://xteink.dve.al/, or swap
+back to the other partition using the "Swap boot partition" button here https://xteink.dve.al/debug.
+
+### Manual
+
+See [Development](#development) below.
+
+## Usage
+
+See [the user guide](./USER_GUIDE.md) for instructions on operating CrossPoint.
+
+## Development
 
 ### Prerequisites
 
@@ -58,24 +85,12 @@ git submodule update --init --recursive
 
 ### Flashing your device
 
-#### Command line
-
 Connect your Xteink X4 to your computer via USB-C and run the following command.
 
 ```sh
 pio run --target upload
 ```
 
-#### Web
-
-1. Connect your Xteink X4 to your computer via USB-C
-2. Download the `firmware.bin` file from the latest release via the [releases page](https://github.com/daveallie/crosspoint-reader/releases)
-3. Go to https://xteink.dve.al/ and flash the firmware file using the "OTA fast flash controls" section
-4. Press the reset button on the Xteink X4 to restart the device
-
-To revert back to the official firmware, you can flash the latest official firmware from https://xteink.dve.al/, or swap
-back to the other partition using the "Swap boot partition" button here https://xteink.dve.al/debug. 
-
 ## Internals
 
 CrossPoint Reader is pretty aggressive about caching data down to the SD card to minimise RAM usage. The ESP32-C3 only

USER_GUIDE.md

@@ -0,0 +1,78 @@
+# CrossPoint User Guide
+
+Welcome to the **CrossPoint** firmware. This guide outlines the hardware controls, navigation, and reading features of 
+the device.
+
+## 1. Hardware Overview
+
+The device utilises the standard buttons on the Xtink X4 in the same layout:
+
+### Button Layout
+| Location        | Buttons                                    |
+|-----------------|--------------------------------------------|
+| **Bottom Edge** | **Back**, **Confirm**, **Left**, **Right** |
+| **Right Side**  | **Power**, **Volume Up**, **Volume Down**  |
+
+---
+
+## 2. Power & Startup
+
+### Power On / Off
+
+To turn the device on or off, **press and hold the Power button for 1 full second**.
+
+### First Launch
+
+Upon turning the device on for the first time, you will be placed on the **Book Selection Screen** (File Browser).
+
+> **Note:** On subsequent restarts, the firmware will automatically reopen the last book you were reading.
+
+---
+
+## 3. Book Selection
+
+The Home Screen acts as a folder and file browser.
+
+* **Navigate List:** Use **Left** (or **Volume Up**), or **Right** (or **Volume Down**) to move the selection cursor up 
+  and down through folders and books.
+* **Open Selection:** Press **Confirm** to open a folder or read a selected book.
+
+---
+
+## 4. Reading Mode
+
+Once you have opened a book, the button layout changes to facilitate reading.
+
+### Page Turning
+| Action            | Buttons                              |
+|-------------------|--------------------------------------|
+| **Previous Page** | Press **Left** _or_ **Volume Up**    |
+| **Next Page**     | Press **Right** _or_ **Volume Down** |
+
+### Chapter Navigation
+* **Next Chapter:** Press and **hold** the **Right** (or **Volume Down**) button briefly, then release.
+* **Previous Chapter:** Press and **hold** the **Left** (or **Volume Up**) button briefly, then release.
+
+### System Navigation
+* **Return to Home:** Press **Back** to close the book and return to the Book Selection screen.
+* **Chapter Menu:** Press **Confirm** to open the Table of Contents/Chapter Selection screen.
+
+---
+
+## 5. Chapter Selection Screen
+
+Accessible by pressing **Confirm** while inside a book.
+
+1.  Use **Left** (or **Volume Up**), or **Right** (or **Volume Down**) to highlight the desired chapter.
+2.  Press **Confirm** to jump to that chapter.
+3.  *Alternatively, press **Back** to cancel and return to your current page.*
+
+---
+
+## 6. Current Limitations & Roadmap
+
+Please note that this firmware is currently in active development. The following features are **not yet supported** but
+are planned for future updates:
+
+* **Images:** Embedded images in e-books will not render.
+* **Text Formatting:** There are currently no settings to adjust font type, size, line spacing, or margins.

lib/EpdFont/EpdFontData.h

@@ -31,4 +31,5 @@ typedef struct {
   uint8_t advanceY;                     ///< Newline distance (y axis)
   int ascender;                         ///< Maximal height of a glyph above the base line
   int descender;                        ///< Maximal height of a glyph below the base line
+  bool is2Bit;
 } EpdFontData;

lib/EpdFont/builtinFonts/babyblue.h

@@ -2,6 +2,7 @@
  * generated by fontconvert.py
  * name: babyblue
  * size: 8
+ * mode: 1-bit
  */
 #pragma once
 #include "EpdFontData.h"
@@ -500,5 +501,5 @@ static const EpdUnicodeInterval babyblueIntervals[] = {
 };
 
 static const EpdFontData babyblue = {
-    babyblueBitmaps, babyblueGlyphs, babyblueIntervals, 5, 17, 13, -4,
+    babyblueBitmaps, babyblueGlyphs, babyblueIntervals, 5, 17, 13, -4, false,
 };

lib/EpdFont/builtinFonts/pixelarial14.h

@@ -0,0 +1,184 @@
+/**
+ * generated by fontconvert.py
+ * name: pixelarial14
+ * size: 8
+ * mode: 1-bit
+ */
+#pragma once
+#include "EpdFontData.h"
+
+static const uint8_t pixelarial14Bitmaps[1145] = {
+    0xFF, 0xFF, 0xFF, 0xC0, 0xFF, 0xFF, 0xFF, 0x1C, 0x63, 0x8C, 0xF7, 0x98, 0xCF, 0xFF, 0xFF, 0xDC, 0xE7, 0xFE, 0xFF,
+    0xFF, 0xFB, 0x9C, 0x63, 0x0C, 0x60, 0x30, 0xF3, 0xFF, 0xBF, 0x1F, 0x9F, 0x9B, 0x37, 0xEF, 0xFB, 0xE3, 0x00, 0x70,
+    0x67, 0xCF, 0x37, 0x61, 0xBB, 0x0D, 0xF0, 0x7D, 0x81, 0xDD, 0xC0, 0xDF, 0x07, 0x98, 0xFC, 0xC7, 0x66, 0x7B, 0xF3,
+    0x07, 0x00, 0x3E, 0x0F, 0xE1, 0x8C, 0x31, 0x86, 0x60, 0xFC, 0x1F, 0x07, 0xE4, 0xC7, 0x98, 0xF3, 0x0E, 0x7F, 0xF7,
+    0xE6, 0xFF, 0xF0, 0x37, 0x66, 0xCC, 0xCC, 0xCC, 0xCC, 0xC6, 0x67, 0x30, 0xCE, 0x66, 0x33, 0x33, 0x33, 0x33, 0x36,
+    0x6E, 0xC0, 0x6F, 0xF6, 0xFF, 0x08, 0x0E, 0x07, 0x03, 0x8F, 0xFF, 0xFC, 0x70, 0x38, 0x1C, 0x0E, 0x00, 0xFF, 0xC0,
+    0xFB, 0xFF, 0x80, 0xF0, 0x1C, 0x73, 0xCC, 0x30, 0xC7, 0x18, 0x61, 0x8E, 0x30, 0xC0, 0x7E, 0xFF, 0xC3, 0xC3, 0xC3,
+    0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0x37, 0xFF, 0x33, 0x33, 0x33, 0x33, 0x30, 0x7E, 0xFF, 0xC3, 0xC3,
+    0x03, 0x03, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xFF, 0xFF, 0x7E, 0xFF, 0xC3, 0xC3, 0x03, 0x3F, 0x3F, 0x03, 0x03, 0xC3,
+    0xC3, 0xFF, 0x7E, 0x03, 0x03, 0x83, 0xC3, 0xE3, 0x31, 0x99, 0xCD, 0xC6, 0xC3, 0x7F, 0xFF, 0xE0, 0x60, 0x30, 0x7F,
+    0x7F, 0xE0, 0xC0, 0xFE, 0xFF, 0xC3, 0x03, 0x03, 0xC3, 0xC7, 0xFE, 0x7E, 0x7E, 0xFF, 0xC3, 0xC0, 0xC0, 0xFE, 0xFF,
+    0xE3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0xFF, 0xFF, 0x07, 0x06, 0x06, 0x1E, 0x1C, 0x1C, 0x1C, 0x38, 0x30, 0x30, 0x30,
+    0x7E, 0xFF, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0x7E, 0xFF, 0xC3, 0xC3, 0xC3, 0xC7,
+    0xFF, 0x7F, 0x03, 0x03, 0xC7, 0xFE, 0x7C, 0xF0, 0x00, 0x3C, 0xF0, 0x00, 0x3F, 0xF0, 0x03, 0x03, 0x1E, 0x7E, 0xF0,
+    0xF0, 0x70, 0x7E, 0x1F, 0x03, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xC0, 0xC0, 0x70, 0x7E, 0x1F, 0x0F, 0x1E, 0x7E,
+    0xF0, 0xC0, 0x7E, 0xFF, 0xC3, 0xC3, 0x03, 0x07, 0x1E, 0x1C, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3F, 0x87, 0xFE, 0xFF,
+    0x7D, 0xFB, 0xF1, 0xBF, 0x1B, 0xF3, 0xBF, 0xFF, 0xDF, 0xE6, 0x00, 0x7F, 0x03, 0xF0, 0x06, 0x01, 0xF0, 0x1F, 0x01,
+    0xF0, 0x1F, 0x03, 0xB8, 0x31, 0x87, 0xFC, 0x7F, 0xE7, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x30, 0xFF, 0x7F, 0xF0, 0x78,
+    0x3C, 0x1F, 0xFF, 0xFF, 0x83, 0xC1, 0xE0, 0xF0, 0x7F, 0xFF, 0xF0, 0x3F, 0x0F, 0xF3, 0x87, 0xE0, 0x3C, 0x01, 0x80,
+    0x30, 0x06, 0x00, 0xC0, 0x18, 0x0F, 0x87, 0xBF, 0xC3, 0xF0, 0xFF, 0x1F, 0xF3, 0x07, 0xE0, 0x3C, 0x07, 0x80, 0xF0,
+    0x1E, 0x03, 0xC0, 0x78, 0x0F, 0x07, 0xFF, 0xCF, 0xF0, 0xFF, 0xFF, 0xF0, 0x18, 0x0C, 0x07, 0xFF, 0xFF, 0x80, 0xC0,
+    0x60, 0x30, 0x1F, 0xFF, 0xF8, 0xFF, 0xFF, 0xF0, 0x18, 0x0C, 0x07, 0xFB, 0xFD, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C,
+    0x00, 0x3F, 0x87, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x0C, 0x00, 0xC1, 0xFC, 0x1F, 0xC0, 0x3C, 0x03, 0xE0, 0x77, 0xFE,
+    0x3F, 0x80, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x1F, 0xFF, 0xFF, 0x83, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x18, 0xFF, 0xFF,
+    0xFF, 0xC0, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x07, 0x8F, 0x1F, 0xF7, 0xC0, 0xC0, 0x78, 0x3F, 0x0E, 0x61,
+    0x8C, 0x61, 0xBC, 0x3F, 0x87, 0xB8, 0xE3, 0x1C, 0x63, 0x0E, 0x60, 0xFC, 0x06, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06,
+    0x03, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x1F, 0xFF, 0xF8, 0xC0, 0x3E, 0x07, 0xE0, 0x7E, 0x07, 0xF1, 0xBF, 0x1B, 0xFB,
+    0xBD, 0xF3, 0xDF, 0x3D, 0xF3, 0xDF, 0x3C, 0x63, 0xC6, 0x30, 0xC1, 0xF0, 0xFC, 0x7E, 0x3F, 0x1F, 0xEF, 0x77, 0xBB,
+    0xC7, 0xE3, 0xF1, 0xF8, 0x7C, 0x18, 0x3F, 0x87, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0,
+    0x3C, 0x03, 0xE0, 0x77, 0xFE, 0x3F, 0x80, 0xFF, 0x7F, 0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0xFF, 0xFE, 0xC0, 0x60, 0x30,
+    0x18, 0x0C, 0x00, 0x3F, 0x87, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x37, 0xE3,
+    0xE7, 0xFF, 0x3F, 0x70, 0xFF, 0x9F, 0xFF, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xFF, 0xFF, 0xFC, 0xC6, 0x18, 0xE3, 0x0E,
+    0x60, 0xFC, 0x06, 0x7F, 0x7F, 0xF0, 0x78, 0x3C, 0x07, 0xE1, 0xFE, 0x0F, 0x01, 0xE0, 0xF0, 0x7F, 0xF7, 0xF0, 0xFF,
+    0xFF, 0xC7, 0x03, 0x81, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x81, 0xC0, 0xC1, 0xE0, 0xF0, 0x78, 0x3C,
+    0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF8, 0xEF, 0xE3, 0xE0, 0xC0, 0x3C, 0x03, 0xE0, 0x76, 0x06, 0x60, 0x67, 0x1E,
+    0x31, 0x83, 0xB8, 0x1F, 0x01, 0xF0, 0x1F, 0x00, 0x60, 0x06, 0x00, 0xC1, 0x81, 0xE1, 0xF0, 0xF8, 0xD8, 0xEC, 0x6C,
+    0x66, 0x36, 0x33, 0x1B, 0x19, 0xDD, 0xFC, 0x6C, 0x7C, 0x36, 0x3E, 0x1B, 0x1F, 0x0F, 0x8F, 0x03, 0x83, 0x01, 0xC1,
+    0x80, 0xC0, 0x7C, 0x3D, 0x86, 0x30, 0xC3, 0x30, 0x7E, 0x07, 0x80, 0xF8, 0x33, 0x0E, 0x71, 0x86, 0x70, 0xFC, 0x06,
+    0xC0, 0x3E, 0x07, 0x71, 0xE3, 0x18, 0x31, 0x83, 0xF8, 0x1F, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06,
+    0x00, 0xFF, 0xFF, 0xFC, 0x0E, 0x01, 0x80, 0x30, 0x0E, 0x07, 0x80, 0xE0, 0x30, 0x06, 0x01, 0xC0, 0x7F, 0xFF, 0xFE,
+    0xFF, 0x6D, 0xB6, 0xDB, 0x6D, 0xB7, 0xE0, 0xC3, 0x0E, 0x18, 0x61, 0x87, 0x0C, 0x30, 0xC3, 0x87, 0x1C, 0xFD, 0xB6,
+    0xDB, 0x6D, 0xB6, 0xDF, 0xE0, 0x30, 0xF1, 0xF3, 0xE7, 0xDD, 0xF1, 0x80, 0xFF, 0xFF, 0xFC, 0xCE, 0x73, 0x00, 0x7E,
+    0x7E, 0xC3, 0xC3, 0x3F, 0x7F, 0x63, 0xE3, 0xC7, 0xFF, 0x7F, 0xC0, 0xC0, 0xFE, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3,
+    0xC3, 0xE3, 0xFF, 0xFE, 0x78, 0xFB, 0x1E, 0x3C, 0x18, 0x30, 0x60, 0xC7, 0xFD, 0xF0, 0x03, 0x03, 0x7B, 0x7F, 0xC7,
+    0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7F, 0x7E, 0x7E, 0xC3, 0xC3, 0xFF, 0xFF, 0xC0, 0xC0, 0xC3, 0xFF, 0x7E,
+    0x3D, 0xEF, 0xBF, 0x61, 0x86, 0x18, 0x61, 0x86, 0x18, 0x60, 0x7B, 0x7F, 0xC7, 0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7,
+    0xFF, 0x7F, 0x03, 0xC3, 0xFF, 0x7E, 0xC0, 0xC0, 0xFE, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
+    0xFF, 0xFF, 0xFF, 0xC0, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0xE0, 0xC0, 0xC0, 0xC3, 0xC3, 0xC6, 0xDE,
+    0xFC, 0xF8, 0xFC, 0xEE, 0xC6, 0xC7, 0xC3, 0xFF, 0xFF, 0xFF, 0xC0, 0xF9, 0xEF, 0xDE, 0xE7, 0x3E, 0x73, 0xC6, 0x3C,
+    0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x30, 0xFE, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
+    0xC3, 0x7E, 0x7E, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0xFE, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3,
+    0xC3, 0xE3, 0xFF, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0x7B, 0x7F, 0xC7, 0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7F,
+    0x03, 0x03, 0x03, 0x03, 0xFB, 0xFE, 0x38, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x00, 0x78, 0xFB, 0x1E, 0x3F, 0x8F, 0x81,
+    0x83, 0xC7, 0xFD, 0xF0, 0x61, 0x8F, 0xBF, 0x61, 0x86, 0x18, 0x61, 0x86, 0x1E, 0x7C, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
+    0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7F, 0xC1, 0xE0, 0xF0, 0x7C, 0x76, 0x33, 0xB8, 0xD8, 0x6C, 0x3E, 0x0E, 0x07, 0x00,
+    0xC6, 0x3C, 0x63, 0xC6, 0x3F, 0xF7, 0x7F, 0x67, 0xF6, 0x7F, 0x67, 0xF6, 0x7B, 0xE3, 0x18, 0x31, 0x80, 0xC3, 0xC3,
+    0x66, 0x66, 0x7E, 0x3C, 0x3C, 0x7E, 0x66, 0xE7, 0xC3, 0xC1, 0xE0, 0xF0, 0x7C, 0x76, 0x33, 0xB8, 0xD8, 0x6C, 0x36,
+    0x1F, 0x07, 0x03, 0x81, 0xC3, 0xE1, 0xC0, 0xFF, 0xFF, 0x06, 0x1E, 0x1C, 0x1C, 0x30, 0x30, 0x70, 0xFF, 0xFF, 0x37,
+    0x66, 0x66, 0x6E, 0xCE, 0x66, 0x66, 0x67, 0x30, 0xFF, 0xFF, 0xFF, 0xC0, 0xCE, 0x66, 0x66, 0x67, 0x37, 0x66, 0x66,
+    0x6E, 0xC0, 0xC3, 0x9B, 0xFF, 0xF9, 0xB8, 0x30, 0xDB, 0x66, 0xC0, 0x6D, 0xBD, 0x80, 0x7F, 0xEF, 0x3C, 0xF3, 0xC0,
+    0x7D, 0xF7, 0xDF, 0xF3, 0xC0,
+};
+
+static const EpdGlyph pixelarial14Glyphs[] = {
+    {0, 0, 4, 0, 0, 0, 0},          //
+    {2, 13, 3, 0, 13, 4, 0},        // !
+    {4, 6, 5, 0, 13, 3, 4},         // "
+    {11, 13, 12, 0, 13, 18, 7},     // #
+    {7, 13, 8, 0, 13, 12, 25},      // $
+    {13, 13, 14, 0, 13, 22, 37},    // %
+    {11, 13, 12, 0, 13, 18, 59},    // &
+    {2, 6, 3, 0, 13, 2, 77},        // '
+    {4, 17, 5, 0, 13, 9, 79},       // (
+    {4, 17, 5, 0, 13, 9, 88},       // )
+    {4, 6, 5, 0, 13, 3, 97},        // *
+    {9, 10, 10, 0, 11, 12, 100},    // +
+    {2, 5, 3, 0, 2, 2, 112},        // ,
+    {6, 3, 6, 0, 6, 3, 114},        // -
+    {2, 2, 3, 0, 2, 1, 117},        // .
+    {6, 13, 6, 0, 13, 10, 118},     // /
+    {8, 13, 9, 0, 13, 13, 128},     // 0
+    {4, 13, 5, 0, 13, 7, 141},      // 1
+    {8, 13, 9, 0, 13, 13, 148},     // 2
+    {8, 13, 9, 0, 13, 13, 161},     // 3
+    {9, 13, 10, 0, 13, 15, 174},    // 4
+    {8, 13, 9, 0, 13, 13, 189},     // 5
+    {8, 13, 9, 0, 13, 13, 202},     // 6
+    {8, 13, 9, 0, 13, 13, 215},     // 7
+    {8, 13, 9, 0, 13, 13, 228},     // 8
+    {8, 13, 9, 0, 13, 13, 241},     // 9
+    {2, 11, 3, 0, 11, 3, 254},      // :
+    {2, 14, 3, 0, 11, 4, 257},      // ;
+    {8, 10, 9, 0, 11, 10, 261},     // <
+    {8, 6, 9, 0, 9, 6, 271},        // =
+    {8, 10, 9, 0, 11, 10, 277},     // >
+    {8, 13, 9, 0, 13, 13, 287},     // ?
+    {12, 12, 13, 0, 9, 18, 300},    // @
+    {12, 13, 13, 0, 13, 20, 318},   // A
+    {9, 13, 10, 0, 13, 15, 338},    // B
+    {11, 13, 12, 0, 13, 18, 353},   // C
+    {11, 13, 12, 0, 13, 18, 371},   // D
+    {9, 13, 10, 0, 13, 15, 389},    // E
+    {9, 13, 10, 0, 13, 15, 404},    // F
+    {12, 13, 13, 0, 13, 20, 419},   // G
+    {9, 13, 10, 0, 13, 15, 439},    // H
+    {2, 13, 3, 0, 13, 4, 454},      // I
+    {7, 13, 8, 0, 13, 12, 458},     // J
+    {11, 13, 12, 0, 13, 18, 470},   // K
+    {9, 13, 10, 0, 13, 15, 488},    // L
+    {12, 13, 13, 0, 13, 20, 503},   // M
+    {9, 13, 10, 0, 13, 15, 523},    // N
+    {12, 13, 13, 0, 13, 20, 538},   // O
+    {9, 13, 10, 0, 13, 15, 558},    // P
+    {12, 13, 13, 0, 13, 20, 573},   // Q
+    {11, 13, 12, 0, 13, 18, 593},   // R
+    {9, 13, 10, 0, 13, 15, 611},    // S
+    {9, 13, 10, 0, 13, 15, 626},    // T
+    {9, 13, 10, 0, 13, 15, 641},    // U
+    {12, 13, 13, 0, 13, 20, 656},   // V
+    {17, 13, 18, 0, 13, 28, 676},   // W
+    {11, 13, 12, 0, 13, 18, 704},   // X
+    {12, 13, 13, 0, 13, 20, 722},   // Y
+    {11, 13, 12, 0, 13, 18, 742},   // Z
+    {3, 17, 4, 0, 13, 7, 760},      // [
+    {6, 13, 6, 0, 13, 10, 767},     // <backslash>
+    {3, 17, 4, 0, 13, 7, 777},      // ]
+    {7, 7, 8, 0, 13, 7, 784},       // ^
+    {11, 2, 12, 0, 2, 3, 791},      // _
+    {4, 5, 5, 0, 13, 3, 794},       // `
+    {8, 11, 9, 0, 11, 11, 797},     // a
+    {8, 13, 9, 0, 13, 13, 808},     // b
+    {7, 11, 8, 0, 11, 10, 821},     // c
+    {8, 13, 9, 0, 13, 13, 831},     // d
+    {8, 11, 9, 0, 11, 11, 844},     // e
+    {6, 13, 6, 0, 13, 10, 855},     // f
+    {8, 15, 9, 0, 11, 15, 865},     // g
+    {8, 13, 9, 0, 13, 13, 880},     // h
+    {2, 13, 3, 0, 13, 4, 893},      // i
+    {4, 17, 5, 0, 13, 9, 897},      // j
+    {8, 13, 9, 0, 13, 13, 906},     // k
+    {2, 13, 3, 0, 13, 4, 919},      // l
+    {12, 11, 13, 0, 11, 17, 923},   // m
+    {8, 11, 9, 0, 11, 11, 940},     // n
+    {8, 11, 9, 0, 11, 11, 951},     // o
+    {8, 15, 9, 0, 11, 15, 962},     // p
+    {8, 15, 9, 0, 11, 15, 977},     // q
+    {6, 11, 6, 0, 11, 9, 992},      // r
+    {7, 11, 8, 0, 11, 10, 1001},    // s
+    {6, 13, 6, 0, 13, 10, 1011},    // t
+    {8, 11, 9, 0, 11, 11, 1021},    // u
+    {9, 11, 10, 0, 11, 13, 1032},   // v
+    {12, 11, 13, 0, 11, 17, 1045},  // w
+    {8, 11, 9, 0, 11, 11, 1062},    // x
+    {9, 15, 10, 0, 11, 17, 1073},   // y
+    {8, 11, 9, 0, 11, 11, 1090},    // z
+    {4, 17, 5, 0, 13, 9, 1101},     // {
+    {2, 13, 3, 0, 13, 4, 1110},     // |
+    {4, 17, 5, 0, 13, 9, 1114},     // }
+    {11, 4, 12, 0, 9, 6, 1123},     // ~
+    {3, 6, 4, 0, 13, 3, 1129},      // ‘
+    {3, 6, 4, 0, 13, 3, 1132},      // ’
+    {6, 6, 6, 0, 13, 5, 1135},      // “
+    {6, 6, 6, 0, 13, 5, 1140},      // ”
+};
+
+static const EpdUnicodeInterval pixelarial14Intervals[] = {
+    {0x20, 0x7E, 0x0},
+    {0x2018, 0x2019, 0x5F},
+    {0x201C, 0x201D, 0x61},
+};
+
+static const EpdFontData pixelarial14 = {
+    pixelarial14Bitmaps, pixelarial14Glyphs, pixelarial14Intervals, 3, 17, 13, -4, false,
+};

lib/EpdFont/builtinFonts/ubuntu_10.h

@@ -2,6 +2,7 @@
  * generated by fontconvert.py
  * name: ubuntu_10
  * size: 10
+ * mode: 1-bit
  */
 #pragma once
 #include "EpdFontData.h"
@@ -762,5 +763,5 @@ static const EpdUnicodeInterval ubuntu_10Intervals[] = {
 };
 
 static const EpdFontData ubuntu_10 = {
-    ubuntu_10Bitmaps, ubuntu_10Glyphs, ubuntu_10Intervals, 31, 24, 20, -4,
+    ubuntu_10Bitmaps, ubuntu_10Glyphs, ubuntu_10Intervals, 31, 24, 20, -4, false,
 };

lib/EpdFont/builtinFonts/ubuntu_bold_10.h

@@ -2,6 +2,7 @@
  * generated by fontconvert.py
  * name: ubuntu_bold_10
  * size: 10
+ * mode: 1-bit
  */
 #pragma once
 #include "EpdFontData.h"
@@ -806,5 +807,5 @@ static const EpdUnicodeInterval ubuntu_bold_10Intervals[] = {
 };
 
 static const EpdFontData ubuntu_bold_10 = {
-    ubuntu_bold_10Bitmaps, ubuntu_bold_10Glyphs, ubuntu_bold_10Intervals, 31, 24, 20, -4,
+    ubuntu_bold_10Bitmaps, ubuntu_bold_10Glyphs, ubuntu_bold_10Intervals, 31, 24, 20, -4, false,
 };

lib/EpdFont/scripts/fontconvert.py

@@ -13,12 +13,14 @@ parser = argparse.ArgumentParser(description="Generate a header file from a font
 parser.add_argument("name", action="store", help="name of the font.")
 parser.add_argument("size", type=int, help="font size to use.")
 parser.add_argument("fontstack", action="store", nargs='+', help="list of font files, ordered by descending priority.")
+parser.add_argument("--2bit", dest="is2Bit", action="store_true", help="generate 2-bit greyscale bitmap instead of 1-bit black and white.")
 parser.add_argument("--additional-intervals", dest="additional_intervals", action="append", help="Additional code point intervals to export as min,max. This argument can be repeated.")
 args = parser.parse_args()
 
 GlyphProps = namedtuple("GlyphProps", ["width", "height", "advance_x", "left", "top", "data_length", "data_offset", "code_point"])
 
 font_stack = [freetype.Face(f) for f in args.fontstack]
+is2Bit = args.is2Bit
 size = args.size
 font_name = args.name
 
@@ -173,26 +175,73 @@ for i_start, i_end in intervals:
                 pixels4g.append(px)
                 px = 0
 
-        # Downsample to 1-bit bitmap - treat any non-zero as black
-        pixelsbw = []
-        px = 0
-        pitch = (bitmap.width // 2) + (bitmap.width % 2)
-        for y in range(bitmap.rows):
-            for x in range(bitmap.width):
-                px = px << 1
-                bm = pixels4g[y * pitch + (x // 2)]
-                px += 1 if ((x & 1) == 0 and bm & 0xF > 0) or ((x & 1) == 1 and bm & 0xF0 > 0) else 0
+        if is2Bit:
+            # 0 = white, 15 black, 8+ dark grey, 7- light grey
+            # Downsample to 2-bit bitmap
+            pixels2b = []
+            px = 0
+            pitch = (bitmap.width // 2) + (bitmap.width % 2)
+            for y in range(bitmap.rows):
+                for x in range(bitmap.width):
+                    px = px << 2
+                    bm = pixels4g[y * pitch + (x // 2)]
+                    bm = (bm >> ((x % 2) * 4)) & 0xF
 
-                if (y * bitmap.width + x) % 8 == 7:
-                    pixelsbw.append(px)
-                    px = 0
-        if (bitmap.width * bitmap.rows) % 8 != 0:
-            px = px << (8 - (bitmap.width * bitmap.rows) % 8)
-            pixelsbw.append(px)
+                    if bm == 15:
+                        px += 3
+                    elif bm >= 8:
+                        px += 2
+                    elif bm > 0:
+                        px += 1
 
+                    if (y * bitmap.width + x) % 4 == 3:
+                        pixels2b.append(px)
+                        px = 0
+            if (bitmap.width * bitmap.rows) % 4 != 0:
+                px = px << (4 - (bitmap.width * bitmap.rows) % 4) * 2
+                pixels2b.append(px)
+
+            # for y in range(bitmap.rows):
+            #     line = ''
+            #     for x in range(bitmap.width):
+            #         pixelPosition = y * bitmap.width + x
+            #         byte = pixels2b[pixelPosition // 4]
+            #         bit_index = (3 - (pixelPosition % 4)) * 2
+            #         line += '#' if ((byte >> bit_index) & 3) > 0 else '.'
+            #     print(line)
+            # print('')
+        else:
+            # Downsample to 1-bit bitmap - treat any non-zero as black
+            pixelsbw = []
+            px = 0
+            pitch = (bitmap.width // 2) + (bitmap.width % 2)
+            for y in range(bitmap.rows):
+                for x in range(bitmap.width):
+                    px = px << 1
+                    bm = pixels4g[y * pitch + (x // 2)]
+                    px += 1 if ((x & 1) == 0 and bm & 0xF > 0) or ((x & 1) == 1 and bm & 0xF0 > 0) else 0
+
+                    if (y * bitmap.width + x) % 8 == 7:
+                        pixelsbw.append(px)
+                        px = 0
+            if (bitmap.width * bitmap.rows) % 8 != 0:
+                px = px << (8 - (bitmap.width * bitmap.rows) % 8)
+                pixelsbw.append(px)
+
+            # for y in range(bitmap.rows):
+            #     line = ''
+            #     for x in range(bitmap.width):
+            #         pixelPosition = y * bitmap.width + x
+            #         byte = pixelsbw[pixelPosition // 8]
+            #         bit_index = 7 - (pixelPosition % 8)
+            #         line += '#' if (byte >> bit_index) & 1 else '.'
+            #     print(line)
+            # print('')
+
+        pixels = pixels2b if is2Bit else pixelsbw
 
         # Build output data
-        packed = bytes(pixelsbw)
+        packed = bytes(pixels)
         glyph = GlyphProps(
             width = bitmap.width,
             height = bitmap.rows,
@@ -216,7 +265,7 @@ for index, glyph in enumerate(all_glyphs):
     glyph_data.extend([b for b in packed])
     glyph_props.append(props)
 
-print(f"/**\n * generated by fontconvert.py\n * name: {font_name}\n * size: {size}\n */")
+print(f"/**\n * generated by fontconvert.py\n * name: {font_name}\n * size: {size}\n * mode: {'2-bit' if is2Bit else '1-bit'}\n */")
 print("#pragma once")
 print("#include \"EpdFontData.h\"\n")
 print(f"static const uint8_t {font_name}Bitmaps[{len(glyph_data)}] = {{")
@@ -244,4 +293,5 @@ print(f"    {len(intervals)},")
 print(f"    {norm_ceil(face.size.height)},")
 print(f"    {norm_ceil(face.size.ascender)},")
 print(f"    {norm_floor(face.size.descender)},")
+print(f"    {'true' if is2Bit else 'false'},")
 print("};")

lib/EpdFontRenderer/EpdFontRenderer.hpp

@@ -1,84 +0,0 @@
-#pragma once
-#include <EpdFontFamily.h>
-#include <HardwareSerial.h>
-#include <Utf8.h>
-
-inline int min(const int a, const int b) { return a < b ? a : b; }
-inline int max(const int a, const int b) { return a > b ? a : b; }
-
-template <typename Renderable>
-class EpdFontRenderer {
-  Renderable& renderer;
-  void renderChar(uint32_t cp, int* x, const int* y, uint16_t color, EpdFontStyle style = REGULAR);
-
- public:
-  const EpdFontFamily* fontFamily;
-  explicit EpdFontRenderer(const EpdFontFamily* fontFamily, Renderable& renderer)
-      : fontFamily(fontFamily), renderer(renderer) {}
-  ~EpdFontRenderer() = default;
-  void renderString(const char* string, int* x, int* y, uint16_t color, EpdFontStyle style = REGULAR);
-};
-
-template <typename Renderable>
-void EpdFontRenderer<Renderable>::renderString(const char* string, int* x, int* y, const uint16_t color,
-                                               const EpdFontStyle style) {
-  // cannot draw a NULL / empty string
-  if (string == nullptr || *string == '\0') {
-    return;
-  }
-
-  // no printable characters
-  if (!fontFamily->hasPrintableChars(string, style)) {
-    return;
-  }
-
-  uint32_t cp;
-  while ((cp = utf8NextCodepoint(reinterpret_cast<const uint8_t**>(&string)))) {
-    renderChar(cp, x, y, color, style);
-  }
-
-  *y += fontFamily->getData(style)->advanceY;
-}
-
-template <typename Renderable>
-void EpdFontRenderer<Renderable>::renderChar(const uint32_t cp, int* x, const int* y, uint16_t color,
-                                             const EpdFontStyle style) {
-  const EpdGlyph* glyph = fontFamily->getGlyph(cp, style);
-  if (!glyph) {
-    // TODO: Replace with fallback glyph property?
-    glyph = fontFamily->getGlyph('?', style);
-  }
-
-  // no glyph?
-  if (!glyph) {
-    Serial.printf("No glyph for codepoint %d\n", cp);
-    return;
-  }
-
-  const uint32_t offset = glyph->dataOffset;
-  const uint8_t width = glyph->width;
-  const uint8_t height = glyph->height;
-  const int left = glyph->left;
-
-  const uint8_t* bitmap = nullptr;
-  bitmap = &fontFamily->getData(style)->bitmap[offset];
-
-  if (bitmap != nullptr) {
-    for (int glyphY = 0; glyphY < height; glyphY++) {
-      int screenY = *y - glyph->top + glyphY;
-      for (int glyphX = 0; glyphX < width; glyphX++) {
-        const int pixelPosition = glyphY * width + glyphX;
-        int screenX = *x + left + glyphX;
-
-        const uint8_t byte = bitmap[pixelPosition / 8];
-        const uint8_t bit_index = 7 - (pixelPosition % 8);
-
-        if ((byte >> bit_index) & 1) {
-          renderer.drawPixel(screenX, screenY, color);
-        }
-      }
-    }
-  }
-
-  *x += glyph->advanceX;
-}

lib/EpdRenderer/EpdRenderer.cpp

@@ -1,168 +0,0 @@
-#include "EpdRenderer.h"
-
-#include "builtinFonts/babyblue.h"
-#include "builtinFonts/bookerly.h"
-#include "builtinFonts/bookerly_bold.h"
-#include "builtinFonts/bookerly_bold_italic.h"
-#include "builtinFonts/bookerly_italic.h"
-#include "builtinFonts/ubuntu_10.h"
-#include "builtinFonts/ubuntu_bold_10.h"
-
-EpdFont bookerlyFont(&bookerly);
-EpdFont bookerlyBoldFont(&bookerly_bold);
-EpdFont bookerlyItalicFont(&bookerly_italic);
-EpdFont bookerlyBoldItalicFont(&bookerly_bold_italic);
-EpdFontFamily bookerlyFontFamily(&bookerlyFont, &bookerlyBoldFont, &bookerlyItalicFont, &bookerlyBoldItalicFont);
-
-EpdFont smallFont(&babyblue);
-EpdFontFamily smallFontFamily(&smallFont);
-
-EpdFont ubuntu10Font(&ubuntu_10);
-EpdFont ununtuBold10Font(&ubuntu_bold_10);
-EpdFontFamily ubuntuFontFamily(&ubuntu10Font, &ununtuBold10Font);
-
-EpdRenderer::EpdRenderer(XteinkDisplay& display)
-    : display(display), marginTop(11), marginBottom(30), marginLeft(10), marginRight(10), lineCompression(0.95f) {
-  this->regularFontRenderer = new EpdFontRenderer<XteinkDisplay>(&bookerlyFontFamily, display);
-  this->smallFontRenderer = new EpdFontRenderer<XteinkDisplay>(&smallFontFamily, display);
-  this->uiFontRenderer = new EpdFontRenderer<XteinkDisplay>(&ubuntuFontFamily, display);
-}
-
-EpdRenderer::~EpdRenderer() {
-  delete regularFontRenderer;
-  delete smallFontRenderer;
-  delete uiFontRenderer;
-}
-
-int EpdRenderer::getTextWidth(const char* text, const EpdFontStyle style) const {
-  int w = 0, h = 0;
-
-  regularFontRenderer->fontFamily->getTextDimensions(text, &w, &h, style);
-
-  return w;
-}
-
-int EpdRenderer::getUiTextWidth(const char* text, const EpdFontStyle style) const {
-  int w = 0, h = 0;
-
-  uiFontRenderer->fontFamily->getTextDimensions(text, &w, &h, style);
-
-  return w;
-}
-
-int EpdRenderer::getSmallTextWidth(const char* text, const EpdFontStyle style) const {
-  int w = 0, h = 0;
-
-  smallFontRenderer->fontFamily->getTextDimensions(text, &w, &h, style);
-
-  return w;
-}
-
-void EpdRenderer::drawText(const int x, const int y, const char* text, const uint16_t color,
-                           const EpdFontStyle style) const {
-  int ypos = y + getLineHeight() + marginTop;
-  int xpos = x + marginLeft;
-  regularFontRenderer->renderString(text, &xpos, &ypos, color > 0 ? GxEPD_BLACK : GxEPD_WHITE, style);
-}
-
-void EpdRenderer::drawUiText(const int x, const int y, const char* text, const uint16_t color,
-                             const EpdFontStyle style) const {
-  int ypos = y + uiFontRenderer->fontFamily->getData(style)->advanceY + marginTop;
-  int xpos = x + marginLeft;
-  uiFontRenderer->renderString(text, &xpos, &ypos, color > 0 ? GxEPD_BLACK : GxEPD_WHITE, style);
-}
-
-void EpdRenderer::drawSmallText(const int x, const int y, const char* text, const uint16_t color,
-                                const EpdFontStyle style) const {
-  int ypos = y + smallFontRenderer->fontFamily->getData(style)->advanceY + marginTop;
-  int xpos = x + marginLeft;
-  smallFontRenderer->renderString(text, &xpos, &ypos, color > 0 ? GxEPD_BLACK : GxEPD_WHITE, style);
-}
-
-void EpdRenderer::drawTextBox(const int x, const int y, const std::string& text, const int width, const int height,
-                              const EpdFontStyle style) const {
-  const size_t length = text.length();
-  // fit the text into the box
-  int start = 0;
-  int end = 1;
-  int ypos = 0;
-  while (true) {
-    if (end >= length) {
-      drawText(x, y + ypos, text.substr(start, length - start).c_str(), 1, style);
-      break;
-    }
-
-    if (ypos + getLineHeight() >= height) {
-      break;
-    }
-
-    if (text[end - 1] == '\n') {
-      drawText(x, y + ypos, text.substr(start, end - start).c_str(), 1, style);
-      ypos += getLineHeight();
-      start = end;
-      end = start + 1;
-      continue;
-    }
-
-    if (getTextWidth(text.substr(start, end - start).c_str(), style) > width) {
-      drawText(x, y + ypos, text.substr(start, end - start - 1).c_str(), 1, style);
-      ypos += getLineHeight();
-      start = end - 1;
-      continue;
-    }
-
-    end++;
-  }
-}
-
-void EpdRenderer::drawLine(int x1, int y1, int x2, int y2, uint16_t color) const {
-  display.drawLine(x1 + marginLeft, y1 + marginTop, x2 + marginLeft, y2 + marginTop,
-                   color > 0 ? GxEPD_BLACK : GxEPD_WHITE);
-}
-
-void EpdRenderer::drawRect(const int x, const int y, const int width, const int height, const uint16_t color) const {
-  display.drawRect(x + marginLeft, y + marginTop, width, height, color > 0 ? GxEPD_BLACK : GxEPD_WHITE);
-}
-
-void EpdRenderer::fillRect(const int x, const int y, const int width, const int height, const uint16_t color) const {
-  display.fillRect(x + marginLeft, y + marginTop, width, height, color > 0 ? GxEPD_BLACK : GxEPD_WHITE);
-}
-
-void EpdRenderer::drawCircle(const int x, const int y, const int radius, const uint16_t color) const {
-  display.drawCircle(x + marginLeft, y + marginTop, radius, color > 0 ? GxEPD_BLACK : GxEPD_WHITE);
-}
-
-void EpdRenderer::fillCircle(const int x, const int y, const int radius, const uint16_t color) const {
-  display.fillCircle(x + marginLeft, y + marginTop, radius, color > 0 ? GxEPD_BLACK : GxEPD_WHITE);
-}
-
-void EpdRenderer::drawImage(const uint8_t bitmap[], const int x, const int y, const int width, const int height,
-                            const bool invert, const bool mirrorY) const {
-  drawImageNoMargin(bitmap, x + marginLeft, y + marginTop, width, height, invert, mirrorY);
-}
-
-void EpdRenderer::drawImageNoMargin(const uint8_t bitmap[], const int x, const int y, const int width, const int height,
-                                    const bool invert, const bool mirrorY) const {
-  display.drawImage(bitmap, x, y, width, height, invert, mirrorY);
-}
-
-void EpdRenderer::clearScreen(const bool black) const {
-  Serial.println("Clearing screen");
-  display.fillScreen(black ? GxEPD_BLACK : GxEPD_WHITE);
-}
-
-void EpdRenderer::flushDisplay(const bool partialUpdate) const { display.display(partialUpdate); }
-
-void EpdRenderer::flushArea(const int x, const int y, const int width, const int height) const {
-  display.displayWindow(x + marginLeft, y + marginTop, width, height);
-}
-
-int EpdRenderer::getPageWidth() const { return display.width() - marginLeft - marginRight; }
-
-int EpdRenderer::getPageHeight() const { return display.height() - marginTop - marginBottom; }
-
-int EpdRenderer::getSpaceWidth() const { return regularFontRenderer->fontFamily->getGlyph(' ', REGULAR)->advanceX; }
-
-int EpdRenderer::getLineHeight() const {
-  return regularFontRenderer->fontFamily->getData(REGULAR)->advanceY * lineCompression;
-}

lib/EpdRenderer/EpdRenderer.h

@@ -1,52 +0,0 @@
-#pragma once
-
-#include <GxEPD2_BW.h>
-
-#include <EpdFontRenderer.hpp>
-
-#define XteinkDisplay GxEPD2_BW<GxEPD2_426_GDEQ0426T82, GxEPD2_426_GDEQ0426T82::HEIGHT>
-
-class EpdRenderer {
-  XteinkDisplay& display;
-  EpdFontRenderer<XteinkDisplay>* regularFontRenderer;
-  EpdFontRenderer<XteinkDisplay>* smallFontRenderer;
-  EpdFontRenderer<XteinkDisplay>* uiFontRenderer;
-  int marginTop;
-  int marginBottom;
-  int marginLeft;
-  int marginRight;
-  float lineCompression;
-
- public:
-  explicit EpdRenderer(XteinkDisplay& display);
-  ~EpdRenderer();
-  int getTextWidth(const char* text, EpdFontStyle style = REGULAR) const;
-  int getUiTextWidth(const char* text, EpdFontStyle style = REGULAR) const;
-  int getSmallTextWidth(const char* text, EpdFontStyle style = REGULAR) const;
-  void drawText(int x, int y, const char* text, uint16_t color = 1, EpdFontStyle style = REGULAR) const;
-  void drawUiText(int x, int y, const char* text, uint16_t color = 1, EpdFontStyle style = REGULAR) const;
-  void drawSmallText(int x, int y, const char* text, uint16_t color = 1, EpdFontStyle style = REGULAR) const;
-  void drawTextBox(int x, int y, const std::string& text, int width, int height, EpdFontStyle style = REGULAR) const;
-  void drawLine(int x1, int y1, int x2, int y2, uint16_t color = 1) const;
-  void drawRect(int x, int y, int width, int height, uint16_t color = 1) const;
-  void fillRect(int x, int y, int width, int height, uint16_t color = 1) const;
-  void drawCircle(int x, int y, int radius, uint16_t color = 1) const;
-  void fillCircle(int x, int y, int radius, uint16_t color = 1) const;
-  void drawImage(const uint8_t bitmap[], int x, int y, int width, int height, bool invert = false,
-                 bool mirrorY = false) const;
-  void drawImageNoMargin(const uint8_t bitmap[], int x, int y, int width, int height, bool invert = false,
-                         bool mirrorY = false) const;
-  void clearScreen(bool black = false) const;
-  void flushDisplay(bool partialUpdate = true) const;
-  void flushArea(int x, int y, int width, int height) const;
-
-  int getPageWidth() const;
-  int getPageHeight() const;
-  int getSpaceWidth() const;
-  int getLineHeight() const;
-  // set margins
-  void setMarginTop(const int newMarginTop) { this->marginTop = newMarginTop; }
-  void setMarginBottom(const int newMarginBottom) { this->marginBottom = newMarginBottom; }
-  void setMarginLeft(const int newMarginLeft) { this->marginLeft = newMarginLeft; }
-  void setMarginRight(const int newMarginRight) { this->marginRight = newMarginRight; }
-};