mirror of
https://github.com/mudita/MuditaOS.git
synced 2026-04-19 06:30:46 -04:00
119 lines
3.5 KiB
C++
119 lines
3.5 KiB
C++
// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved.
|
|
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
|
|
|
|
#include "IntervalBox.hpp"
|
|
#include "Style.hpp"
|
|
#include "TimerProperty.hpp"
|
|
|
|
#include <gui/input/InputEvent.hpp>
|
|
#include <i18n/i18n.hpp>
|
|
#include <Constants.hpp>
|
|
#include <cassert>
|
|
|
|
using namespace gui;
|
|
|
|
IntervalBox::IntervalBox(Item *parent, uint32_t x, uint32_t y, uint32_t w, uint32_t h, TimerProperty *timerSetter)
|
|
: HBox(parent, x, y, w, h), timerSetter(timerSetter)
|
|
{
|
|
assert(timerSetter);
|
|
build();
|
|
}
|
|
|
|
void IntervalBox::build()
|
|
{
|
|
chimeSpinner = new gui::TextSpinnerBoxWithLabel(
|
|
this, utils::translate("app_meditation_interval_chime"), {}, Boundaries::Continuous);
|
|
chimeSpinner->setMinimumSize(widgetArea.w, widgetArea.h);
|
|
updateIntervals();
|
|
|
|
resizeItems();
|
|
|
|
focusChangedCallback = [&](gui::Item &item) {
|
|
if (focus) {
|
|
updateIntervals();
|
|
}
|
|
setFocusItem(focus ? chimeSpinner : nullptr);
|
|
return true;
|
|
};
|
|
}
|
|
|
|
void IntervalBox::updateIntervals()
|
|
{
|
|
auto setTime = timerSetter->getTime();
|
|
|
|
std::vector<UTF8> chimeOptions;
|
|
for (auto chime : Constants::Params::chimeIntervals) {
|
|
if (chime < setTime) {
|
|
chimeOptions.push_back(intervalToString(chime));
|
|
}
|
|
}
|
|
|
|
auto currentInterval = chimeSpinner->getCurrentValue();
|
|
chimeSpinner->setData(chimeOptions);
|
|
|
|
if (stringToInterval(currentInterval) < setTime) {
|
|
chimeSpinner->setCurrentValue(currentInterval);
|
|
}
|
|
}
|
|
|
|
std::chrono::seconds IntervalBox::getIntervalValue() noexcept
|
|
{
|
|
if (stringToInterval(chimeSpinner->getCurrentValue()) < timerSetter->getTime()) {
|
|
return std::chrono::seconds{stringToInterval(chimeSpinner->getCurrentValue())};
|
|
}
|
|
else {
|
|
return std::chrono::seconds{0};
|
|
}
|
|
}
|
|
|
|
bool IntervalBox::setIntervalValue(std::chrono::minutes newValue)
|
|
{
|
|
bool result = true;
|
|
const auto it =
|
|
std::find(std::begin(Constants::Params::chimeIntervals), std::end(Constants::Params::chimeIntervals), newValue);
|
|
if (it == std::end(Constants::Params::chimeIntervals)) {
|
|
newValue = Constants::Params::defaultChimeInterval;
|
|
result = false;
|
|
}
|
|
|
|
if (const auto setTime = timerSetter->getTime(); newValue < setTime) {
|
|
chimeSpinner->setCurrentValue(intervalToString(newValue));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void IntervalBox::setOnChangeCallback(OnChangeCallback &callback)
|
|
{
|
|
if (chimeSpinner != nullptr) {
|
|
chimeSpinner->setOnValueChangeCallback([&](const UTF8 &newValue) {
|
|
if (callback != nullptr) {
|
|
callback(stringToInterval(newValue));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
std::string IntervalBox::intervalToString(std::chrono::minutes time)
|
|
{
|
|
if (time.count() == 0) {
|
|
return utils::translate("app_meditation_interval_none");
|
|
}
|
|
const std::string toReplace = "%0";
|
|
std::string description = utils::translate("app_meditation_interval_every_x_minutes");
|
|
description.replace(description.find(toReplace), toReplace.size(), std::to_string(static_cast<int>(time.count())));
|
|
return description;
|
|
}
|
|
|
|
std::chrono::minutes IntervalBox::stringToInterval(const std::string &description)
|
|
{
|
|
if (description == utils::translate("app_meditation_interval_none")) {
|
|
return std::chrono::minutes(0);
|
|
}
|
|
|
|
auto number = description;
|
|
number.erase(std::remove_if(number.begin(), number.end(), [](char c) { return !isdigit(c, std::locale()); }),
|
|
number.end());
|
|
|
|
return std::chrono::minutes(std::atoi(number.c_str()));
|
|
}
|