452 lines
16 KiB
C++
452 lines
16 KiB
C++
#include "PowerNodeWidget.hpp"
|
|
#include "../Fonts.hpp"
|
|
#include <cstring>
|
|
#include <cstdio>
|
|
|
|
PowerNodeWidget::PowerNodeWidget(const WidgetConfig& config)
|
|
: Widget(config)
|
|
{
|
|
labelText_[0] = '\0';
|
|
valueFormat_[0] = '\0';
|
|
leftFormat_[0] = '\0';
|
|
rightFormat_[0] = '\0';
|
|
}
|
|
|
|
static bool set_label_text_if_changed(lv_obj_t* label, const char* text) {
|
|
if (!label || !text) return false;
|
|
const char* current = lv_label_get_text(label);
|
|
if (current && strcmp(current, text) == 0) return false;
|
|
lv_label_set_text(label, text);
|
|
return true;
|
|
}
|
|
|
|
static void set_obj_name(lv_obj_t* obj, const char* base, uint8_t id, const char* suffix) {
|
|
#if LV_USE_OBJ_NAME
|
|
if (!obj || !base) return;
|
|
char name[48];
|
|
if (suffix && suffix[0] != '\0') {
|
|
snprintf(name, sizeof(name), "%s#%u_%s", base, id, suffix);
|
|
} else {
|
|
snprintf(name, sizeof(name), "%s#%u", base, id);
|
|
}
|
|
lv_obj_set_name(obj, name);
|
|
#else
|
|
(void)obj;
|
|
(void)base;
|
|
(void)id;
|
|
(void)suffix;
|
|
#endif
|
|
}
|
|
|
|
int PowerNodeWidget::encodeUtf8(uint32_t codepoint, char* buf) {
|
|
if (codepoint < 0x80) {
|
|
buf[0] = static_cast<char>(codepoint);
|
|
buf[1] = '\0';
|
|
return 1;
|
|
} else if (codepoint < 0x800) {
|
|
buf[0] = static_cast<char>(0xC0 | (codepoint >> 6));
|
|
buf[1] = static_cast<char>(0x80 | (codepoint & 0x3F));
|
|
buf[2] = '\0';
|
|
return 2;
|
|
} else if (codepoint < 0x10000) {
|
|
buf[0] = static_cast<char>(0xE0 | (codepoint >> 12));
|
|
buf[1] = static_cast<char>(0x80 | ((codepoint >> 6) & 0x3F));
|
|
buf[2] = static_cast<char>(0x80 | (codepoint & 0x3F));
|
|
buf[3] = '\0';
|
|
return 3;
|
|
} else if (codepoint < 0x110000) {
|
|
buf[0] = static_cast<char>(0xF0 | (codepoint >> 18));
|
|
buf[1] = static_cast<char>(0x80 | ((codepoint >> 12) & 0x3F));
|
|
buf[2] = static_cast<char>(0x80 | ((codepoint >> 6) & 0x3F));
|
|
buf[3] = static_cast<char>(0x80 | (codepoint & 0x3F));
|
|
buf[4] = '\0';
|
|
return 4;
|
|
}
|
|
buf[0] = '\0';
|
|
return 0;
|
|
}
|
|
|
|
void PowerNodeWidget::parseText() {
|
|
labelText_[0] = '\0';
|
|
valueFormat_[0] = '\0';
|
|
leftFormat_[0] = '\0';
|
|
rightFormat_[0] = '\0';
|
|
|
|
// Parse primary text (label\nformat)
|
|
const char* text = config_.text;
|
|
if (text && text[0] != '\0') {
|
|
const char* newline = strchr(text, '\n');
|
|
if (newline) {
|
|
size_t labelLen = static_cast<size_t>(newline - text);
|
|
if (labelLen >= MAX_TEXT_LEN) labelLen = MAX_TEXT_LEN - 1;
|
|
memcpy(labelText_, text, labelLen);
|
|
labelText_[labelLen] = '\0';
|
|
strncpy(valueFormat_, newline + 1, MAX_TEXT_LEN - 1);
|
|
valueFormat_[MAX_TEXT_LEN - 1] = '\0';
|
|
} else {
|
|
strncpy(labelText_, text, MAX_TEXT_LEN - 1);
|
|
labelText_[MAX_TEXT_LEN - 1] = '\0';
|
|
}
|
|
}
|
|
|
|
// Copy left format from text2
|
|
if (config_.text2[0] != '\0') {
|
|
strncpy(leftFormat_, config_.text2, MAX_FORMAT_LEN - 1);
|
|
leftFormat_[MAX_FORMAT_LEN - 1] = '\0';
|
|
}
|
|
|
|
// Copy right format from text3
|
|
if (config_.text3[0] != '\0') {
|
|
strncpy(rightFormat_, config_.text3, MAX_FORMAT_LEN - 1);
|
|
rightFormat_[MAX_FORMAT_LEN - 1] = '\0';
|
|
}
|
|
}
|
|
|
|
lv_obj_t* PowerNodeWidget::create(lv_obj_t* parent) {
|
|
parseText();
|
|
|
|
obj_ = lv_obj_create(parent);
|
|
if (obj_ == nullptr) {
|
|
return nullptr;
|
|
}
|
|
set_obj_name(obj_, "PowerNode", config_.id, nullptr);
|
|
|
|
lv_obj_remove_style_all(obj_);
|
|
lv_obj_set_pos(obj_, config_.x, config_.y);
|
|
lv_obj_set_size(obj_,
|
|
config_.width > 0 ? config_.width : 120,
|
|
config_.height > 0 ? config_.height : 120);
|
|
lv_obj_clear_flag(obj_, LV_OBJ_FLAG_SCROLLABLE);
|
|
lv_obj_set_flex_flow(obj_, LV_FLEX_FLOW_COLUMN);
|
|
lv_obj_set_flex_align(obj_, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
lv_obj_set_style_pad_all(obj_, 6, 0);
|
|
lv_obj_set_style_pad_gap(obj_, 2, 0);
|
|
|
|
// Top label (title)
|
|
if (labelText_[0] != '\0') {
|
|
labelLabel_ = lv_label_create(obj_);
|
|
set_obj_name(labelLabel_, "PowerNode", config_.id, "label");
|
|
lv_label_set_text(labelLabel_, labelText_);
|
|
lv_obj_clear_flag(labelLabel_, LV_OBJ_FLAG_CLICKABLE);
|
|
}
|
|
|
|
// Check if we have left/right values (dual-value mode)
|
|
bool hasDualValues = (config_.knxAddress2 > 0 || config_.knxAddress3 > 0);
|
|
|
|
if (hasDualValues) {
|
|
// Create middle row container for: left | icon | right
|
|
middleRow_ = lv_obj_create(obj_);
|
|
lv_obj_remove_style_all(middleRow_);
|
|
set_obj_name(middleRow_, "PowerNode", config_.id, "middleRow");
|
|
lv_obj_set_size(middleRow_, LV_SIZE_CONTENT, LV_SIZE_CONTENT);
|
|
lv_obj_clear_flag(middleRow_, LV_OBJ_FLAG_SCROLLABLE);
|
|
lv_obj_set_flex_flow(middleRow_, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_flex_align(middleRow_, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
lv_obj_set_style_pad_gap(middleRow_, 8, 0);
|
|
|
|
// Left value label (secondary)
|
|
if (config_.knxAddress2 > 0) {
|
|
leftLabel_ = lv_label_create(middleRow_);
|
|
set_obj_name(leftLabel_, "PowerNode", config_.id, "left");
|
|
lv_label_set_text(leftLabel_, leftFormat_[0] != '\0' ? leftFormat_ : "");
|
|
lv_obj_clear_flag(leftLabel_, LV_OBJ_FLAG_CLICKABLE);
|
|
}
|
|
|
|
// Center icon
|
|
if (config_.iconCodepoint > 0 && Fonts::hasIconFont()) {
|
|
iconLabel_ = lv_label_create(middleRow_);
|
|
set_obj_name(iconLabel_, "PowerNode", config_.id, "icon");
|
|
char iconText[5];
|
|
encodeUtf8(config_.iconCodepoint, iconText);
|
|
lv_label_set_text(iconLabel_, iconText);
|
|
lv_obj_clear_flag(iconLabel_, LV_OBJ_FLAG_CLICKABLE);
|
|
}
|
|
|
|
// Right value label (tertiary)
|
|
if (config_.knxAddress3 > 0) {
|
|
rightLabel_ = lv_label_create(middleRow_);
|
|
set_obj_name(rightLabel_, "PowerNode", config_.id, "right");
|
|
lv_label_set_text(rightLabel_, rightFormat_[0] != '\0' ? rightFormat_ : "");
|
|
lv_obj_clear_flag(rightLabel_, LV_OBJ_FLAG_CLICKABLE);
|
|
}
|
|
} else {
|
|
// Original layout: icon in column flow
|
|
if (config_.iconCodepoint > 0 && Fonts::hasIconFont()) {
|
|
iconLabel_ = lv_label_create(obj_);
|
|
set_obj_name(iconLabel_, "PowerNode", config_.id, "icon");
|
|
char iconText[5];
|
|
encodeUtf8(config_.iconCodepoint, iconText);
|
|
lv_label_set_text(iconLabel_, iconText);
|
|
lv_obj_clear_flag(iconLabel_, LV_OBJ_FLAG_CLICKABLE);
|
|
}
|
|
}
|
|
|
|
// Bottom value label (primary)
|
|
valueLabel_ = lv_label_create(obj_);
|
|
set_obj_name(valueLabel_, "PowerNode", config_.id, "value");
|
|
if (valueFormat_[0] != '\0') {
|
|
lv_label_set_text(valueLabel_, valueFormat_);
|
|
} else {
|
|
lv_label_set_text(valueLabel_, "");
|
|
}
|
|
lv_obj_clear_flag(valueLabel_, LV_OBJ_FLAG_CLICKABLE);
|
|
|
|
return obj_;
|
|
}
|
|
|
|
void PowerNodeWidget::applyStyle() {
|
|
if (obj_ == nullptr) return;
|
|
|
|
lv_obj_set_style_bg_color(obj_, lv_color_white(), 0);
|
|
lv_obj_set_style_bg_opa(obj_, LV_OPA_COVER, 0);
|
|
lv_obj_set_style_radius(obj_, LV_RADIUS_CIRCLE, 0);
|
|
|
|
int16_t minSide = config_.width < config_.height ? config_.width : config_.height;
|
|
int16_t ring = minSide / 12;
|
|
if (ring < 2) ring = 2;
|
|
if (ring > 12) ring = 12;
|
|
|
|
lv_obj_set_style_border_width(obj_, ring, 0);
|
|
lv_obj_set_style_border_color(obj_, lv_color_make(
|
|
config_.bgColor.r, config_.bgColor.g, config_.bgColor.b), 0);
|
|
lv_obj_set_style_border_opa(obj_, config_.bgOpacity, 0);
|
|
|
|
applyShadowStyle();
|
|
|
|
uint8_t valueSizeIdx = config_.fontSize;
|
|
uint8_t labelSizeIdx = valueSizeIdx > 0 ? static_cast<uint8_t>(valueSizeIdx - 1) : valueSizeIdx;
|
|
uint8_t sideValueSizeIdx = labelSizeIdx; // Left/right values use smaller font
|
|
|
|
if (labelLabel_ != nullptr) {
|
|
lv_obj_set_style_text_color(labelLabel_, lv_color_make(
|
|
config_.textColor.r, config_.textColor.g, config_.textColor.b), 0);
|
|
lv_obj_set_style_text_font(labelLabel_, Fonts::bySizeIndex(labelSizeIdx), 0);
|
|
lv_obj_set_style_text_align(labelLabel_, LV_TEXT_ALIGN_CENTER, 0);
|
|
lv_obj_set_style_text_opa(labelLabel_, LV_OPA_70, 0);
|
|
}
|
|
|
|
if (iconLabel_ != nullptr) {
|
|
lv_obj_set_style_text_color(iconLabel_, lv_color_make(
|
|
config_.textColor.r, config_.textColor.g, config_.textColor.b), 0);
|
|
uint8_t sizeIdx = config_.iconSize < 6 ? config_.iconSize : valueSizeIdx;
|
|
lv_obj_set_style_text_font(iconLabel_, Fonts::iconFont(sizeIdx), 0);
|
|
lv_obj_set_style_text_align(iconLabel_, LV_TEXT_ALIGN_CENTER, 0);
|
|
}
|
|
|
|
if (leftLabel_ != nullptr) {
|
|
lv_obj_set_style_text_color(leftLabel_, lv_color_make(
|
|
config_.textColor.r, config_.textColor.g, config_.textColor.b), 0);
|
|
lv_obj_set_style_text_font(leftLabel_, Fonts::bySizeIndex(sideValueSizeIdx), 0);
|
|
lv_obj_set_style_text_align(leftLabel_, LV_TEXT_ALIGN_RIGHT, 0);
|
|
}
|
|
|
|
if (rightLabel_ != nullptr) {
|
|
lv_obj_set_style_text_color(rightLabel_, lv_color_make(
|
|
config_.textColor.r, config_.textColor.g, config_.textColor.b), 0);
|
|
lv_obj_set_style_text_font(rightLabel_, Fonts::bySizeIndex(sideValueSizeIdx), 0);
|
|
lv_obj_set_style_text_align(rightLabel_, LV_TEXT_ALIGN_LEFT, 0);
|
|
}
|
|
|
|
if (valueLabel_ != nullptr) {
|
|
lv_obj_set_style_text_color(valueLabel_, lv_color_make(
|
|
config_.textColor.r, config_.textColor.g, config_.textColor.b), 0);
|
|
lv_obj_set_style_text_font(valueLabel_, Fonts::bySizeIndex(valueSizeIdx), 0);
|
|
lv_obj_set_style_text_align(valueLabel_, LV_TEXT_ALIGN_CENTER, 0);
|
|
}
|
|
}
|
|
|
|
void PowerNodeWidget::updateValueText(const char* text) {
|
|
if (valueLabel_ == nullptr || text == nullptr) return;
|
|
set_label_text_if_changed(valueLabel_, text);
|
|
}
|
|
|
|
void PowerNodeWidget::updateLeftText(const char* text) {
|
|
if (leftLabel_ == nullptr || text == nullptr) return;
|
|
set_label_text_if_changed(leftLabel_, text);
|
|
}
|
|
|
|
void PowerNodeWidget::updateRightText(const char* text) {
|
|
if (rightLabel_ == nullptr || text == nullptr) return;
|
|
set_label_text_if_changed(rightLabel_, text);
|
|
}
|
|
|
|
void PowerNodeWidget::updateIcon(uint32_t codepoint) {
|
|
if (iconLabel_ == nullptr || codepoint == 0) return;
|
|
char iconText[5];
|
|
encodeUtf8(codepoint, iconText);
|
|
set_label_text_if_changed(iconLabel_, iconText);
|
|
}
|
|
|
|
static bool isNumericSource(TextSource source) {
|
|
return source == TextSource::KNX_DPT_TEMP ||
|
|
source == TextSource::KNX_DPT_PERCENT ||
|
|
source == TextSource::KNX_DPT_POWER ||
|
|
source == TextSource::KNX_DPT_ENERGY ||
|
|
source == TextSource::KNX_DPT_DECIMALFACTOR;
|
|
}
|
|
|
|
static void formatValue(char* buf, size_t bufSize, float value, const char* fmt, TextSource source) {
|
|
const char* useFmt = (fmt && fmt[0] != '\0') ? fmt : "%0.1f";
|
|
if (source == TextSource::KNX_DPT_PERCENT ||
|
|
source == TextSource::KNX_DPT_DECIMALFACTOR) {
|
|
int intVal = static_cast<int>(value + 0.5f);
|
|
snprintf(buf, bufSize, useFmt, intVal);
|
|
} else {
|
|
snprintf(buf, bufSize, useFmt, value);
|
|
}
|
|
}
|
|
|
|
void PowerNodeWidget::onKnxValue(float value) {
|
|
// Cache and call base for condition evaluation
|
|
cachedPrimaryValue_ = value;
|
|
hasCachedPrimary_ = true;
|
|
|
|
if (valueLabel_ == nullptr) return;
|
|
if (!isNumericSource(config_.textSource)) return;
|
|
|
|
char buf[32];
|
|
formatValue(buf, sizeof(buf), value, valueFormat_, config_.textSource);
|
|
updateValueText(buf);
|
|
|
|
// Evaluate conditions after updating value
|
|
evaluateConditions(cachedPrimaryValue_, cachedSecondaryValue_, cachedTertiaryValue_);
|
|
}
|
|
|
|
void PowerNodeWidget::onKnxValue2(float value) {
|
|
cachedSecondaryValue_ = value;
|
|
hasCachedSecondary_ = true;
|
|
|
|
if (leftLabel_ == nullptr) return;
|
|
if (!isNumericSource(config_.textSource2)) return;
|
|
|
|
char buf[32];
|
|
formatValue(buf, sizeof(buf), value, leftFormat_, config_.textSource2);
|
|
updateLeftText(buf);
|
|
|
|
// Evaluate conditions after updating value
|
|
evaluateConditions(cachedPrimaryValue_, cachedSecondaryValue_, cachedTertiaryValue_);
|
|
}
|
|
|
|
void PowerNodeWidget::onKnxValue3(float value) {
|
|
cachedTertiaryValue_ = value;
|
|
hasCachedTertiary_ = true;
|
|
|
|
if (rightLabel_ == nullptr) return;
|
|
if (!isNumericSource(config_.textSource3)) return;
|
|
|
|
char buf[32];
|
|
formatValue(buf, sizeof(buf), value, rightFormat_, config_.textSource3);
|
|
updateRightText(buf);
|
|
|
|
// Evaluate conditions after updating value
|
|
evaluateConditions(cachedPrimaryValue_, cachedSecondaryValue_, cachedTertiaryValue_);
|
|
}
|
|
|
|
void PowerNodeWidget::onKnxSwitch(bool value) {
|
|
if (valueLabel_ == nullptr) return;
|
|
if (config_.textSource != TextSource::KNX_DPT_SWITCH) return;
|
|
updateValueText(value ? "EIN" : "AUS");
|
|
}
|
|
|
|
void PowerNodeWidget::onKnxText(const char* text) {
|
|
if (valueLabel_ == nullptr) return;
|
|
if (config_.textSource != TextSource::KNX_DPT_TEXT) return;
|
|
updateValueText(text);
|
|
}
|
|
|
|
bool PowerNodeWidget::evaluateConditions(float primaryValue, float secondaryValue, float tertiaryValue) {
|
|
if (config_.conditionCount == 0) return false;
|
|
|
|
const StyleCondition* bestMatch = nullptr;
|
|
uint8_t bestPriority = 255;
|
|
|
|
for (uint8_t i = 0; i < config_.conditionCount && i < MAX_CONDITIONS; ++i) {
|
|
const StyleCondition& cond = config_.conditions[i];
|
|
if (!cond.enabled) continue;
|
|
|
|
// Get the value to check based on source
|
|
float checkValue = 0.0f;
|
|
bool hasValue = false;
|
|
switch (cond.source) {
|
|
case ConditionSource::PRIMARY:
|
|
checkValue = primaryValue;
|
|
hasValue = hasCachedPrimary_;
|
|
break;
|
|
case ConditionSource::SECONDARY:
|
|
checkValue = secondaryValue;
|
|
hasValue = hasCachedSecondary_;
|
|
break;
|
|
case ConditionSource::TERTIARY:
|
|
checkValue = tertiaryValue;
|
|
hasValue = hasCachedTertiary_;
|
|
break;
|
|
}
|
|
|
|
if (!hasValue) continue;
|
|
|
|
// Evaluate condition
|
|
bool matches = false;
|
|
switch (cond.op) {
|
|
case ConditionOp::LESS:
|
|
matches = checkValue < cond.threshold;
|
|
break;
|
|
case ConditionOp::LESS_EQUAL:
|
|
matches = checkValue <= cond.threshold;
|
|
break;
|
|
case ConditionOp::EQUAL:
|
|
matches = checkValue == cond.threshold;
|
|
break;
|
|
case ConditionOp::GREATER_EQUAL:
|
|
matches = checkValue >= cond.threshold;
|
|
break;
|
|
case ConditionOp::GREATER:
|
|
matches = checkValue > cond.threshold;
|
|
break;
|
|
case ConditionOp::NOT_EQUAL:
|
|
matches = checkValue != cond.threshold;
|
|
break;
|
|
}
|
|
|
|
if (matches && cond.priority < bestPriority) {
|
|
bestMatch = &cond;
|
|
bestPriority = cond.priority;
|
|
}
|
|
}
|
|
|
|
if (bestMatch) {
|
|
// Apply icon change
|
|
if (bestMatch->style.iconCodepoint != 0 &&
|
|
bestMatch->style.iconCodepoint != currentConditionIcon_) {
|
|
updateIcon(bestMatch->style.iconCodepoint);
|
|
currentConditionIcon_ = bestMatch->style.iconCodepoint;
|
|
}
|
|
|
|
// Apply text color to icon
|
|
if ((bestMatch->style.flags & ConditionStyle::FLAG_USE_TEXT_COLOR) && iconLabel_) {
|
|
lv_obj_set_style_text_color(iconLabel_, lv_color_make(
|
|
bestMatch->style.textColor.r,
|
|
bestMatch->style.textColor.g,
|
|
bestMatch->style.textColor.b), 0);
|
|
}
|
|
|
|
// Apply border color change (bgColor affects border in PowerNode)
|
|
if (bestMatch->style.flags & ConditionStyle::FLAG_USE_BG_COLOR) {
|
|
lv_obj_set_style_border_color(obj_, lv_color_make(
|
|
bestMatch->style.bgColor.r,
|
|
bestMatch->style.bgColor.g,
|
|
bestMatch->style.bgColor.b), 0);
|
|
}
|
|
|
|
// Handle hide flag
|
|
if (bestMatch->style.flags & ConditionStyle::FLAG_HIDE) {
|
|
lv_obj_add_flag(obj_, LV_OBJ_FLAG_HIDDEN);
|
|
} else {
|
|
lv_obj_clear_flag(obj_, LV_OBJ_FLAG_HIDDEN);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|