jpirnay
45441e0789
Add SdCardFontFamilyInfo::pickClosestSize(targetPtSize) and have the
manager and SdCardFontSystem drive size selection from a target point
size derived from the user's font-size enum (SMALL=12, MEDIUM=14,
LARGE=16, EXTRA_LARGE=18) rather than indexing the family's sorted size
list by enum ordinal.
The ordinal-slot approach mis-selects whenever a family doesn't ship the
canonical {12,14,16,18} set: a family with only [10,14,18] would map
SMALL/MEDIUM/LARGE/EXTRA_LARGE to 10/14/18/18 — fine for SMALL but
arbitrary for the rest. Closest-pt always picks the on-disk file nearest
to the user-intended point size, with a deterministic smaller-pt
tie-break.
No change for canonical-sized families.
## Summary
* **What is the goal of this PR?** (e.g., Implements the new feature for
file uploading.)
* **What changes are included?**
## Additional Context
* 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? _**< YES | PARTIALLY | NO
>**_
68 lines
3.0 KiB
C++
68 lines
3.0 KiB
C++
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
struct SdCardFontFileInfo {
|
|
std::string path; // v4 on-disk naming: "/<root>/<Family>/<Family>_<size>.cpfont"
|
|
// where <root> is "/.fonts" (preferred, hidden) or "/fonts" (visible).
|
|
// e.g. "/.fonts/NotoSansCJK/NotoSansCJK_14.cpfont"
|
|
uint8_t pointSize; // parsed from filename: 14
|
|
uint8_t style; // always 0 in v4 (all 4 styles bundled in one file);
|
|
// kept for potential future formats
|
|
};
|
|
|
|
struct SdCardFontFamilyInfo {
|
|
std::string name; // directory name, e.g. "NotoSansCJK"
|
|
std::vector<SdCardFontFileInfo> files;
|
|
|
|
const SdCardFontFileInfo* findFile(uint8_t size, uint8_t style = 0) const;
|
|
bool hasSize(uint8_t size) const;
|
|
std::vector<uint8_t> availableSizes() const;
|
|
|
|
// Pick the file whose pointSize is closest to targetPtSize. On ties (equal
|
|
// distance) prefers the smaller pointSize so behaviour is deterministic
|
|
// across SD card layouts. Returns nullptr when files is empty.
|
|
//
|
|
// Robust against families that don't ship the canonical {12,14,16,18} set:
|
|
// a family with only [10,14,18] resolves target 12 → 10 (or 14 on tie),
|
|
// target 16 → 14 or 18, etc., instead of mis-indexing by ordinal slot.
|
|
const SdCardFontFileInfo* pickClosestSize(uint8_t targetPtSize) const;
|
|
};
|
|
|
|
class SdCardFontRegistry {
|
|
public:
|
|
static constexpr int MAX_SD_FAMILIES = 128;
|
|
// Two top-level roots are scanned at discovery time. Hidden is preferred
|
|
// when creating new installs; both are read from if present.
|
|
static constexpr const char* FONTS_DIR_HIDDEN = "/.fonts";
|
|
static constexpr const char* FONTS_DIR_VISIBLE = "/fonts";
|
|
|
|
// Returns the existing root for `familyName` (the one that contains
|
|
// /<root>/<familyName>/), or nullptr if the family is not installed in
|
|
// either root. Used by writers to keep re-installs in their existing dir.
|
|
static const char* findFamilyRoot(const char* familyName);
|
|
|
|
// Returns the root path that should be used when creating a brand-new
|
|
// family on disk (no prior install): the existing root if exactly one of
|
|
// the two roots exists, otherwise the hidden root.
|
|
static const char* defaultWriteRoot();
|
|
|
|
// Scan SD card, populate families_. Returns true if any families found.
|
|
bool discover();
|
|
|
|
const std::vector<SdCardFontFamilyInfo>& getFamilies() const { return families_; }
|
|
const SdCardFontFamilyInfo* findFamily(const std::string& name) const;
|
|
int getFamilyIndex(const std::string& name) const;
|
|
int getFamilyCount() const { return static_cast<int>(families_.size()); }
|
|
|
|
private:
|
|
std::vector<SdCardFontFamilyInfo> families_; // sorted alphabetically
|
|
|
|
static bool parseFilename(const char* filename, uint8_t& size, uint8_t& style);
|
|
static void scanDirectory(const char* dirPath, SdCardFontFamilyInfo& family);
|
|
// Scan one root (e.g. "/.fonts"), append families to `out`, dedup by name.
|
|
static void scanRoot(const char* rootPath, std::vector<SdCardFontFamilyInfo>& out);
|
|
};
|