Bernardo Magri
6c1f58ffb0
Add recurrence_frequency, recurrence_interval, recurrence_count, and
recurrence_by_weekday editor fields. Frequency cycles with Space.
BYDAY input accepts comma-separated names and ordinal prefixes (1MO).
Extend RecurrenceRule::by_weekday from std::chrono::weekday to ByWeekday
{ordinal, day} struct. Parser accepts ordinal BYDAY (+1MO, -1FR).
Remove strict BY*/FREQ pairing constraint to match RFC 5545.
681 lines
27 KiB
C++
681 lines
27 KiB
C++
#include "nocal/tui/EventEditor.hpp"
|
||
#include "nocal/tui/unicode.hpp"
|
||
|
||
#include <algorithm>
|
||
#include <array>
|
||
#include <atomic>
|
||
#include <chrono>
|
||
#include <cstdint>
|
||
#include <cstdio>
|
||
#include <ctime>
|
||
#include <initializer_list>
|
||
#include <random>
|
||
#include <sstream>
|
||
#include <stdexcept>
|
||
#include <utility>
|
||
#include <vector>
|
||
|
||
namespace nocal::tui {
|
||
namespace {
|
||
|
||
constexpr std::size_t field_count = static_cast<std::size_t>(EditorField::count);
|
||
constexpr std::array<std::string_view, field_count> labels{
|
||
"Title", "Start date", "Start time", "End date", "End time",
|
||
"All day", "Location", "Notes",
|
||
"Repeat", "Interval", "Count", "On days",
|
||
};
|
||
|
||
std::size_t index_of(const EditorField field) noexcept
|
||
{
|
||
return static_cast<std::size_t>(field);
|
||
}
|
||
|
||
std::string make_uid()
|
||
{
|
||
static std::atomic<std::uint64_t> sequence{0};
|
||
static const std::uint64_t seed = [] {
|
||
std::random_device random;
|
||
const auto high = static_cast<std::uint64_t>(random()) << 32U;
|
||
return high ^ static_cast<std::uint64_t>(random());
|
||
}();
|
||
const auto now = std::chrono::duration_cast<std::chrono::nanoseconds>(
|
||
std::chrono::system_clock::now().time_since_epoch())
|
||
.count();
|
||
std::ostringstream stream;
|
||
stream << "nocal-" << std::hex << static_cast<std::uint64_t>(now) << '-'
|
||
<< (seed ^ sequence.fetch_add(1, std::memory_order_relaxed)) << "@local";
|
||
return stream.str();
|
||
}
|
||
|
||
std::string two_digits(const unsigned value)
|
||
{
|
||
std::array<char, 3> buffer{};
|
||
std::snprintf(buffer.data(), buffer.size(), "%02u", value);
|
||
return {buffer.data(), 2};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> local_hour_minute(const TimePoint point)
|
||
{
|
||
const auto time = Clock::to_time_t(point);
|
||
std::tm value{};
|
||
#if defined(_WIN32)
|
||
if (::localtime_s(&value, &time) != 0) {
|
||
throw std::runtime_error("could not convert event time");
|
||
}
|
||
#else
|
||
if (::localtime_r(&time, &value) == nullptr) {
|
||
throw std::runtime_error("could not convert event time");
|
||
}
|
||
#endif
|
||
return {static_cast<unsigned>(value.tm_hour), static_cast<unsigned>(value.tm_min)};
|
||
}
|
||
|
||
struct CivilMoment {
|
||
Date date;
|
||
unsigned hour;
|
||
unsigned minute;
|
||
};
|
||
|
||
CivilMoment event_civil_moment(const Event& event, const TimePoint point)
|
||
{
|
||
if (event.time_basis != TimeBasis::zoned || event.time_zone.empty()) {
|
||
const auto [hour, minute] = local_hour_minute(point);
|
||
return {local_date(point), hour, minute};
|
||
}
|
||
const auto* zone = std::chrono::locate_zone(event.time_zone);
|
||
const auto local = zone->to_local(point);
|
||
const auto local_day = std::chrono::floor<std::chrono::days>(local);
|
||
const std::chrono::year_month_day date{local_day};
|
||
const auto time = std::chrono::duration_cast<std::chrono::minutes>(local - local_day);
|
||
const auto hour = static_cast<unsigned>(time.count() / 60);
|
||
const auto minute = static_cast<unsigned>(time.count() % 60);
|
||
return {date, hour, minute};
|
||
}
|
||
|
||
TimePoint make_event_time(const Event& event, const Date date, const unsigned hour,
|
||
const unsigned minute)
|
||
{
|
||
if (event.time_basis != TimeBasis::zoned || event.time_zone.empty()) {
|
||
return make_local_time(date, hour, minute);
|
||
}
|
||
const auto* zone = std::chrono::locate_zone(event.time_zone);
|
||
const auto value = std::chrono::local_days{date} + std::chrono::hours{hour} +
|
||
std::chrono::minutes{minute};
|
||
if (zone->get_info(value).result == std::chrono::local_info::nonexistent) {
|
||
throw std::runtime_error("local date-time does not exist in source time zone");
|
||
}
|
||
return zone->to_sys(value, std::chrono::choose::earliest);
|
||
}
|
||
|
||
bool parse_time(const std::string_view text, unsigned& hour, unsigned& minute) noexcept
|
||
{
|
||
if (text.size() != 5 || text[2] != ':' || text[0] < '0' || text[0] > '9' ||
|
||
text[1] < '0' || text[1] > '9' || text[3] < '0' || text[3] > '9' ||
|
||
text[4] < '0' || text[4] > '9') {
|
||
return false;
|
||
}
|
||
hour = static_cast<unsigned>((text[0] - '0') * 10 + text[1] - '0');
|
||
minute = static_cast<unsigned>((text[3] - '0') * 10 + text[4] - '0');
|
||
return hour < 24 && minute < 60;
|
||
}
|
||
|
||
void erase_last_codepoint(std::string& text)
|
||
{
|
||
if (text.empty()) {
|
||
return;
|
||
}
|
||
auto at = text.size() - 1;
|
||
while (at > 0 && (static_cast<unsigned char>(text[at]) & 0xc0U) == 0x80U) {
|
||
--at;
|
||
}
|
||
text.erase(at);
|
||
}
|
||
|
||
bool printable_input(const std::string_view key) noexcept
|
||
{
|
||
if (key.empty() || key.front() == '\x1b') {
|
||
return false;
|
||
}
|
||
return std::all_of(key.begin(), key.end(), [](const char character) {
|
||
const auto byte = static_cast<unsigned char>(character);
|
||
return byte >= 0x20U && byte != 0x7fU;
|
||
});
|
||
}
|
||
|
||
std::string single_line(std::string_view value)
|
||
{
|
||
std::string result{value};
|
||
std::replace(result.begin(), result.end(), '\n', ' ');
|
||
std::replace(result.begin(), result.end(), '\r', ' ');
|
||
return result;
|
||
}
|
||
|
||
std::string style(std::string text, const std::string_view code, const bool ansi)
|
||
{
|
||
if (!ansi || text.empty()) return text;
|
||
return "\x1b[" + std::string{code} + 'm' + std::move(text) + "\x1b[0m";
|
||
}
|
||
|
||
std::string interior_line(std::string content, const int width)
|
||
{
|
||
if (width <= 0) return {};
|
||
if (width == 1) return "│";
|
||
return "│" + fit_text(content, width - 2, false) + "│";
|
||
}
|
||
|
||
std::string styled_interior_line(std::string content, const int width,
|
||
const std::string_view code, const bool ansi)
|
||
{
|
||
if (width <= 0) return {};
|
||
if (width == 1) return "│";
|
||
return "│" + style(fit_text(content, width - 2, false), code, ansi) + "│";
|
||
}
|
||
|
||
std::string horizontal_line(const int width, const std::string_view left,
|
||
const std::string_view fill, const std::string_view right)
|
||
{
|
||
if (width <= 0) return {};
|
||
if (width == 1) return std::string{left};
|
||
std::string result{left};
|
||
for (int column = 0; column < width - 2; ++column) result += fill;
|
||
result += right;
|
||
return result;
|
||
}
|
||
|
||
struct KeyHint {
|
||
std::string_view key;
|
||
std::string_view label;
|
||
};
|
||
|
||
int hints_width(const KeyHint* const hints, const std::size_t count)
|
||
{
|
||
int width = 0;
|
||
for (std::size_t index = 0; index < count; ++index) {
|
||
if (index != 0) width += 3;
|
||
width += static_cast<int>(hints[index].key.size() + 1 + hints[index].label.size());
|
||
}
|
||
return width;
|
||
}
|
||
|
||
// Key bold, label dim, three spaces between hints; the plain layout is
|
||
// identical with ANSI disabled. Hints drop from the end to fit.
|
||
std::string render_hints(const std::initializer_list<KeyHint> hints, const int width,
|
||
const bool ansi)
|
||
{
|
||
std::size_t count = hints.size();
|
||
while (count > 0 && hints_width(hints.begin(), count) > width) --count;
|
||
std::string result;
|
||
for (std::size_t index = 0; index < count; ++index) {
|
||
if (index != 0) result += " ";
|
||
result += style(std::string{hints.begin()[index].key}, "1", ansi);
|
||
result += ' ';
|
||
result += style(std::string{hints.begin()[index].label}, "2", ansi);
|
||
}
|
||
const int used = hints_width(hints.begin(), count);
|
||
if (used < width) result.append(static_cast<std::size_t>(width - used), ' ');
|
||
return result;
|
||
}
|
||
|
||
std::string hints_interior_line(const std::initializer_list<KeyHint> hints, const int width,
|
||
const bool ansi)
|
||
{
|
||
if (width <= 0) return {};
|
||
if (width == 1) return "│";
|
||
if (width <= 3) return interior_line({}, width);
|
||
return "│ " + render_hints(hints, width - 4, ansi) + "│";
|
||
}
|
||
|
||
// Recurrence frequency display names
|
||
constexpr std::array<std::string_view, 5> frequency_names{
|
||
"none", "daily", "weekly", "monthly", "yearly",
|
||
};
|
||
|
||
[[nodiscard]] int frequency_name_to_index(const std::string_view name) noexcept
|
||
{
|
||
for (int i = 0; i < static_cast<int>(frequency_names.size()); ++i) {
|
||
if (frequency_names[static_cast<std::size_t>(i)] == name) return i;
|
||
}
|
||
return 0; // default to none
|
||
}
|
||
|
||
[[nodiscard]] std::string weekday_short_name(const std::chrono::weekday day) noexcept
|
||
{
|
||
static constexpr std::string_view names[]{"SU", "MO", "TU", "WE", "TH", "FR", "SA"};
|
||
return std::string(names[day.c_encoding()]);
|
||
}
|
||
|
||
[[nodiscard]] std::string by_weekday_display(const std::vector<ByWeekday>& weekdays)
|
||
{
|
||
std::string result;
|
||
for (std::size_t i = 0; i < weekdays.size(); ++i) {
|
||
if (i != 0) result += ",";
|
||
result += weekday_short_name(weekdays[i].day);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// Parse a comma-separated list of weekday short names (MO,TU,WE) into ByWeekday entries.
|
||
// Returns empty vector on any parse failure.
|
||
[[nodiscard]] std::vector<ByWeekday> parse_by_weekday_input(const std::string_view text)
|
||
{
|
||
std::vector<ByWeekday> result;
|
||
if (text.empty()) return result;
|
||
std::size_t start = 0;
|
||
while (start < text.size()) {
|
||
while (start < text.size() && (text[start] == ',' || text[start] == ' ')) ++start;
|
||
if (start >= text.size()) break;
|
||
std::size_t end = start;
|
||
while (end < text.size() && text[end] != ',' && text[end] != ' ') ++end;
|
||
const auto token = text.substr(start, end - start);
|
||
// Check for ordinal prefix (e.g., 1MO, -1SU)
|
||
int ordinal = 0;
|
||
std::string_view weekday_part = token;
|
||
if (!token.empty() && (token[0] == '+' || token[0] == '-' || (token[0] >= '0' && token[0] <= '9'))) {
|
||
std::size_t digit_end = 0;
|
||
if (token[0] == '+' || token[0] == '-') digit_end = 1;
|
||
while (digit_end < token.size() && token[digit_end] >= '0' && token[digit_end] <= '9') ++digit_end;
|
||
if (digit_end > 0U && digit_end < token.size()) {
|
||
try {
|
||
ordinal = std::stoi(std::string(token.substr(0, digit_end)));
|
||
} catch (...) {
|
||
return {};
|
||
}
|
||
if (ordinal < -5 || ordinal > 5) return {};
|
||
weekday_part = token.substr(digit_end);
|
||
}
|
||
}
|
||
std::chrono::weekday day{0};
|
||
bool found = false;
|
||
if (weekday_part == "SU") { day = std::chrono::Sunday; found = true; }
|
||
else if (weekday_part == "MO") { day = std::chrono::Monday; found = true; }
|
||
else if (weekday_part == "TU") { day = std::chrono::Tuesday; found = true; }
|
||
else if (weekday_part == "WE") { day = std::chrono::Wednesday; found = true; }
|
||
else if (weekday_part == "TH") { day = std::chrono::Thursday; found = true; }
|
||
else if (weekday_part == "FR") { day = std::chrono::Friday; found = true; }
|
||
else if (weekday_part == "SA") { day = std::chrono::Saturday; found = true; }
|
||
if (!found) return {};
|
||
result.push_back({ordinal, day});
|
||
start = end;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
} // namespace
|
||
|
||
EventEditor::EventEditor(const Date selected_day)
|
||
{
|
||
if (!selected_day.ok()) {
|
||
throw std::invalid_argument("event editor requires a valid selected date");
|
||
}
|
||
original_.uid = make_uid();
|
||
result_ = original_;
|
||
values_[index_of(EditorField::start_date)] = format_date(selected_day);
|
||
values_[index_of(EditorField::start_time)] = "09:00";
|
||
values_[index_of(EditorField::end_date)] = format_date(selected_day);
|
||
values_[index_of(EditorField::end_time)] = "10:00";
|
||
values_[index_of(EditorField::recurrence_frequency)] = "none";
|
||
values_[index_of(EditorField::recurrence_interval)] = "1";
|
||
values_[index_of(EditorField::recurrence_count)] = "";
|
||
// Default to days of week for weekly: the start day's weekday
|
||
const auto start_wd = std::chrono::weekday{std::chrono::sys_days{selected_day}};
|
||
values_[index_of(EditorField::recurrence_by_weekday)] = weekday_short_name(start_wd);
|
||
}
|
||
|
||
EventEditor::EventEditor(const Event& event)
|
||
: original_{event}, result_{event}, all_day_{event.all_day}, editing_{true}
|
||
{
|
||
const auto start = event_civil_moment(event, event.start);
|
||
const auto end = event_civil_moment(event, event.end);
|
||
values_[index_of(EditorField::title)] = event.title;
|
||
values_[index_of(EditorField::start_date)] = format_date(start.date);
|
||
values_[index_of(EditorField::start_time)] = two_digits(start.hour) + ':' +
|
||
two_digits(start.minute);
|
||
values_[index_of(EditorField::end_date)] = format_date(end.date);
|
||
values_[index_of(EditorField::end_time)] = two_digits(end.hour) + ':' + two_digits(end.minute);
|
||
values_[index_of(EditorField::location)] = event.location;
|
||
values_[index_of(EditorField::notes)] = event.description;
|
||
|
||
// Populate recurrence fields from existing rule
|
||
if (event.recurrence) {
|
||
const auto& rule = *event.recurrence;
|
||
std::string freq_name;
|
||
switch (rule.frequency) {
|
||
case RecurrenceFrequency::daily: freq_name = "daily"; break;
|
||
case RecurrenceFrequency::weekly: freq_name = "weekly"; break;
|
||
case RecurrenceFrequency::monthly: freq_name = "monthly"; break;
|
||
case RecurrenceFrequency::yearly: freq_name = "yearly"; break;
|
||
}
|
||
values_[index_of(EditorField::recurrence_frequency)] = freq_name;
|
||
values_[index_of(EditorField::recurrence_interval)] = std::to_string(rule.interval);
|
||
values_[index_of(EditorField::recurrence_count)] = rule.count
|
||
? std::to_string(*rule.count) : "";
|
||
values_[index_of(EditorField::recurrence_by_weekday)] = by_weekday_display(rule.by_weekday);
|
||
} else {
|
||
values_[index_of(EditorField::recurrence_frequency)] = "none";
|
||
values_[index_of(EditorField::recurrence_interval)] = "1";
|
||
values_[index_of(EditorField::recurrence_count)] = "";
|
||
const auto start_wd = std::chrono::weekday{std::chrono::sys_days{start.date}};
|
||
values_[index_of(EditorField::recurrence_by_weekday)] = weekday_short_name(start_wd);
|
||
}
|
||
}
|
||
|
||
std::string_view EventEditor::field_value(const EditorField field) const noexcept
|
||
{
|
||
if (field == EditorField::all_day) return {};
|
||
return values_[index_of(field)];
|
||
}
|
||
|
||
void EventEditor::move_focus(const int direction) noexcept
|
||
{
|
||
const auto current = static_cast<int>(index_of(focused_));
|
||
const auto count = static_cast<int>(field_count);
|
||
focused_ = static_cast<EditorField>((current + direction + count) % count);
|
||
}
|
||
|
||
EditorOutcome EventEditor::handle_key(const std::string_view key)
|
||
{
|
||
if (key == "\x1b") return EditorOutcome::cancel;
|
||
if (key == "\x13") return validate() ? EditorOutcome::submit : EditorOutcome::active;
|
||
if (key == "\t" || key == "\x1b[B" || key == "\x1b[C") {
|
||
move_focus(1);
|
||
return EditorOutcome::active;
|
||
}
|
||
if (key == "\x1b[Z" || key == "\x1b[A" || key == "\x1b[D") {
|
||
move_focus(-1);
|
||
return EditorOutcome::active;
|
||
}
|
||
if (key == "\r" || key == "\n") {
|
||
if (focused_ == EditorField::notes) {
|
||
values_[index_of(focused_)] += '\n';
|
||
} else {
|
||
move_focus(1);
|
||
}
|
||
return EditorOutcome::active;
|
||
}
|
||
if (focused_ == EditorField::all_day) {
|
||
if (key == " ") {
|
||
all_day_ = !all_day_;
|
||
if (all_day_) {
|
||
try {
|
||
const auto start = parse_date(values_[index_of(EditorField::start_date)]);
|
||
const auto end = parse_date(values_[index_of(EditorField::end_date)]);
|
||
if (start == end) {
|
||
values_[index_of(EditorField::end_date)] =
|
||
format_date(from_sys_days(to_sys_days(start) + std::chrono::days{1}));
|
||
}
|
||
} catch (const std::exception&) {
|
||
// Leave malformed input untouched; submit validation will
|
||
// focus it and provide the specific correction message.
|
||
}
|
||
}
|
||
}
|
||
return EditorOutcome::active;
|
||
}
|
||
|
||
// Recurrence frequency cycling: Space or arrow keys cycle through options
|
||
if (focused_ == EditorField::recurrence_frequency) {
|
||
if (key == " " || key == "\r" || key == "\n") {
|
||
auto& value = values_[index_of(focused_)];
|
||
const int current = frequency_name_to_index(value);
|
||
const int next = (current + 1) % static_cast<int>(frequency_names.size());
|
||
value = frequency_names[static_cast<std::size_t>(next)];
|
||
error_.clear();
|
||
}
|
||
return EditorOutcome::active;
|
||
}
|
||
|
||
auto& value = values_[index_of(focused_)];
|
||
if (key == "\x7f" || key == "\b") {
|
||
erase_last_codepoint(value);
|
||
error_.clear();
|
||
} else if (printable_input(key)) {
|
||
value.append(key);
|
||
error_.clear();
|
||
}
|
||
return EditorOutcome::active;
|
||
}
|
||
|
||
bool EventEditor::validate()
|
||
{
|
||
const auto fail = [this](const EditorField field, std::string message) {
|
||
focused_ = field;
|
||
error_ = std::move(message);
|
||
return false;
|
||
};
|
||
const auto& title = values_[index_of(EditorField::title)];
|
||
if (title.find_first_not_of(" \t\r\n") == std::string::npos) {
|
||
return fail(EditorField::title, "Title is required.");
|
||
}
|
||
|
||
Date start_day;
|
||
Date end_day;
|
||
try {
|
||
start_day = parse_date(values_[index_of(EditorField::start_date)]);
|
||
} catch (const std::exception&) {
|
||
return fail(EditorField::start_date, "Start date must be a valid YYYY-MM-DD date.");
|
||
}
|
||
try {
|
||
end_day = parse_date(values_[index_of(EditorField::end_date)]);
|
||
} catch (const std::exception&) {
|
||
return fail(EditorField::end_date, "End date must be a valid YYYY-MM-DD date.");
|
||
}
|
||
|
||
Event candidate = original_;
|
||
if (candidate.uid.empty()) candidate.uid = make_uid();
|
||
if (is_recurring(candidate) && all_day_ != candidate.all_day) {
|
||
return fail(EditorField::all_day,
|
||
"Timed/all-day conversion is unavailable for recurring series.");
|
||
}
|
||
candidate.title = title;
|
||
candidate.location = values_[index_of(EditorField::location)];
|
||
candidate.description = values_[index_of(EditorField::notes)];
|
||
candidate.all_day = all_day_;
|
||
|
||
try {
|
||
if (all_day_) {
|
||
if (to_sys_days(end_day) <= to_sys_days(start_day)) {
|
||
return fail(EditorField::end_date,
|
||
"All-day end is exclusive and must be at least the next day.");
|
||
}
|
||
candidate.time_basis = TimeBasis::floating;
|
||
candidate.time_zone.clear();
|
||
candidate.start = make_event_time(candidate, start_day, 0, 0);
|
||
candidate.end = make_event_time(candidate, end_day, 0, 0);
|
||
} else {
|
||
unsigned start_hour = 0;
|
||
unsigned start_minute = 0;
|
||
unsigned end_hour = 0;
|
||
unsigned end_minute = 0;
|
||
if (!parse_time(values_[index_of(EditorField::start_time)], start_hour, start_minute)) {
|
||
return fail(EditorField::start_time, "Start time must be a valid HH:MM time.");
|
||
}
|
||
if (!parse_time(values_[index_of(EditorField::end_time)], end_hour, end_minute)) {
|
||
return fail(EditorField::end_time, "End time must be a valid HH:MM time.");
|
||
}
|
||
candidate.start = make_event_time(candidate, start_day, start_hour, start_minute);
|
||
candidate.end = make_event_time(candidate, end_day, end_hour, end_minute);
|
||
if (candidate.end <= candidate.start) {
|
||
return fail(EditorField::end_time, "End must be after start.");
|
||
}
|
||
}
|
||
} catch (const std::exception&) {
|
||
return fail(EditorField::start_date,
|
||
"That local date and time cannot be represented in this time zone.");
|
||
}
|
||
|
||
// Build recurrence rule from editor fields
|
||
const auto& freq_text = values_[index_of(EditorField::recurrence_frequency)];
|
||
if (freq_text != "none") {
|
||
RecurrenceRule rule;
|
||
|
||
// Parse frequency
|
||
if (freq_text == "daily") rule.frequency = RecurrenceFrequency::daily;
|
||
else if (freq_text == "weekly") rule.frequency = RecurrenceFrequency::weekly;
|
||
else if (freq_text == "monthly") rule.frequency = RecurrenceFrequency::monthly;
|
||
else if (freq_text == "yearly") rule.frequency = RecurrenceFrequency::yearly;
|
||
else {
|
||
return fail(EditorField::recurrence_frequency, "Invalid recurrence frequency.");
|
||
}
|
||
|
||
// Parse interval
|
||
const auto& interval_text = values_[index_of(EditorField::recurrence_interval)];
|
||
if (interval_text.empty()) {
|
||
return fail(EditorField::recurrence_interval, "Interval is required.");
|
||
}
|
||
try {
|
||
const auto interval_val = std::stoul(interval_text);
|
||
if (interval_val < 1U || interval_val > 32767U) {
|
||
return fail(EditorField::recurrence_interval, "Interval must be between 1 and 32767.");
|
||
}
|
||
rule.interval = static_cast<unsigned>(interval_val);
|
||
} catch (const std::exception&) {
|
||
return fail(EditorField::recurrence_interval, "Interval must be a positive integer.");
|
||
}
|
||
|
||
// Parse count (optional)
|
||
const auto& count_text = values_[index_of(EditorField::recurrence_count)];
|
||
if (!count_text.empty()) {
|
||
try {
|
||
const auto count_val = std::stoul(count_text);
|
||
if (count_val < 1U) {
|
||
return fail(EditorField::recurrence_count, "Count must be at least 1.");
|
||
}
|
||
rule.count = static_cast<unsigned>(count_val);
|
||
} catch (const std::exception&) {
|
||
return fail(EditorField::recurrence_count, "Count must be a positive integer or empty.");
|
||
}
|
||
}
|
||
|
||
// Parse BYDAY
|
||
const auto& by_weekday_text = values_[index_of(EditorField::recurrence_by_weekday)];
|
||
const auto parsed = parse_by_weekday_input(by_weekday_text);
|
||
if (parsed.empty() && !by_weekday_text.empty()) {
|
||
return fail(EditorField::recurrence_by_weekday, "Use comma-separated day names: MO,TU,WE");
|
||
}
|
||
rule.by_weekday = parsed;
|
||
|
||
// If frequency is weekly and by_weekday is empty, fill with DTSTART's weekday
|
||
if (rule.frequency == RecurrenceFrequency::weekly && rule.by_weekday.empty()) {
|
||
const auto start_wd = std::chrono::weekday{std::chrono::sys_days{start_day}};
|
||
rule.by_weekday.push_back({0, start_wd});
|
||
}
|
||
|
||
candidate.recurrence = std::move(rule);
|
||
} else {
|
||
candidate.recurrence = std::nullopt;
|
||
}
|
||
|
||
result_ = std::move(candidate);
|
||
error_.clear();
|
||
return true;
|
||
}
|
||
|
||
std::string EventEditor::render(const int requested_width, const int requested_height,
|
||
const bool ansi) const
|
||
{
|
||
const int width = std::max(0, requested_width);
|
||
const int height = std::max(0, requested_height);
|
||
if (height == 0) return {};
|
||
|
||
const auto top = horizontal_line(width, "┌", "─", "┐");
|
||
const auto rule = horizontal_line(width, "├", "─", "┤");
|
||
const auto bottom = horizontal_line(width, "└", "─", "┘");
|
||
std::vector<std::string> lines;
|
||
lines.reserve(16);
|
||
lines.push_back(top);
|
||
const auto heading = editing_ && is_recurring(original_)
|
||
? " NOCAL · EDIT ENTIRE RECURRING SERIES"
|
||
: editing_ ? " NOCAL · EDIT APPOINTMENT"
|
||
: " NOCAL · NEW APPOINTMENT";
|
||
lines.push_back(styled_interior_line(heading, width, "1", ansi));
|
||
lines.push_back(hints_interior_line(
|
||
{{"Tab", "next field"}, {"Shift-Tab", "previous field"}, {"Space", "toggle"}},
|
||
width, ansi));
|
||
lines.push_back(styled_interior_line(
|
||
original_.time_basis == TimeBasis::zoned && !original_.time_zone.empty()
|
||
? " Times shown in source zone: " + original_.time_zone
|
||
: " Times shown in your local zone",
|
||
width, "2", ansi));
|
||
lines.push_back(rule);
|
||
|
||
const auto& freq_text = values_[index_of(EditorField::recurrence_frequency)];
|
||
const bool has_recurrence = freq_text != "none";
|
||
|
||
for (std::size_t index = 0; index < field_count; ++index) {
|
||
const auto field = static_cast<EditorField>(index);
|
||
const bool selected = focused_ == field;
|
||
|
||
// Suppress recurrence fields (except frequency) when frequency is none
|
||
if (field == EditorField::recurrence_interval && !has_recurrence) continue;
|
||
if (field == EditorField::recurrence_count && !has_recurrence) continue;
|
||
if (field == EditorField::recurrence_by_weekday && !has_recurrence) continue;
|
||
|
||
std::string value;
|
||
if (field == EditorField::all_day) {
|
||
value = all_day_ ? "[x] spans whole days (end date is exclusive)"
|
||
: "[ ] timed appointment";
|
||
} else if (all_day_ && (field == EditorField::start_time || field == EditorField::end_time)) {
|
||
value = "— not used for all-day appointments —";
|
||
} else if (field == EditorField::recurrence_frequency) {
|
||
value = std::string{freq_text};
|
||
if (selected) value += " (Space to cycle)";
|
||
} else if (field == EditorField::recurrence_interval) {
|
||
value = values_[index];
|
||
if (selected) value += "_";
|
||
} else if (field == EditorField::recurrence_count) {
|
||
const auto& count_val = values_[index];
|
||
value = count_val.empty() ? "(unlimited)" : count_val;
|
||
if (selected) value += "_";
|
||
} else if (field == EditorField::recurrence_by_weekday) {
|
||
value = values_[index];
|
||
if (selected) value += "_";
|
||
} else {
|
||
value = single_line(values_[index]);
|
||
if (selected) value += "_";
|
||
}
|
||
std::string row = selected ? " › " : " ";
|
||
row += fit_text(labels[index], 11, false);
|
||
row += " ";
|
||
row += value;
|
||
lines.push_back(styled_interior_line(std::move(row), width, selected ? "7" : "", ansi));
|
||
}
|
||
|
||
lines.push_back(rule);
|
||
lines.push_back(error_.empty()
|
||
? styled_interior_line(" Ready", width, "2", ansi)
|
||
: styled_interior_line(" ! " + error_, width, "1;31", ansi));
|
||
lines.push_back(hints_interior_line({{"Ctrl-S", "save"}, {"Esc", "cancel"}}, width, ansi));
|
||
lines.push_back(bottom);
|
||
|
||
// Keep the active field visible on short terminals by selecting a window
|
||
// from the complete form, while retaining a top and bottom frame.
|
||
if (static_cast<int>(lines.size()) > height) {
|
||
std::vector<std::string> compact;
|
||
compact.reserve(static_cast<std::size_t>(height));
|
||
compact.push_back(top);
|
||
if (height > 2) {
|
||
const int available = height - 2;
|
||
const int selected_line = 5 + static_cast<int>(index_of(focused_));
|
||
const int maximum_start = static_cast<int>(lines.size()) - 1 - available;
|
||
const int start = std::clamp(selected_line - available / 2, 1,
|
||
std::max(1, maximum_start));
|
||
for (int offset = 0; offset < available; ++offset) {
|
||
compact.push_back(lines[static_cast<std::size_t>(start + offset)]);
|
||
}
|
||
}
|
||
if (height > 1) compact.push_back(bottom);
|
||
lines = std::move(compact);
|
||
}
|
||
while (static_cast<int>(lines.size()) < height) {
|
||
lines.insert(lines.end() - 1, interior_line({}, width));
|
||
}
|
||
|
||
std::string frame;
|
||
for (int row = 0; row < height; ++row) {
|
||
if (row != 0) frame += '\n';
|
||
frame += lines[static_cast<std::size_t>(row)];
|
||
}
|
||
return frame;
|
||
}
|
||
|
||
} // namespace nocal::tui
|