InfoView.cpp

Go to the documentation of this file.

 
#include "cdc_views/InfoView.h"
#include "cdc_views/KeyCodes.h"
#include "cdc_views/LayoutConstants.h"
#include "cdc_views/RenderHelpers.h"
#include "cdc_ui/ViewStack.h"
#include "cdc_ui/I18n.h"
#include "cdc_hal/IDisplay.h"
#include "cdc_log.h"
#include <goodisplay/gdey029T94.h>
#include <cstring>
 
static const char* TAG = "InfoView";

static constexpr int TITLE_Y = 5;
static constexpr int TEXT_START_Y = 28;
static constexpr int TEXT_MARGIN = 8;
using cdc::ui::layout::FOOTER_HEIGHT;
using cdc::ui::layout::SCROLL_INDICATOR_WIDTH;
 
namespace cdc::ui {

namespace {
 
constexpr uint16_t WRAP_COLS = 44;
 
void wrapInPlace(char* buf, uint16_t maxCols) {
    if (!buf || maxCols == 0) return;
    uint16_t col = 0;
    char* lastSpace = nullptr;
    for (char* p = buf; *p; ++p) {
        if (*p == '\n') {
            col = 0;
            lastSpace = nullptr;
            continue;
        }
        if (col >= maxCols && lastSpace) {
            *lastSpace = '\n';
            col = static_cast<uint16_t>(p - lastSpace - 1);
            lastSpace = nullptr;
        }
        if (*p == ' ') lastSpace = p;
        ++col;
    }
}
 
}  // namespace
 
void InfoView::init(const char* title, const char* text) {
    if (title) {
        strncpy(titleBuf_, title, MAX_TITLE_LEN - 1);
        titleBuf_[MAX_TITLE_LEN - 1] = '\0';
    } else {
        titleBuf_[0] = '\0';
    }
 
    if (!textBuf_) {
        textBuf_ = cdc::core::psramAlloc<char>(MAX_TEXT_LEN);
    }
    if (textBuf_) {
        if (text) {
            strncpy(textBuf_.get(), text, MAX_TEXT_LEN - 1);
            textBuf_.get()[MAX_TEXT_LEN - 1] = '\0';
        } else {
            textBuf_.get()[0] = '\0';
        }
        wrapInPlace(textBuf_.get(), WRAP_COLS);
    }
 
    scrollLine_ = 0;
    totalLines_ = countLines();
    customHint_ = nullptr;
    dirty_ = true;
 
    LOG_D(TAG, "init: title='%s', lines=%d", titleBuf_, totalLines_);
}

uint16_t InfoView::countLines() const {
    if (!textBuf_ || textBuf_.get()[0] == '\0') return 0;
 
    uint16_t lines = 1;
    const char* p = textBuf_.get();
    while (*p) {
        if (*p == '\n') lines++;
        p++;
    }
    return lines;
}

void InfoView::scroll(bool down) {
    if (totalLines_ <= VISIBLE_LINES) return;
 
    if (down) {
        if (scrollLine_ < totalLines_ - VISIBLE_LINES) {
            scrollLine_++;
        } else {
            // Wrap to top
            scrollLine_ = 0;
        }
    } else {
        if (scrollLine_ > 0) {
            scrollLine_--;
        } else {
            // Wrap to bottom
            scrollLine_ = totalLines_ - VISIBLE_LINES;
        }
    }
 
    dirty_ = true;
}

InputResult InfoView::onKey(char key) {
    if (key == KEY_YES && onYes_) {
        onYes_(callbackUserData_);
        return InputResult::CONSUMED;
    }
    if (key == KEY_NO && onNo_) {
        onNo_(callbackUserData_);
        return InputResult::CONSUMED;
    }
    if (key == KEY_MENU && onMenu_) {
        onMenu_(menuUserData_);
        return InputResult::CONSUMED;
    }
 
    switch (key) {
        case KEY_UP:
            scroll(false);
            return InputResult::CONSUMED;
 
        case KEY_DOWN:
            scroll(true);
            return InputResult::CONSUMED;
 
        case KEY_NO:  // Back
            return InputResult::REQUEST_POP;
 
        default:
            // KEY_YES (and any other key) is left free: the plugin can bind it
            // via the KEY_PRESSED EventBus or an explicit onYes_ callback.
            return InputResult::IGNORED;
    }
}

InputResult InfoView::onLongPress(char key) {
    if (totalLines_ <= VISIBLE_LINES) return InputResult::IGNORED;
    switch (key) {
        case KEY_UP:   scrollLine_ = 0; dirty_ = true; return InputResult::CONSUMED;
        case KEY_DOWN: scrollLine_ = totalLines_ - VISIBLE_LINES; dirty_ = true; return InputResult::CONSUMED;
        default:       return InputResult::IGNORED;
    }
}

const char* InfoView::getFooterHint() const {
    if (customHint_) {
        return customHint_;
    }
    return ui::tr("core.hint_scroll_back");
}

void InfoView::render(bool partial) {
    hal::IDisplay* display = hal::getDisplayInstance();
    if (!display) return;
 
    auto* gfx = static_cast<Gdey029T94*>(display->getNativeHandle());
    if (!gfx) return;
 
    const uint16_t width = display->getWidth();
    const uint16_t height = display->getHeight();
 
    if (!partial) {
        gfx->fillScreen(EPD_WHITE);
    } else {
        // Partial repaint (e.g. as a modal over a base view): clear the whole
        // content band including the header, so a header/body underneath does
        // not bleed through behind the freshly drawn title.
        gfx->fillRect(0, 0, width, height - FOOTER_HEIGHT, EPD_WHITE);
    }
 
    gfx->setFont(nullptr);  // 6x8 built-in (CP437): never inherit a leaked GFX font
    gfx->setTextColor(EPD_BLACK);
    gfx->setTextSize(1);
 
    // Title + underline
    const char* title = (titleBuf_[0] != '\0') ? titleBuf_ : nullptr;
    render::drawHeaderLeft(gfx, title, TEXT_MARGIN, TITLE_Y, width);
 
    // Text area dimensions
    int textAreaWidth = width - TEXT_MARGIN * 2 - SCROLL_INDICATOR_WIDTH;
    int textAreaHeight = height - TEXT_START_Y - FOOTER_HEIGHT;
 
    // Clear text area
    gfx->fillRect(TEXT_MARGIN, TEXT_START_Y, textAreaWidth, textAreaHeight, EPD_WHITE);
 
    // Render visible lines
    if (textBuf_ && textBuf_.get()[0] != '\0') {
        const char* lineStart = textBuf_.get();
        uint16_t currentLine = 0;
        int y = TEXT_START_Y;
 
        // Skip to scroll position
        while (currentLine < scrollLine_ && *lineStart) {
            if (*lineStart == '\n') currentLine++;
            lineStart++;
        }
 
        // Render visible lines
        for (uint8_t i = 0; i < VISIBLE_LINES && *lineStart; i++) {
            gfx->setCursor(TEXT_MARGIN, y);
 
            // Find end of line
            const char* lineEnd = lineStart;
            while (*lineEnd && *lineEnd != '\n') lineEnd++;
 
            // Print line (character by character to handle no null-terminator)
            while (lineStart < lineEnd) {
                gfx->print(*lineStart);
                lineStart++;
            }
 
            // Skip newline
            if (*lineStart == '\n') lineStart++;
 
            y += LINE_HEIGHT;
        }
    }
 
    // Scroll indicators (if needed)
    if (totalLines_ > VISIBLE_LINES) {
        int indicatorX = width - SCROLL_INDICATOR_WIDTH;
        int listHeight = VISIBLE_LINES * LINE_HEIGHT;
        render::drawScrollIndicator(gfx, indicatorX, TEXT_START_Y, listHeight,
                                    totalLines_, VISIBLE_LINES, scrollLine_);
    }
 
    // Footer
    char posStr[20];  // Max: "65535-65535/65535  \0"
    const char* prefix = nullptr;
    if (totalLines_ > VISIBLE_LINES) {
        snprintf(posStr, sizeof(posStr), "%u-%u/%u  ",
                 scrollLine_ + 1,
                 scrollLine_ + VISIBLE_LINES > totalLines_ ? totalLines_ : scrollLine_ + VISIBLE_LINES,
                 totalLines_);
        prefix = posStr;
    }
    const char* hint = getFooterHint();
    render::drawFooterBar(gfx, width, height, prefix, hint, true);
 
    dirty_ = false;
}

 
static InfoView s_sharedInfoView;

InfoView* showInfo(const char* title, const char* text, const char* hint) {
    s_sharedInfoView.init(title, text);
    if (hint) {
        s_sharedInfoView.setHint(hint);
    }
    ViewStack::instance().push(&s_sharedInfoView);
    return &s_sharedInfoView;
}
 
} // namespace cdc::ui