mirror of
https://github.com/daveallie/crosspoint-reader.git
synced 2026-02-04 14:47:37 +03:00
513 lines
14 KiB
C++
513 lines
14 KiB
C++
#pragma once
|
|
|
|
#include "ThemeContext.h"
|
|
#include "ThemeTypes.h"
|
|
#include "UIElement.h"
|
|
#include <Bitmap.h>
|
|
#include <SDCardManager.h>
|
|
#include <vector>
|
|
|
|
namespace ThemeEngine {
|
|
|
|
// --- Container ---
|
|
class Container : public UIElement {
|
|
protected:
|
|
std::vector<UIElement *> children;
|
|
Expression bgColorExpr;
|
|
bool hasBg = false;
|
|
bool border = false;
|
|
Expression borderExpr; // Dynamic border based on expression
|
|
int padding = 0; // Inner padding for children
|
|
int borderRadius = 0; // Corner radius (for future rounded rect support)
|
|
|
|
public:
|
|
Container(const std::string &id) : UIElement(id) {
|
|
bgColorExpr = Expression::parse("0xFF");
|
|
}
|
|
virtual ~Container() {
|
|
for (auto child : children)
|
|
delete child;
|
|
}
|
|
|
|
Container *asContainer() override { return this; }
|
|
|
|
ElementType getType() const override { return ElementType::Container; }
|
|
|
|
void addChild(UIElement *child) { children.push_back(child); }
|
|
|
|
const std::vector<UIElement *> &getChildren() const { return children; }
|
|
|
|
void setBackgroundColorExpr(const std::string &expr) {
|
|
bgColorExpr = Expression::parse(expr);
|
|
hasBg = true;
|
|
markDirty();
|
|
}
|
|
|
|
void setBorder(bool enable) {
|
|
border = enable;
|
|
markDirty();
|
|
}
|
|
|
|
void setBorderExpr(const std::string &expr) {
|
|
borderExpr = Expression::parse(expr);
|
|
markDirty();
|
|
}
|
|
|
|
bool hasBorderExpr() const { return !borderExpr.empty(); }
|
|
|
|
void setPadding(int p) {
|
|
padding = p;
|
|
markDirty();
|
|
}
|
|
|
|
int getPadding() const { return padding; }
|
|
|
|
void setBorderRadius(int r) {
|
|
borderRadius = r;
|
|
markDirty();
|
|
}
|
|
|
|
int getBorderRadius() const { return borderRadius; }
|
|
|
|
void layout(const ThemeContext &context, int parentX, int parentY,
|
|
int parentW, int parentH) override {
|
|
UIElement::layout(context, parentX, parentY, parentW, parentH);
|
|
// Children are laid out with padding offset
|
|
int childX = absX + padding;
|
|
int childY = absY + padding;
|
|
int childW = absW - 2 * padding;
|
|
int childH = absH - 2 * padding;
|
|
for (auto child : children) {
|
|
child->layout(context, childX, childY, childW, childH);
|
|
}
|
|
}
|
|
|
|
void markDirty() override {
|
|
UIElement::markDirty();
|
|
for (auto child : children) {
|
|
child->markDirty();
|
|
}
|
|
}
|
|
|
|
void draw(const GfxRenderer &renderer, const ThemeContext &context) override {
|
|
if (!isVisible(context))
|
|
return;
|
|
|
|
if (hasBg) {
|
|
std::string colStr = context.evaluatestring(bgColorExpr);
|
|
uint8_t color = Color::parse(colStr).value;
|
|
// Use dithered fill for grayscale values, solid fill for black/white
|
|
// Use rounded rect if borderRadius > 0
|
|
if (color == 0x00) {
|
|
if (borderRadius > 0) {
|
|
renderer.fillRoundedRect(absX, absY, absW, absH, borderRadius, true);
|
|
} else {
|
|
renderer.fillRect(absX, absY, absW, absH, true);
|
|
}
|
|
} else if (color >= 0xF0) {
|
|
if (borderRadius > 0) {
|
|
renderer.fillRoundedRect(absX, absY, absW, absH, borderRadius, false);
|
|
} else {
|
|
renderer.fillRect(absX, absY, absW, absH, false);
|
|
}
|
|
} else {
|
|
if (borderRadius > 0) {
|
|
renderer.fillRoundedRectDithered(absX, absY, absW, absH, borderRadius, color);
|
|
} else {
|
|
renderer.fillRectDithered(absX, absY, absW, absH, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle dynamic border expression
|
|
bool drawBorder = border;
|
|
if (hasBorderExpr()) {
|
|
drawBorder = context.evaluateBool(borderExpr.rawExpr);
|
|
}
|
|
|
|
if (drawBorder) {
|
|
if (borderRadius > 0) {
|
|
renderer.drawRoundedRect(absX, absY, absW, absH, borderRadius, true);
|
|
} else {
|
|
renderer.drawRect(absX, absY, absW, absH, true);
|
|
}
|
|
}
|
|
|
|
for (auto child : children) {
|
|
child->draw(renderer, context);
|
|
}
|
|
|
|
markClean();
|
|
}
|
|
};
|
|
|
|
// --- Rectangle ---
|
|
class Rectangle : public UIElement {
|
|
bool fill = false;
|
|
Expression fillExpr; // Dynamic fill based on expression
|
|
Expression colorExpr;
|
|
|
|
public:
|
|
Rectangle(const std::string &id) : UIElement(id) {
|
|
colorExpr = Expression::parse("0x00");
|
|
}
|
|
ElementType getType() const override { return ElementType::Rectangle; }
|
|
|
|
void setFill(bool f) {
|
|
fill = f;
|
|
markDirty();
|
|
}
|
|
|
|
void setFillExpr(const std::string &expr) {
|
|
fillExpr = Expression::parse(expr);
|
|
markDirty();
|
|
}
|
|
|
|
void setColorExpr(const std::string &c) {
|
|
colorExpr = Expression::parse(c);
|
|
markDirty();
|
|
}
|
|
|
|
void draw(const GfxRenderer &renderer, const ThemeContext &context) override {
|
|
if (!isVisible(context))
|
|
return;
|
|
|
|
std::string colStr = context.evaluatestring(colorExpr);
|
|
uint8_t color = Color::parse(colStr).value;
|
|
bool black = (color == 0x00);
|
|
|
|
bool shouldFill = fill;
|
|
if (!fillExpr.empty()) {
|
|
shouldFill = context.evaluateBool(fillExpr.rawExpr);
|
|
}
|
|
|
|
if (shouldFill) {
|
|
renderer.fillRect(absX, absY, absW, absH, black);
|
|
} else {
|
|
renderer.drawRect(absX, absY, absW, absH, black);
|
|
}
|
|
|
|
markClean();
|
|
}
|
|
};
|
|
|
|
// --- Label ---
|
|
class Label : public UIElement {
|
|
public:
|
|
enum class Alignment { Left, Center, Right };
|
|
|
|
private:
|
|
Expression textExpr;
|
|
int fontId = 0;
|
|
Alignment alignment = Alignment::Left;
|
|
Expression colorExpr;
|
|
int maxLines = 1; // For multi-line support
|
|
bool ellipsis = true; // Truncate with ... if too long
|
|
|
|
public:
|
|
Label(const std::string &id) : UIElement(id) {
|
|
colorExpr = Expression::parse("0x00");
|
|
}
|
|
ElementType getType() const override { return ElementType::Label; }
|
|
|
|
void setText(const std::string &expr) {
|
|
textExpr = Expression::parse(expr);
|
|
markDirty();
|
|
}
|
|
void setFont(int fid) {
|
|
fontId = fid;
|
|
markDirty();
|
|
}
|
|
void setAlignment(Alignment a) {
|
|
alignment = a;
|
|
markDirty();
|
|
}
|
|
void setCentered(bool c) {
|
|
alignment = c ? Alignment::Center : Alignment::Left;
|
|
markDirty();
|
|
}
|
|
void setColorExpr(const std::string &c) {
|
|
colorExpr = Expression::parse(c);
|
|
markDirty();
|
|
}
|
|
void setMaxLines(int lines) {
|
|
maxLines = lines;
|
|
markDirty();
|
|
}
|
|
void setEllipsis(bool e) {
|
|
ellipsis = e;
|
|
markDirty();
|
|
}
|
|
|
|
void draw(const GfxRenderer &renderer, const ThemeContext &context) override {
|
|
if (!isVisible(context))
|
|
return;
|
|
|
|
std::string finalText = context.evaluatestring(textExpr);
|
|
if (finalText.empty()) {
|
|
markClean();
|
|
return;
|
|
}
|
|
|
|
std::string colStr = context.evaluatestring(colorExpr);
|
|
uint8_t color = Color::parse(colStr).value;
|
|
bool black = (color == 0x00);
|
|
|
|
int textWidth = renderer.getTextWidth(fontId, finalText.c_str());
|
|
int lineHeight = renderer.getLineHeight(fontId);
|
|
|
|
// Truncate if needed
|
|
if (ellipsis && textWidth > absW && absW > 0) {
|
|
finalText = renderer.truncatedText(fontId, finalText.c_str(), absW);
|
|
textWidth = renderer.getTextWidth(fontId, finalText.c_str());
|
|
}
|
|
|
|
int drawX = absX;
|
|
int drawY = absY;
|
|
|
|
// Vertical centering
|
|
if (absH > 0 && lineHeight > 0) {
|
|
drawY = absY + (absH - lineHeight) / 2;
|
|
}
|
|
|
|
// Horizontal alignment
|
|
if (alignment == Alignment::Center && absW > 0) {
|
|
drawX = absX + (absW - textWidth) / 2;
|
|
} else if (alignment == Alignment::Right && absW > 0) {
|
|
drawX = absX + absW - textWidth;
|
|
}
|
|
|
|
renderer.drawText(fontId, drawX, drawY, finalText.c_str(), black);
|
|
markClean();
|
|
}
|
|
};
|
|
|
|
// --- BitmapElement ---
|
|
class BitmapElement : public UIElement {
|
|
Expression srcExpr;
|
|
bool scaleToFit = true;
|
|
bool preserveAspect = true;
|
|
|
|
public:
|
|
BitmapElement(const std::string &id) : UIElement(id) {
|
|
cacheable = true; // Bitmaps benefit from caching
|
|
}
|
|
ElementType getType() const override { return ElementType::Bitmap; }
|
|
|
|
void setSrc(const std::string &src) {
|
|
srcExpr = Expression::parse(src);
|
|
invalidateCache();
|
|
}
|
|
|
|
void setScaleToFit(bool scale) {
|
|
scaleToFit = scale;
|
|
invalidateCache();
|
|
}
|
|
|
|
void setPreserveAspect(bool preserve) {
|
|
preserveAspect = preserve;
|
|
invalidateCache();
|
|
}
|
|
|
|
void draw(const GfxRenderer &renderer, const ThemeContext &context) override;
|
|
};
|
|
|
|
// --- ProgressBar ---
|
|
class ProgressBar : public UIElement {
|
|
Expression valueExpr; // Current value (0-100 or 0-max)
|
|
Expression maxExpr; // Max value (default 100)
|
|
Expression fgColorExpr; // Foreground color
|
|
Expression bgColorExpr; // Background color
|
|
bool showBorder = true;
|
|
int borderWidth = 1;
|
|
|
|
public:
|
|
ProgressBar(const std::string &id) : UIElement(id) {
|
|
valueExpr = Expression::parse("0");
|
|
maxExpr = Expression::parse("100");
|
|
fgColorExpr = Expression::parse("0x00"); // Black fill
|
|
bgColorExpr = Expression::parse("0xFF"); // White background
|
|
}
|
|
|
|
ElementType getType() const override { return ElementType::ProgressBar; }
|
|
|
|
void setValue(const std::string &expr) {
|
|
valueExpr = Expression::parse(expr);
|
|
markDirty();
|
|
}
|
|
void setMax(const std::string &expr) {
|
|
maxExpr = Expression::parse(expr);
|
|
markDirty();
|
|
}
|
|
void setFgColor(const std::string &expr) {
|
|
fgColorExpr = Expression::parse(expr);
|
|
markDirty();
|
|
}
|
|
void setBgColor(const std::string &expr) {
|
|
bgColorExpr = Expression::parse(expr);
|
|
markDirty();
|
|
}
|
|
void setShowBorder(bool show) {
|
|
showBorder = show;
|
|
markDirty();
|
|
}
|
|
|
|
void draw(const GfxRenderer &renderer, const ThemeContext &context) override {
|
|
if (!isVisible(context))
|
|
return;
|
|
|
|
std::string valStr = context.evaluatestring(valueExpr);
|
|
std::string maxStr = context.evaluatestring(maxExpr);
|
|
|
|
int value = valStr.empty() ? 0 : std::stoi(valStr);
|
|
int maxVal = maxStr.empty() ? 100 : std::stoi(maxStr);
|
|
if (maxVal <= 0)
|
|
maxVal = 100;
|
|
|
|
float ratio = static_cast<float>(value) / static_cast<float>(maxVal);
|
|
if (ratio < 0)
|
|
ratio = 0;
|
|
if (ratio > 1)
|
|
ratio = 1;
|
|
|
|
// Draw background
|
|
std::string bgStr = context.evaluatestring(bgColorExpr);
|
|
uint8_t bgColor = Color::parse(bgStr).value;
|
|
renderer.fillRect(absX, absY, absW, absH, bgColor == 0x00);
|
|
|
|
// Draw filled portion
|
|
int fillWidth = static_cast<int>(absW * ratio);
|
|
if (fillWidth > 0) {
|
|
std::string fgStr = context.evaluatestring(fgColorExpr);
|
|
uint8_t fgColor = Color::parse(fgStr).value;
|
|
renderer.fillRect(absX, absY, fillWidth, absH, fgColor == 0x00);
|
|
}
|
|
|
|
// Draw border
|
|
if (showBorder) {
|
|
renderer.drawRect(absX, absY, absW, absH, true);
|
|
}
|
|
|
|
markClean();
|
|
}
|
|
};
|
|
|
|
// --- Divider (horizontal or vertical line) ---
|
|
class Divider : public UIElement {
|
|
Expression colorExpr;
|
|
bool horizontal = true;
|
|
int thickness = 1;
|
|
|
|
public:
|
|
Divider(const std::string &id) : UIElement(id) {
|
|
colorExpr = Expression::parse("0x00");
|
|
}
|
|
|
|
ElementType getType() const override { return ElementType::Divider; }
|
|
|
|
void setColorExpr(const std::string &expr) {
|
|
colorExpr = Expression::parse(expr);
|
|
markDirty();
|
|
}
|
|
void setHorizontal(bool h) {
|
|
horizontal = h;
|
|
markDirty();
|
|
}
|
|
void setThickness(int t) {
|
|
thickness = t;
|
|
markDirty();
|
|
}
|
|
|
|
void draw(const GfxRenderer &renderer, const ThemeContext &context) override {
|
|
if (!isVisible(context))
|
|
return;
|
|
|
|
std::string colStr = context.evaluatestring(colorExpr);
|
|
uint8_t color = Color::parse(colStr).value;
|
|
bool black = (color == 0x00);
|
|
|
|
if (horizontal) {
|
|
for (int i = 0; i < thickness && i < absH; i++) {
|
|
renderer.drawLine(absX, absY + i, absX + absW - 1, absY + i, black);
|
|
}
|
|
} else {
|
|
for (int i = 0; i < thickness && i < absW; i++) {
|
|
renderer.drawLine(absX + i, absY, absX + i, absY + absH - 1, black);
|
|
}
|
|
}
|
|
|
|
markClean();
|
|
}
|
|
};
|
|
|
|
// --- BatteryIcon ---
|
|
class BatteryIcon : public UIElement {
|
|
Expression valueExpr;
|
|
Expression colorExpr;
|
|
|
|
public:
|
|
BatteryIcon(const std::string &id) : UIElement(id) {
|
|
valueExpr = Expression::parse("0");
|
|
colorExpr = Expression::parse("0x00"); // Black by default
|
|
}
|
|
|
|
ElementType getType() const override { return ElementType::BatteryIcon; }
|
|
|
|
void setValue(const std::string &expr) {
|
|
valueExpr = Expression::parse(expr);
|
|
markDirty();
|
|
}
|
|
|
|
void setColor(const std::string &expr) {
|
|
colorExpr = Expression::parse(expr);
|
|
markDirty();
|
|
}
|
|
|
|
void draw(const GfxRenderer &renderer, const ThemeContext &context) override {
|
|
if (!isVisible(context))
|
|
return;
|
|
|
|
std::string valStr = context.evaluatestring(valueExpr);
|
|
int percentage = valStr.empty() ? 0 : std::stoi(valStr);
|
|
|
|
std::string colStr = context.evaluatestring(colorExpr);
|
|
uint8_t color = Color::parse(colStr).value;
|
|
bool black = (color == 0x00);
|
|
|
|
constexpr int batteryWidth = 15;
|
|
constexpr int batteryHeight = 12;
|
|
|
|
int x = absX;
|
|
int y = absY;
|
|
|
|
if (absW > batteryWidth)
|
|
x += (absW - batteryWidth) / 2;
|
|
if (absH > batteryHeight)
|
|
y += (absH - batteryHeight) / 2;
|
|
|
|
renderer.drawLine(x + 1, y, x + batteryWidth - 3, y, black);
|
|
renderer.drawLine(x + 1, y + batteryHeight - 1, x + batteryWidth - 3,
|
|
y + batteryHeight - 1, black);
|
|
renderer.drawLine(x, y + 1, x, y + batteryHeight - 2, black);
|
|
renderer.drawLine(x + batteryWidth - 2, y + 1, x + batteryWidth - 2,
|
|
y + batteryHeight - 2, black);
|
|
|
|
renderer.drawPixel(x + batteryWidth - 1, y + 3, black);
|
|
renderer.drawPixel(x + batteryWidth - 1, y + batteryHeight - 4, black);
|
|
renderer.drawLine(x + batteryWidth - 0, y + 4, x + batteryWidth - 0,
|
|
y + batteryHeight - 5, black);
|
|
|
|
if (percentage > 0) {
|
|
int filledWidth = percentage * (batteryWidth - 5) / 100 + 1;
|
|
if (filledWidth > batteryWidth - 5) {
|
|
filledWidth = batteryWidth - 5;
|
|
}
|
|
renderer.fillRect(x + 2, y + 2, filledWidth, batteryHeight - 4, black);
|
|
}
|
|
|
|
markClean();
|
|
}
|
|
};
|
|
|
|
} // namespace ThemeEngine
|