Flashcard newline and supplement font not working

[rdsdjqwyqx-crypto]

Affected Version

1.83

Describe the Bug

Newline /n in csv does not produce new line on back of card in flashcards.

Adding new font for support of different languages (Cyrillic alphabet) does not carry over to flashcards. Unsupported characters show as apostrophes or crash.

Steps to Reproduce

1. Add flashcard csv with newline character /n
2. Go to Apps
3. Select Flashcards
4. Select an imported csv as flashcards to review
5. Open flashcard (one line running off screen)

Expected Behavior

Newline /n should reflect in back of flashcard.

Adding new font and setting as Supplement [ON] should fill in character's that can't be rendered in flashcards as well.

Relevant Log Output/Screenshots

[pebblot]

Fix in src/activities/flashcard/FlashcardReviewActivity.cpp and FlashcardReviewActivity.h is that the Flashcard App does not rely on the user to type /n, but that the program recognizes it. Also instead of renderFront () being fixed at Bookerly_18, it tries the biggest font and sizes it down until everything fits on the screen.

### Here is the optimized source code for FlashcardReviewActivity.h
#pragma once
#include "../Activity.h"
#include "FlashcardDeck.h"
#include "FlashcardSrs.h"
#include
#include

class FlashcardReviewActivity final : public Activity {
public:
FlashcardReviewActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
const std::string& deckPath);
void onEnter() override;
void loop() override;
void render(RenderLock&&) override;

private:
enum class CardState { Front, Back };

void flipCard();
void rateCard(SrsRating rating);
void renderFront(const FlashcardCard& card);
void renderBack(const FlashcardCard& card);

// Picks the largest font from fontIds[] (tried largest-first) that allows
// `text` to word-wrap without truncation inside a box of boxWidth x boxHeight
// pixels. Draws the wrapped lines centered horizontally starting at startY.
// Returns the Y coordinate directly below the last rendered line.
int drawAdaptiveText(const std::string& text, int startY,
                     int boxWidth, int boxHeight,
                     const int* fontIds, int numFonts);

FlashcardDeck deck;
std::string deckPath;
std::vector<size_t> reviewQueue;
size_t currentQueueIndex = 0;
CardState cardState = CardState::Front;
uint32_t today = 0;
uint8_t saveCounter = 0;  // batch save every 5 cards
size_t maxQueueSize = 0;  // cap for re-queue growth (2x initial)

};

### Here is the optimized source code for FlashcardReviewActivity.cpp

#include "FlashcardReviewActivity.h"

#include <GfxRenderer.h>
#include <HalGPIO.h>
#include <I18n.h>

#include

#include "components/UITheme.h"
#include "CrossPetSettings.h"
#include "fontIds.h"
#include "FlashcardDoneActivity.h"

// ─── Constructor ─────────────────────────────────────────────────────────────

FlashcardReviewActivity::FlashcardReviewActivity(GfxRenderer& renderer,
MappedInputManager& mappedInput,
const std::string& deckPath)
: Activity("FlashcardReview", renderer, mappedInput), deckPath(deckPath) {}

// ─── Lifecycle ────────────────────────────────────────────────────────────────

void FlashcardReviewActivity::onEnter() {
Activity::onEnter();
today = FlashcardSrs::getToday();
deck.loadFromCsv(deckPath.c_str());
reviewQueue = deck.buildReviewQueue(today,
PET_SETTINGS.flashcardNewPerDay,
PET_SETTINGS.flashcardMaxReviewPerDay);
currentQueueIndex = 0;
cardState = CardState::Front;
saveCounter = 0;

if (reviewQueue.empty()) {
    activityManager.pushActivity(
        std::make_unique<FlashcardDoneActivity>(renderer, mappedInput));
    return;
}
maxQueueSize = reviewQueue.size() * 2;
requestUpdate();

}

// ─── Input loop ───────────────────────────────────────────────────────────────

void FlashcardReviewActivity::loop() {
if (reviewQueue.empty() || currentQueueIndex >= reviewQueue.size()) return;

if (cardState == CardState::Front) {
    if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
        deck.saveToCsv(deckPath.c_str());
        finish();
        return;
    }
    if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
        flipCard();
    }
} else {
    // Back state — 4 buttons map to 4 SRS ratings
    // Back->Again, Left/Up->Hard, Right/Down->Good, Confirm->Easy
    if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
        rateCard(SrsRating::Again);
    } else if (mappedInput.wasReleased(MappedInputManager::Button::Left) ||
               mappedInput.wasReleased(MappedInputManager::Button::Up)) {
        rateCard(SrsRating::Hard);
    } else if (mappedInput.wasReleased(MappedInputManager::Button::Right) ||
               mappedInput.wasReleased(MappedInputManager::Button::Down)) {
        rateCard(SrsRating::Good);
    } else if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
        rateCard(SrsRating::Easy);
    }
}

}

// ─── Card state transitions ───────────────────────────────────────────────────

void FlashcardReviewActivity::flipCard() {
cardState = CardState::Back;
requestUpdate();
}

void FlashcardReviewActivity::rateCard(SrsRating rating) {
size_t cardIdx = reviewQueue[currentQueueIndex];
auto& card = deck.getCards()[cardIdx];
SrsState newState = FlashcardSrs::review(card.srs, rating, today);
deck.updateCard(cardIdx, newState);

if (rating == SrsRating::Again && reviewQueue.size() < maxQueueSize) {
    reviewQueue.push_back(cardIdx);  // re-queue failed card at end
}

currentQueueIndex++;
saveCounter++;

if (saveCounter >= 5) {
    deck.saveToCsv(deckPath.c_str());
    saveCounter = 0;
}

if (currentQueueIndex >= reviewQueue.size()) {
    deck.saveToCsv(deckPath.c_str());
    activityManager.pushActivity(
        std::make_unique<FlashcardDoneActivity>(renderer, mappedInput));
} else {
    cardState = CardState::Front;
    requestUpdate();
}

}

// ─── Adaptive text helper ─────────────────────────────────────────────────────
//
// Tries each font in fontIds (largest first) and picks the largest one whose
// word-wrapped output fits within boxWidth x boxHeight without truncation.
// Falls back to the smallest font if nothing fits perfectly.
// Draws lines centered horizontally, starting at startY.
// Returns the Y coordinate directly below the last drawn line.

int FlashcardReviewActivity::drawAdaptiveText(const std::string& text,
int startY,
int boxWidth,
int boxHeight,
const int* fontIds,
int numFonts) {
int chosenFont = fontIds[numFonts - 1];
int chosenLineHeight = renderer.getLineHeight(chosenFont);
std::vectorstd::string chosenLines;

for (int fi = 0; fi < numFonts; ++fi) {
    int fid = fontIds[fi];
    int lh  = renderer.getLineHeight(fid);
    if (lh <= 0) continue;

    int maxLines = boxHeight / lh;
    if (maxLines < 1) maxLines = 1;

    auto lines = renderer.wrappedText(fid, text.c_str(), boxWidth, maxLines);

    // wrappedText() appends U+2026 (0xE2 0x80 0xA6) when text is truncated.
    // If the last line ends with that sequence the font is too large.
    bool truncated = false;
    if (!lines.empty()) {
        const auto& last = lines.back();
        if (last.size() >= 3) {
            auto sz = last.size();
            if ((uint8_t)last[sz - 3] == 0xE2 &&
                (uint8_t)last[sz - 2] == 0x80 &&
                (uint8_t)last[sz - 1] == 0xA6) {
                truncated = true;
            }
        }
    }

    if (!truncated) {
        chosenFont       = fid;
        chosenLineHeight = lh;
        chosenLines      = std::move(lines);
        break;
    }

    // Smallest font — use it regardless
    if (fi == numFonts - 1) {
        chosenFont       = fid;
        chosenLineHeight = lh;
        chosenLines      = std::move(lines);
    }
}

// Safety: regenerate if chosenLines is somehow empty
if (chosenLines.empty()) {
    int maxLines = (chosenLineHeight > 0) ? boxHeight / chosenLineHeight : 1;
    if (maxLines < 1) maxLines = 1;
    chosenLines = renderer.wrappedText(chosenFont, text.c_str(), boxWidth, maxLines);
}

int y = startY;
for (const auto& line : chosenLines) {
    renderer.drawCenteredText(chosenFont, y, line.c_str());
    y += chosenLineHeight;
}
return y;

}

// ─── Render ───────────────────────────────────────────────────────────────────

void FlashcardReviewActivity::render(RenderLock&&) {
if (reviewQueue.empty() || currentQueueIndex >= reviewQueue.size()) return;

const auto& card = deck.getCards()[reviewQueue[currentQueueIndex]];
renderer.clearScreen();

const auto& metrics = UITheme::getInstance().getMetrics();
auto pageWidth = renderer.getScreenWidth();

GUI.drawHeader(renderer,
               Rect{0, metrics.topPadding, pageWidth, metrics.headerHeight},
               deck.getName().c_str());

if (cardState == CardState::Front) {
    renderFront(card);
} else {
    renderBack(card);
}

renderer.displayBuffer();

}

// ─── renderFront ──────────────────────────────────────────────────────────────

void FlashcardReviewActivity::renderFront(const FlashcardCard& card) {
const auto& metrics = UITheme::getInstance().getMetrics();
auto pageWidth = renderer.getScreenWidth();
auto pageHeight = renderer.getScreenHeight();
int contentTop = metrics.topPadding + metrics.headerHeight + metrics.verticalSpacing;
int contentBottom = pageHeight - metrics.buttonHintsHeight - metrics.verticalSpacing;
int contentHeight = contentBottom - contentTop;
int boxWidth = pageWidth - 2 * metrics.contentSidePadding;

// Candidate fonts for the front question, largest -> smallest
static const int kFrontFonts[] = {
    BOOKERLY_18_FONT_ID,
    BOOKERLY_16_FONT_ID,
    BOOKERLY_14_FONT_ID,
    BOOKERLY_12_FONT_ID,
    UI_10_FONT_ID,
};
constexpr int kNumFrontFonts = sizeof(kFrontFonts) / sizeof(kFrontFonts[0]);

std::string mainText = card.frontMain();
std::string hint     = card.frontHint();

// Reserve height for hint line so it never overlaps the main text
int hintReserve = hint.empty() ? 0 :
    renderer.getLineHeight(UI_10_FONT_ID) + metrics.verticalSpacing;
int mainBoxHeight = contentHeight - hintReserve;

// Start in the upper-third of the content area (original feel for short
// cards; avoids top-cling for longer ones)
int textY = contentTop + contentHeight / 3;

int afterMain = drawAdaptiveText(mainText, textY, boxWidth, mainBoxHeight,
                                 kFrontFonts, kNumFrontFonts);

if (!hint.empty()) {
    afterMain += metrics.verticalSpacing;
    renderer.drawCenteredText(UI_10_FONT_ID, afterMain, hint.c_str());
}

// Button hints: Back + Show
const auto labels = mappedInput.mapLabels(tr(STR_BACK), tr(STR_FLASHCARD_SHOW), "", "");
GUI.drawButtonHints(renderer, labels.btn1, labels.btn2, labels.btn3, labels.btn4);

}

// ─── renderBack ───────────────────────────────────────────────────────────────

void FlashcardReviewActivity::renderBack(const FlashcardCard& card) {
const auto& metrics = UITheme::getInstance().getMetrics();
auto pageWidth = renderer.getScreenWidth();
auto pageHeight = renderer.getScreenHeight();
int contentTop = metrics.topPadding + metrics.headerHeight + metrics.verticalSpacing;
int boxWidth = pageWidth - 2 * metrics.contentSidePadding;

// --- Two-line SRS buttons at bottom ---
const auto origOrientation = renderer.getOrientation();
renderer.setOrientation(GfxRenderer::Orientation::Portrait);

constexpr int btnWidth  = 106;
constexpr int btnHeight = 50;
const int portHeight = renderer.getScreenHeight();
const int btnY = portHeight - btnHeight;
const int x4Pos[] = {25, 130, 245, 350};
const int x3Pos[] = {38, 154, 268, 384};
const int* btnPos = gpio.deviceIsX3() ? x3Pos : x4Pos;

const auto& srs = card.srs;
char iv1[16], iv2[16], iv3[16], iv4[16];
strncpy(iv1, FlashcardSrs::previewInterval(srs, SrsRating::Again), sizeof(iv1));
strncpy(iv2, FlashcardSrs::previewInterval(srs, SrsRating::Hard),  sizeof(iv2));
strncpy(iv3, FlashcardSrs::previewInterval(srs, SrsRating::Good),  sizeof(iv3));
strncpy(iv4, FlashcardSrs::previewInterval(srs, SrsRating::Easy),  sizeof(iv4));
iv1[15] = iv2[15] = iv3[15] = iv4[15] = '\0';

const char* intervals_raw[] = {iv1, iv4, iv2, iv3};
const char* ratings_raw[] = {
    tr(STR_FLASHCARD_AGAIN), tr(STR_FLASHCARD_EASY),
    tr(STR_FLASHCARD_HARD),  tr(STR_FLASHCARD_GOOD)};

const char* intervals[4];
const char* ratings[4];
if (origOrientation == GfxRenderer::Orientation::PortraitInverted) {
    intervals[0] = intervals_raw[3]; intervals[1] = intervals_raw[2];
    intervals[2] = intervals_raw[1]; intervals[3] = intervals_raw[0];
    ratings[0]   = ratings_raw[3];   ratings[1]   = ratings_raw[2];
    ratings[2]   = ratings_raw[1];   ratings[3]   = ratings_raw[0];
} else {
    for (int i = 0; i < 4; i++) {
        intervals[i] = intervals_raw[i];
        ratings[i]   = ratings_raw[i];
    }
}

for (int i = 0; i < 4; i++) {
    int x = btnPos[i];
    renderer.fillRect(x, btnY, btnWidth, btnHeight, false);
    renderer.drawRect(x, btnY, btnWidth, btnHeight);
    int tw1 = renderer.getTextWidth(SMALL_FONT_ID, intervals[i]);
    renderer.drawText(SMALL_FONT_ID, x + (btnWidth - tw1) / 2, btnY + 7,  intervals[i]);
    int tw2 = renderer.getTextWidth(UI_10_FONT_ID, ratings[i]);
    renderer.drawText(UI_10_FONT_ID, x + (btnWidth - tw2) / 2, btnY + 27, ratings[i]);
}

renderer.setOrientation(origOrientation);

// --- Content area layout ---
int contentBottom = pageHeight - btnHeight - metrics.verticalSpacing;
int contentHeight = contentBottom - contentTop;

// Upper 40% for the front question reminder, lower 60% for the answer.
// The separator + its padding occupies a small slice in between.
constexpr int kSepSlice = 2;  // separator line height
int frontAreaHeight = contentHeight * 2 / 5;
int backAreaHeight  = contentHeight
                      - frontAreaHeight
                      - metrics.verticalSpacing * 2
                      - kSepSlice;

// ── Front reminder ────────────────────────────────────────────────────────
// Use slightly smaller font range since the question is already known
static const int kFrontSmallFonts[] = {
    BOOKERLY_16_FONT_ID,
    BOOKERLY_14_FONT_ID,
    BOOKERLY_12_FONT_ID,
    UI_10_FONT_ID,
};
constexpr int kNumFrontSmall = sizeof(kFrontSmallFonts) / sizeof(kFrontSmallFonts[0]);

std::string mainText = card.frontMain();
int textY    = contentTop + frontAreaHeight / 3;
int afterFront = drawAdaptiveText(mainText, textY, boxWidth, frontAreaHeight,
                                  kFrontSmallFonts, kNumFrontSmall);

std::string hint = card.frontHint();
if (!hint.empty()) {
    afterFront += 4;
    renderer.drawCenteredText(UI_10_FONT_ID, afterFront, hint.c_str());
    afterFront += renderer.getLineHeight(UI_10_FONT_ID);
}

// ── Separator ─────────────────────────────────────────────────────────────
int sepY = contentTop + frontAreaHeight + metrics.verticalSpacing;
renderer.drawLine(metrics.contentSidePadding, sepY,
                  pageWidth - metrics.contentSidePadding, sepY, true);

// ── Answer (back content) — adaptive, full remaining height ───────────────
static const int kBackFonts[] = {
    BOOKERLY_18_FONT_ID,
    BOOKERLY_16_FONT_ID,
    BOOKERLY_14_FONT_ID,
    BOOKERLY_12_FONT_ID,
    UI_10_FONT_ID,
};
constexpr int kNumBackFonts = sizeof(kBackFonts) / sizeof(kBackFonts[0]);

int backStartY = sepY + metrics.verticalSpacing;
drawAdaptiveText(card.backContent, backStartY, boxWidth, backAreaHeight,
                 kBackFonts, kNumBackFonts);

}

FlashcardReviewActivity.cpp