486 lines
18 KiB
C++
486 lines
18 KiB
C++
#include "modules/clock.hpp"
|
|
|
|
#include <fmt/chrono.h>
|
|
#include <spdlog/spdlog.h>
|
|
|
|
#include <ctime>
|
|
#include <iomanip>
|
|
#include <regex>
|
|
#include <sstream>
|
|
#include <type_traits>
|
|
|
|
#include "util/ustring_clen.hpp"
|
|
#ifdef HAVE_LANGINFO_1STDAY
|
|
#include <langinfo.h>
|
|
#include <locale.h>
|
|
#endif
|
|
|
|
waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
|
|
: ALabel(config, "clock", id, "{:%H:%M}", 60, false, false, true),
|
|
current_time_zone_idx_{0},
|
|
is_calendar_in_tooltip_{false},
|
|
is_timezoned_list_in_tooltip_{false} {
|
|
if (config_["timezones"].isArray() && !config_["timezones"].empty()) {
|
|
for (const auto& zone_name : config_["timezones"]) {
|
|
if (!zone_name.isString()) continue;
|
|
if (zone_name.asString().empty())
|
|
// local time should be shown
|
|
time_zones_.push_back(date::current_zone());
|
|
else
|
|
try {
|
|
time_zones_.push_back(date::locate_zone(zone_name.asString()));
|
|
} catch (const std::exception& e) {
|
|
spdlog::warn("Timezone: {0}. {1}", zone_name.asString(), e.what());
|
|
}
|
|
}
|
|
} else if (config_["timezone"].isString()) {
|
|
if (config_["timezone"].asString().empty())
|
|
time_zones_.push_back(date::current_zone());
|
|
else
|
|
try {
|
|
time_zones_.push_back(date::locate_zone(config_["timezone"].asString()));
|
|
} catch (const std::exception& e) {
|
|
spdlog::warn("Timezone: {0}. {1}", config_["timezone"].asString(), e.what());
|
|
}
|
|
}
|
|
|
|
// If all timezones are parsed and no one is good
|
|
if (!time_zones_.size()) {
|
|
time_zones_.push_back(date::current_zone());
|
|
}
|
|
|
|
// Check if a particular placeholder is present in the tooltip format, to know what to calculate
|
|
// on update.
|
|
if (config_["tooltip-format"].isString()) {
|
|
std::string trimmed_format{config_["tooltip-format"].asString()};
|
|
fmtMap_.insert({5, trimmed_format});
|
|
trimmed_format.erase(std::remove_if(trimmed_format.begin(), trimmed_format.end(),
|
|
[](unsigned char x) { return std::isspace(x); }),
|
|
trimmed_format.end());
|
|
|
|
if (trimmed_format.find("{" + kCalendarPlaceholder + "}") != std::string::npos) {
|
|
is_calendar_in_tooltip_ = true;
|
|
}
|
|
if (trimmed_format.find("{" + KTimezonedTimeListPlaceholder + "}") != std::string::npos) {
|
|
is_timezoned_list_in_tooltip_ = true;
|
|
}
|
|
}
|
|
|
|
// Calendar configuration
|
|
if (is_calendar_in_tooltip_) {
|
|
if (config_[kCalendarPlaceholder]["weeks-pos"].isString()) {
|
|
if (config_[kCalendarPlaceholder]["weeks-pos"].asString() == "left") {
|
|
cldWPos_ = WeeksSide::LEFT;
|
|
} else if (config_[kCalendarPlaceholder]["weeks-pos"].asString() == "right") {
|
|
cldWPos_ = WeeksSide::RIGHT;
|
|
}
|
|
}
|
|
if (config_[kCalendarPlaceholder]["format"]["months"].isString())
|
|
fmtMap_.insert({0, config_[kCalendarPlaceholder]["format"]["months"].asString()});
|
|
else
|
|
fmtMap_.insert({0, "{}"});
|
|
if (config_[kCalendarPlaceholder]["format"]["days"].isString())
|
|
fmtMap_.insert({2, config_[kCalendarPlaceholder]["format"]["days"].asString()});
|
|
else
|
|
fmtMap_.insert({2, "{}"});
|
|
if (config_[kCalendarPlaceholder]["format"]["weeks"].isString() &&
|
|
cldWPos_ != WeeksSide::HIDDEN) {
|
|
fmtMap_.insert(
|
|
{4, std::regex_replace(config_[kCalendarPlaceholder]["format"]["weeks"].asString(),
|
|
std::regex("\\{\\}"),
|
|
(first_day_of_week() == date::Monday) ? "{:%W}" : "{:%U}")});
|
|
Glib::ustring tmp{std::regex_replace(fmtMap_[4], std::regex("</?[^>]+>|\\{.*\\}"), "")};
|
|
cldWnLen_ += tmp.size();
|
|
} else {
|
|
if (cldWPos_ != WeeksSide::HIDDEN)
|
|
fmtMap_.insert({4, (first_day_of_week() == date::Monday) ? "{:%W}" : "{:%U}"});
|
|
else
|
|
cldWnLen_ = 0;
|
|
}
|
|
if (config_[kCalendarPlaceholder]["format"]["weekdays"].isString())
|
|
fmtMap_.insert({1, config_[kCalendarPlaceholder]["format"]["weekdays"].asString()});
|
|
else
|
|
fmtMap_.insert({1, "{}"});
|
|
if (config_[kCalendarPlaceholder]["format"]["today"].isString()) {
|
|
fmtMap_.insert({3, config_[kCalendarPlaceholder]["format"]["today"].asString()});
|
|
cldBaseDay_ =
|
|
date::year_month_day{date::floor<date::days>(std::chrono::system_clock::now())}.day();
|
|
} else
|
|
fmtMap_.insert({3, "{}"});
|
|
if (config_[kCalendarPlaceholder]["mode"].isString()) {
|
|
const std::string cfgMode{(config_[kCalendarPlaceholder]["mode"].isString())
|
|
? config_[kCalendarPlaceholder]["mode"].asString()
|
|
: "month"};
|
|
const std::map<std::string, const CldMode&> monthModes{{"month", CldMode::MONTH},
|
|
{"year", CldMode::YEAR}};
|
|
if (monthModes.find(cfgMode) != monthModes.end())
|
|
cldMode_ = monthModes.at(cfgMode);
|
|
else
|
|
spdlog::warn(
|
|
"Clock calendar configuration \"mode\"\"\" \"{0}\" is not recognized. Mode = \"month\" "
|
|
"is using instead",
|
|
cfgMode);
|
|
}
|
|
if (config_[kCalendarPlaceholder]["mode-mon-col"].isInt()) {
|
|
cldMonCols_ = config_[kCalendarPlaceholder]["mode-mon-col"].asInt();
|
|
if (cldMonCols_ == 0u || 12 % cldMonCols_ != 0u) {
|
|
cldMonCols_ = 3u;
|
|
spdlog::warn(
|
|
"Clock calendar configuration \"mode-mon-col\" = {0} must be one of [1, 2, 3, 4, 6, "
|
|
"12]. Value 3 is using instead",
|
|
cldMonCols_);
|
|
}
|
|
} else
|
|
cldMonCols_ = 1;
|
|
if (config_[kCalendarPlaceholder]["on-scroll"].isInt()) {
|
|
cldShift_ = date::months{config_[kCalendarPlaceholder]["on-scroll"].asInt()};
|
|
event_box_.add_events(Gdk::LEAVE_NOTIFY_MASK);
|
|
event_box_.signal_leave_notify_event().connect([this](GdkEventCrossing*) {
|
|
cldCurrShift_ = date::months{0};
|
|
return false;
|
|
});
|
|
}
|
|
}
|
|
|
|
if (config_["locale"].isString())
|
|
locale_ = std::locale(config_["locale"].asString());
|
|
else
|
|
locale_ = std::locale("");
|
|
|
|
thread_ = [this] {
|
|
dp.emit();
|
|
auto now = std::chrono::system_clock::now();
|
|
/* difference with projected wakeup time */
|
|
auto diff = now.time_since_epoch() % interval_;
|
|
/* sleep until the next projected time */
|
|
thread_.sleep_for(interval_ - diff);
|
|
};
|
|
}
|
|
|
|
const date::time_zone* waybar::modules::Clock::current_timezone() {
|
|
return time_zones_[current_time_zone_idx_];
|
|
}
|
|
|
|
auto waybar::modules::Clock::update() -> void {
|
|
const auto* tz{current_timezone()};
|
|
const date::zoned_time now{
|
|
tz,
|
|
date::floor<std::chrono::seconds>(
|
|
std::chrono::system_clock::now())}; // Define local time is based on provided time zone
|
|
const date::year_month_day today{
|
|
date::floor<date::days>(now.get_local_time())}; // Convert now to year_month_day
|
|
const date::year_month_day shiftedDay{today + cldCurrShift_}; // Shift today
|
|
// Define shift local time
|
|
const auto shiftedNow{date::make_zoned(
|
|
tz, date::local_days(shiftedDay) +
|
|
(now.get_local_time() - date::floor<date::days>(now.get_local_time())))};
|
|
|
|
label_.set_markup(
|
|
fmt::format(locale_, fmt::runtime(format_), now.get_local_time().time_since_epoch()));
|
|
|
|
if (tooltipEnabled()) {
|
|
const std::string tz_text{(is_timezoned_list_in_tooltip_) ? timezones_text(now.get_sys_time())
|
|
: ""};
|
|
const std::string cld_text{(is_calendar_in_tooltip_) ? get_calendar(today, shiftedDay, tz)
|
|
: ""};
|
|
|
|
const std::string text{fmt::format(locale_, fmt::runtime(fmtMap_[5]), shiftedNow,
|
|
fmt::arg(KTimezonedTimeListPlaceholder.c_str(), tz_text),
|
|
fmt::arg(kCalendarPlaceholder.c_str(), cld_text))};
|
|
label_.set_tooltip_markup(text);
|
|
}
|
|
|
|
// Call parent update
|
|
ALabel::update();
|
|
}
|
|
|
|
auto waybar::modules::Clock::doAction(const std::string& name) -> void {
|
|
if ((actionMap_[name])) {
|
|
(this->*actionMap_[name])();
|
|
update();
|
|
} else
|
|
spdlog::error("Clock. Unsupported action \"{0}\"", name);
|
|
}
|
|
|
|
// The number of weeks in calendar month layout plus 1 more for calendar titles
|
|
const unsigned cldRowsInMonth(const date::year_month& ym, const date::weekday& firstdow) {
|
|
using namespace date;
|
|
return static_cast<unsigned>(
|
|
ceil<weeks>((weekday{ym / 1} - firstdow) + ((ym / last).day() - day{0})).count()) +
|
|
2;
|
|
}
|
|
|
|
auto cldGetWeekForLine(const date::year_month& ym, const date::weekday& firstdow,
|
|
unsigned const line) -> const date::year_month_weekday {
|
|
unsigned index = line - 2;
|
|
auto sd = date::sys_days{ym / 1};
|
|
if (date::weekday{sd} == firstdow) ++index;
|
|
auto ymdw = ym / firstdow[index];
|
|
return ymdw;
|
|
}
|
|
|
|
auto getCalendarLine(const date::year_month_day& currDate, const date::year_month ym,
|
|
const unsigned line, const date::weekday& firstdow,
|
|
const std::locale* const locale_) -> std::string {
|
|
using namespace date::literals;
|
|
std::ostringstream res;
|
|
|
|
switch (line) {
|
|
case 0: {
|
|
// Output month and year title
|
|
res << date::format(*locale_, "%B %Y", ym);
|
|
break;
|
|
}
|
|
case 1: {
|
|
// Output weekday names title
|
|
auto wd{firstdow};
|
|
do {
|
|
Glib::ustring wd_ustring{date::format(*locale_, "%a", wd)};
|
|
auto clen{ustring_clen(wd_ustring)};
|
|
auto wd_len{wd_ustring.length()};
|
|
while (clen > 2) {
|
|
wd_ustring = wd_ustring.substr(0, wd_len - 1);
|
|
--wd_len;
|
|
clen = ustring_clen(wd_ustring);
|
|
}
|
|
const std::string pad(2 - clen, ' ');
|
|
|
|
if (wd != firstdow) res << ' ';
|
|
|
|
res << pad << wd_ustring;
|
|
} while (++wd != firstdow);
|
|
break;
|
|
}
|
|
case 2: {
|
|
// Output first week prefixed with spaces if necessary
|
|
auto wd = date::weekday{ym / 1};
|
|
res << std::string(static_cast<unsigned>((wd - firstdow).count()) * 3, ' ');
|
|
|
|
if (currDate.year() != ym.year() || currDate.month() != ym.month() || currDate != ym / 1_d)
|
|
res << date::format("%e", 1_d);
|
|
else
|
|
res << "{today}";
|
|
|
|
auto d = 2_d;
|
|
|
|
while (++wd != firstdow) {
|
|
if (currDate.year() != ym.year() || currDate.month() != ym.month() || currDate != ym / d)
|
|
res << date::format(" %e", d);
|
|
else
|
|
res << " {today}";
|
|
|
|
++d;
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
// Output a non-first week:
|
|
auto ymdw{cldGetWeekForLine(ym, firstdow, line)};
|
|
if (ymdw.ok()) {
|
|
auto d = date::year_month_day{ymdw}.day();
|
|
auto const e = (ym / last).day();
|
|
auto wd = firstdow;
|
|
|
|
if (currDate.year() != ym.year() || currDate.month() != ym.month() || currDate != ym / d)
|
|
res << date::format("%e", d);
|
|
else
|
|
res << "{today}";
|
|
|
|
while (++wd != firstdow && ++d <= e) {
|
|
if (currDate.year() != ym.year() || currDate.month() != ym.month() || currDate != ym / d)
|
|
res << date::format(" %e", d);
|
|
else
|
|
res << " {today}";
|
|
}
|
|
// Append row with spaces if the week did not complete
|
|
res << std::string(static_cast<unsigned>((firstdow - wd).count()) * 3, ' ');
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return res.str();
|
|
}
|
|
|
|
auto waybar::modules::Clock::get_calendar(const date::year_month_day& today,
|
|
const date::year_month_day& ymd,
|
|
const date::time_zone* tz) -> const std::string {
|
|
const auto ym{ymd.year() / ymd.month()};
|
|
const auto y{ymd.year()};
|
|
const auto d{ymd.day()};
|
|
const auto firstdow = first_day_of_week();
|
|
const auto maxRows{12 / cldMonCols_};
|
|
std::ostringstream os;
|
|
std::ostringstream tmp;
|
|
|
|
if (cldMode_ == CldMode::YEAR) {
|
|
if (y / date::month{1} / 1 == cldYearShift_)
|
|
if (d == cldBaseDay_ || (uint)cldBaseDay_ == 0u)
|
|
return cldYearCached_;
|
|
else
|
|
cldBaseDay_ = d;
|
|
else
|
|
cldYearShift_ = y / date::month{1} / 1;
|
|
}
|
|
if (cldMode_ == CldMode::MONTH) {
|
|
if (ym == cldMonShift_)
|
|
if (d == cldBaseDay_ || (uint)cldBaseDay_ == 0u)
|
|
return cldMonCached_;
|
|
else
|
|
cldBaseDay_ = d;
|
|
else
|
|
cldMonShift_ = ym;
|
|
}
|
|
|
|
// Compute number of lines needed for each calendar month
|
|
unsigned ml[12]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
|
|
|
|
for (auto& m : ml) {
|
|
if (cldMode_ == CldMode::YEAR || m == static_cast<unsigned>(ymd.month()))
|
|
m = cldRowsInMonth(y / date::month{m}, firstdow);
|
|
else
|
|
m = 0u;
|
|
}
|
|
|
|
for (auto row{0u}; row < maxRows; ++row) {
|
|
const auto lines = *std::max_element(std::begin(ml) + (row * cldMonCols_),
|
|
std::begin(ml) + ((row + 1) * cldMonCols_));
|
|
for (auto line{0u}; line < lines; ++line) {
|
|
for (auto col{0u}; col < cldMonCols_; ++col) {
|
|
const auto mon{date::month{row * cldMonCols_ + col + 1}};
|
|
if (cldMode_ == CldMode::YEAR || y / mon == ym) {
|
|
date::year_month ymTmp{y / mon};
|
|
if (col != 0 && cldMode_ == CldMode::YEAR) os << " ";
|
|
|
|
// Week numbers on the left
|
|
if (cldWPos_ == WeeksSide::LEFT && line > 0) {
|
|
if (line > 1) {
|
|
if (line < ml[static_cast<unsigned>(ymTmp.month()) - 1u])
|
|
os << fmt::format(fmt::runtime(fmtMap_[4]),
|
|
(line == 2)
|
|
? date::zoned_seconds{tz, date::local_days{ymTmp / 1}}
|
|
: date::zoned_seconds{tz, date::local_days{cldGetWeekForLine(
|
|
ymTmp, firstdow, line)}})
|
|
<< ' ';
|
|
else
|
|
os << std::string(cldWnLen_, ' ');
|
|
}
|
|
}
|
|
|
|
os << fmt::format(
|
|
fmt::runtime((cldWPos_ != WeeksSide::LEFT || line == 0) ? "{:<{}}" : "{:>{}}"),
|
|
getCalendarLine(today, ymTmp, line, firstdow, &locale_),
|
|
(cldMonColLen_ + ((line < 2) ? cldWnLen_ : 0)));
|
|
|
|
// Week numbers on the right
|
|
if (cldWPos_ == WeeksSide ::RIGHT && line > 0) {
|
|
if (line > 1) {
|
|
if (line < ml[static_cast<unsigned>(ymTmp.month()) - 1u])
|
|
os << ' '
|
|
<< fmt::format(fmt::runtime(fmtMap_[4]),
|
|
(line == 2)
|
|
? date::zoned_seconds{tz, date::local_days{ymTmp / 1}}
|
|
: date::zoned_seconds{tz, date::local_days{cldGetWeekForLine(
|
|
ymTmp, firstdow, line)}});
|
|
else
|
|
os << std::string(cldWnLen_, ' ');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Apply user formats to calendar
|
|
if (line < 2)
|
|
tmp << fmt::format(fmt::runtime(fmtMap_[line]), os.str());
|
|
else
|
|
tmp << os.str();
|
|
// Clear ostringstream
|
|
std::ostringstream().swap(os);
|
|
if (line + 1u != lines || (row + 1u != maxRows && cldMode_ == CldMode::YEAR)) tmp << '\n';
|
|
}
|
|
if (row + 1u != maxRows && cldMode_ == CldMode::YEAR) tmp << '\n';
|
|
}
|
|
|
|
os << fmt::format( // Apply days format
|
|
fmt::runtime(fmt::format(fmt::runtime(fmtMap_[2]), tmp.str())),
|
|
// Apply today format
|
|
fmt::arg("today", fmt::format(fmt::runtime(fmtMap_[3]), date::format("%e", d))));
|
|
|
|
if (cldMode_ == CldMode::YEAR)
|
|
cldYearCached_ = os.str();
|
|
else
|
|
cldMonCached_ = os.str();
|
|
|
|
return os.str();
|
|
}
|
|
|
|
/*Clock actions*/
|
|
void waybar::modules::Clock::cldModeSwitch() {
|
|
cldMode_ = (cldMode_ == CldMode::YEAR) ? CldMode::MONTH : CldMode::YEAR;
|
|
}
|
|
void waybar::modules::Clock::cldShift_up() {
|
|
cldCurrShift_ += ((cldMode_ == CldMode::YEAR) ? 12 : 1) * cldShift_;
|
|
}
|
|
void waybar::modules::Clock::cldShift_down() {
|
|
cldCurrShift_ -= ((cldMode_ == CldMode::YEAR) ? 12 : 1) * cldShift_;
|
|
}
|
|
void waybar::modules::Clock::tz_up() {
|
|
auto nr_zones = time_zones_.size();
|
|
|
|
if (nr_zones == 1) return;
|
|
|
|
size_t new_idx = current_time_zone_idx_ + 1;
|
|
current_time_zone_idx_ = new_idx == nr_zones ? 0 : new_idx;
|
|
}
|
|
void waybar::modules::Clock::tz_down() {
|
|
auto nr_zones = time_zones_.size();
|
|
|
|
if (nr_zones == 1) return;
|
|
|
|
current_time_zone_idx_ = current_time_zone_idx_ == 0 ? nr_zones - 1 : current_time_zone_idx_ - 1;
|
|
}
|
|
|
|
auto waybar::modules::Clock::timezones_text(std::chrono::system_clock::time_point now)
|
|
-> std::string {
|
|
if (time_zones_.size() == 1) {
|
|
return "";
|
|
}
|
|
std::stringstream os;
|
|
for (size_t time_zone_idx = 0; time_zone_idx < time_zones_.size(); ++time_zone_idx) {
|
|
if (static_cast<int>(time_zone_idx) == current_time_zone_idx_) {
|
|
continue;
|
|
}
|
|
const date::time_zone* timezone = time_zones_[time_zone_idx];
|
|
if (!timezone) {
|
|
timezone = date::current_zone();
|
|
}
|
|
auto ztime = date::zoned_time{timezone, date::floor<std::chrono::seconds>(now)};
|
|
os << fmt::format(locale_, fmt::runtime(format_), ztime) << '\n';
|
|
}
|
|
return os.str();
|
|
}
|
|
|
|
#ifdef HAVE_LANGINFO_1STDAY
|
|
template <auto fn>
|
|
using deleter_from_fn = std::integral_constant<decltype(fn), fn>;
|
|
|
|
template <typename T, auto fn>
|
|
using deleting_unique_ptr = std::unique_ptr<T, deleter_from_fn<fn>>;
|
|
#endif
|
|
|
|
// Computations done similarly to Linux cal utility.
|
|
auto waybar::modules::Clock::first_day_of_week() -> date::weekday {
|
|
#ifdef HAVE_LANGINFO_1STDAY
|
|
deleting_unique_ptr<std::remove_pointer<locale_t>::type, freelocale> posix_locale{
|
|
newlocale(LC_ALL, locale_.name().c_str(), nullptr)};
|
|
if (posix_locale) {
|
|
const int i = (std::intptr_t)nl_langinfo_l(_NL_TIME_WEEK_1STDAY, posix_locale.get());
|
|
auto ymd = date::year(i / 10000) / (i / 100 % 100) / (i % 100);
|
|
auto wd = date::weekday(ymd);
|
|
uint8_t j = *nl_langinfo_l(_NL_TIME_FIRST_WEEKDAY, posix_locale.get());
|
|
return wd + date::days(j - 1);
|
|
}
|
|
#endif
|
|
return date::Sunday;
|
|
}
|