vyn/mirai
1
Fork 0
mirror of https://codeberg.org/vyn/mirai.git synced 2025-07-12 05:43:18 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[WIP] full views rework

Browse source
This commit is contained in:
Vyn 2025-06-29 20:07:11 +02:00
parent 9de3972630
commit 15bd0f58a7
Signed by: vyn
GPG key ID: E1B2BE34E7A971E7
30 changed files with 812 additions and 1175 deletions
Download patch file Download diff file Expand all files Collapse all files

16
src/components/Calendar.slint
View file

@ -1,10 +1,10 @@
import { ScrollView, Date, Time } from "std-widgets.slint";
import { VCheckBox, VButton, VActionButton, Svg, VTag, VPopupIconMenu, VText, Palette } from "@selenite";
import { Utils } from "../shared/Utils.slint";
import { AppModels, CalendarDay, CalendarDateDisplayFormat } from "../shared/Models.slint";
import { AppModels, CalendarViewDate, CalendarDateDisplayFormat } from "../shared/Models.slint";
export component Calendar inherits Rectangle {
in property<[CalendarDay]> days;
in property<[CalendarViewDate]> days;
in property <CalendarDateDisplayFormat> format;
in property <Date> current-date;
in property <Time> current-time;
@ -17,8 +17,6 @@ export component Calendar inherits Rectangle {
callback delete-event-request(source-id: int, event-id: int);
HorizontalLayout {
Rectangle {
//background: red;
@ -94,20 +92,20 @@ export component Calendar inherits Rectangle {
Rectangle {
width: 100%;
height: 100%;
background: AppModels.get-source-color-from-id-as-color(event.sourceId);
background: AppModels.get-source-color-from-id-as-color(event.source-id);
opacity: 0.05;
}
background: Palette.card-background;
border-radius: 4px;
x: 8px;
width: parent.width - 16px;
y: day-start-y + hour-spacing * event.startsAt.hour;
height: hour-spacing * (event.endsAt.hour - event.startsAt.hour) - 2px;
y: day-start-y + hour-spacing * event.starts_at.hour;
height: hour-spacing * (event.ends_at.hour - event.starts_at.hour) - 2px;
clip: true;
HorizontalLayout {
Rectangle {
width: 4px;
background: AppModels.get-source-color-from-id-as-color(event.sourceId);
background: AppModels.get-source-color-from-id-as-color(event.source-id);
}
VerticalLayout {
padding: 16px;
@ -138,7 +136,7 @@ export component Calendar inherits Rectangle {
icon-size: 1.5rem;
border-radius: 0;
clicked => {
delete-event-request(event.sourceId, event.id);
delete-event-request(event.source-id, event.id);
}
}
}

2
src/components/CreateTaskOrEvent.slint
View file

@ -39,7 +39,7 @@ export component CreateTaskOrEvent inherits Rectangle {
newTaskTitleInput := VTextInput {
placeholder: "Enter new task";
started-writting() => {
sourceInput.current-index = AppModels.default-source-index;
sourceInput.current-index = 0;
}
accepted => { accepted() }
}

128
src/components/EventGroup.slint
View file

@ -1,128 +0,0 @@
import { Event } from "../shared/Models.slint";
import { ScrollView } from "std-widgets.slint";
import { VCheckBox, VTextInput, VButton, VActionButton, Svg, VTag, VPopupIconMenu, VText, Palette } from "@selenite";
import { TaskLine } from "./TaskLine.slint";
import { Utils } from "../shared/Utils.slint";
export struct EventGroupAddTask {
title: string
}
export component EventGroup {
in property<Event> event;
private property <bool> show-add-task: false;
private property <bool> edit-name: false;
callback add-task(EventGroupAddTask);
callback edit-task(int, EventGroupAddTask);
callback delete-task(int);
callback delete();
callback edit(EventGroupAddTask);
callback toggle-check-task(int);
eventPopup := VPopupIconMenu {
VActionButton {
icon-svg: Svg.plus;
icon-colorize: Colors.greenyellow;
icon-size: 1.5rem;
border-radius: 0;
clicked => {
root.show-add-task = true;
}
}
VActionButton {
icon-svg: Svg.pen;
icon-colorize: Colors.grey;
icon-size: 1.5rem;
border-radius: 0;
clicked => { edit-name = true; }
}
VActionButton {
icon-svg: Svg.trash;
icon-colorize: Colors.pink;
icon-size: 1.5rem;
border-radius: 0;
clicked => { root.delete() }
}
}
ta := TouchArea {
pointer-event(e) => {
if (e.button == PointerEventButton.right && e.kind == PointerEventKind.up) {
eventPopup.show(ta.mouse-x, ta.mouse-y);
}
}
}
HorizontalLayout {
VerticalLayout {
spacing: 4px;
VText {
text: Utils.time-to-string(event.startsAt);
horizontal-alignment: center;
color: Palette.accent;
}
HorizontalLayout {
alignment: center;
Rectangle {
width: 2px;
background: Palette.accent;
}
}
VText {
text: Utils.time-to-string(event.endsAt);
color: Palette.accent;
font-size: 0.9rem;
horizontal-alignment: center;
}
}
VerticalLayout {
horizontal-stretch: 1;
padding: 16px;
padding-top: 32px;
padding-bottom: 32px;
padding-right: 0px;
if !edit-name : VText {
text: event.title;
font-size: 1.1rem;
}
if edit-name : title := VTextInput {
text: event.title;
accepted => {
root.edit({
title: title.text
});
root.edit-name = false;
}
}
for task[taskIndex] in event.tasks: VerticalLayout {
padding-top: taskIndex == 0 ? 16px : 0px;
padding-bottom: 8px;
TaskLine {
title: task.title;
checked: task.checked;
delete => {
root.delete-task(task.id)
}
toggle-check => {
root.toggle-check-task(task.id)
}
edited(data) => {
root.edit-task(task.id, {
title: data.title
});
}
}
}
if show-add-task : taskInput := VTextInput {
accepted => {
root.add-task({
title: taskInput.text
});
root.show-add-task = false;
}
}
}
}
}

1
src/shared/Actions.slint
View file

@ -1,5 +1,4 @@
import { Date, Time } from "std-widgets.slint";
import { CalendarDay } from "./Models.slint";
export struct NewTaskData {
sourceId: int,

94
src/shared/Models.slint
View file

@ -1,68 +1,76 @@
import { Date, Time } from "std-widgets.slint";
export struct Source {
export struct TasksViewTask {
id: int,
source-id: int,
title: string,
checked: bool
}
export struct TasksViewSource {
id: int,
name: string,
selected: bool,
path: string
color: color,
tasks: [TasksViewTask]
}
export struct TaskData {
sourceId: int,
eventId: int,
id: int,
title: string,
date: Date,
checked: bool,
export struct TasksViewDate {
due-date: Date,
no-date: bool,
is-late: bool,
sources: [TasksViewSource]
}
export struct Event {
sourceId: int,
export struct TasksView {
dates: [TasksViewDate],
sources: [string]
}
export struct CalendarViewEvent {
source-id: int,
id: int,
title: string,
startsAt: Time,
endsAt: Time,
tasks: [TaskData],
starts-at: Time,
ends-at: Time
}
export struct Day {
sourceId: int,
id: int,
date: Date,
events: [Event],
tasks: [TaskData],
isLate: bool,
isToday: bool,
relativeDaysDiff: int
}
export struct CalendarDayEvent {
sourceId: int,
id: int,
title: string,
startsAt: Time,
endsAt: Time
}
export struct CalendarDay {
events: [CalendarDayEvent],
export struct CalendarViewDate {
events: [CalendarViewEvent],
date: Date,
header: string,
}
export struct CalendarView {
dates: [CalendarViewDate]
}
export struct SidebarViewSources {
id: int,
name: string,
color: color,
active: bool
}
export enum SidebarViewActiveTab {
tasks,
calendar
}
export struct SidebarView {
sources: [SidebarViewSources],
active-view: SidebarViewActiveTab,
all-active: bool
}
export enum CalendarDateDisplayFormat {
Relative,
Normal
}
export global AppModels {
in-out property<[Source]> sources-selected;
in-out property<int> default-source-index;
in-out property<[string]> sources;
in-out property<bool> no-source-selected;
in-out property<[Day]> days;
in-out property<[CalendarDay]> calendar;
in-out property<[TaskData]> unscheduled-tasks;
in-out property<SidebarView> sidebar-view;
in-out property<TasksView> tasks-view;
in-out property<CalendarView> calendar-view;
callback get-source-id-from-name(string) -> int;
pure callback get-source-name-from-id(int) -> string;

24
src/view.h Normal file
View file

@ -0,0 +1,24 @@
#include "DataProvider.h"
#include "DateTime.h"
#include <vector>
struct source_group {
int source_id;
std::vector<mirai::event_data> events;
std::vector<mirai::task_data> tasks;
};
struct day_group {
mirai::Date date;
source_group sources;
};
std::vector<day_group>
group_by_day(std::vector<mirai::event_data> events, std::vector<mirai::task_data> tasks)
{
std::vector<day_group> days;
// todo
return days;
}

661
src/windows/AppWindow/AppWindow.cpp
View file

@ -8,37 +8,40 @@
#include "../../SeleniteSetup.h"
#include "../../shared/Utils.h"
#include "mirai-core/DateTime.h"
#include "mirai-core/Day.h"
#include "mirai-core/Event.h"
#include "mirai-core/MarkdownDataProvider.h"
#include "mirai-core/Mirai.h"
#include "mirai-core/Source.h"
#include "selenite/palette.h"
#include "slint_color.h"
#include "slint_models.h"
#include "slint_string.h"
#include "ui.h"
#include <algorithm>
#include <bits/chrono.h>
#include <cassert>
#include <chrono>
#include <cstdlib>
#include <iostream>
#include <iterator>
#include <memory>
#include <optional>
#include <print>
#include <ranges>
#include <string>
#include <string_view>
#include <vector>
AppWindow::AppWindow(mirai::Mirai *miraiInstance)
: miraiInstance_(miraiInstance), view_(miraiInstance)
AppWindow::AppWindow(mirai::Mirai *miraiInstance) : miraiInstance_(miraiInstance)
{
sources_ = std::make_shared<slint::VectorModel<ui::Source>>();
days_ = std::make_shared<slint::VectorModel<ui::Day>>();
calendar_ = std::make_shared<slint::VectorModel<ui::CalendarDay>>();
unscheduledTasks_ = std::make_shared<slint::VectorModel<ui::TaskData>>();
auto sourcesNames = std::make_shared<slint::MapModel<ui::Source, slint::SharedString>>(
sources_, [&](const ui::Source &a) {
return a.name;
}
);
_sidebar_view = ui::SidebarView();
_calendar_view = ui::CalendarView();
_tasks_view = ui::TasksView();
/*auto sourcesNames = std::make_shared<slint::MapModel<ui::Source, slint::SharedString>>(*/
/*sources_, [&](const ui::Source &a) {*/
/*return a.name;*/
/*}*/
/*);*/
const auto palettePath = std::string(getenv("HOME")) + "/.config/evalyte/theme.json";
const auto palette = selenite::parseJson(palettePath);
@ -49,13 +52,14 @@ AppWindow::AppWindow(mirai::Mirai *miraiInstance)
bindSlintUtils(mainWindow_->global<ui::Utils>());
models().set_sources(sourcesNames);
models().set_sources_selected(sources_);
models().set_days(days_);
models().set_calendar(calendar_);
models().set_sidebar_view(_sidebar_view);
models().set_calendar_view(_calendar_view);
models().set_tasks_view(_tasks_view);
view_.setAllSources();
view_.update();
show_all_sources();
update_views();
/*view_.setAllSources();*/
/*view_.update();*/
reloadSources();
reloadTasks();
@ -119,41 +123,37 @@ void AppWindow::setupCallbacks()
return slint::SharedString(sourceProvider->path());
});
miraiInstance_->onSourceAdded([&](mirai::source *source) {
refreshModels();
});
miraiInstance_->onSourceEdited([&](mirai::source *source) {
refreshModels();
});
miraiInstance_->onSourceDeleted([&](int id) {
refreshModels();
});
miraiInstance_->onSourceAdded([&](mirai::source *source) { refreshModels(); });
miraiInstance_->onSourceEdited([&](mirai::source *source) { refreshModels(); });
miraiInstance_->onSourceDeleted([&](int id) { refreshModels(); });
actions().on_task_clicked([&](int sourceId, int taskId) {
auto source = miraiInstance_->getSourceById(sourceId);
assert(source);
auto task = source->get_task_by_id(taskId);
assert(task);
if (!task->checked() && !task->hasDate() && !task->hasEvent()) {
task->setDate(mirai::Date(mirai::Date(std::chrono::system_clock::now())));
}
task->setChecked(!task->checked());
task->set_checked(!task->checked());
miraiInstance_->save();
view_.update();
update_views();
// view_.update();
reloadTasks();
});
actions().on_source_clicked([&](int index) {
// index with value -1 is equal to no selection, aka "All"
if (index == -1) {
view_.setAllSources();
show_all_sources();
// view_.setAllSources();
} else {
view_.removeSources();
hide_all_sources();
// view_.removeSources();
const mirai::source *source = miraiInstance_->getSourceById(index);
view_.addSource(*source);
show_source(*source);
// view_.addSource(*source);
}
models().set_default_source_index(index == -1 ? 0 : index);
view_.update();
// models().set_default_source_index(index == -1 ? 0 : index);
update_views();
// view_.update();
reloadSources();
reloadTasks();
});
@ -178,13 +178,20 @@ void AppWindow::setupCallbacks()
assert(task);
source->remove_task(*task);
miraiInstance_->save();
view_.update();
// view_.update();
update_views();
reloadTasks();
});
actions().on_toggle_show_completed_tasks([&] {
view_.hideCompletedTasks(!view_.shouldHideCompletedTasks());
view_.update();
// view_.hideCompletedTasks(!view_.shouldHideCompletedTasks());
if (should_hide_completed_tasks()) {
show_completed_tasks();
} else {
hide_completed_tasks();
}
// view_.update();
update_views();
reloadTasks();
});
@ -194,19 +201,12 @@ void AppWindow::setupCallbacks()
auto task = source->get_task_by_id(newTaskData.id);
assert(task.has_value());
const mirai::Date &date = SlintDateToMiraiDate(newTaskData.date);
const auto dayOpt = source->get_day_by_date(date);
task->setTitle(std::string(newTaskData.title));
if (!task.value().hasEvent() && date.year != 0) {
task->setDate(date);
}
if (!task.value().hasEvent() && date.year == 0) {
task->unschedule();
}
// const auto dayOpt = source->get_day_by_date(date);
task->set_title(std::string(newTaskData.title));
miraiInstance_->save();
view_.update();
// view_.update();
update_views();
reloadTasks();
});
@ -224,12 +224,12 @@ void AppWindow::setupCallbacks()
source->create_task({
.title = std::string(newTaskData.title),
.event = event,
.date = date,
.due_date = date,
});
miraiInstance_->save();
view_.update();
// view_.update();
update_views();
reloadTasks();
});
@ -240,24 +240,26 @@ void AppWindow::setupCallbacks()
assert(event.has_value());
source->remove_event(event.value());
miraiInstance_->save();
view_.update();
// view_.update();
update_views();
reloadTasks();
});
actions().on_create_event([&](ui::CreateEventParams newEventParams) {
const ui::Date &date = newEventParams.date;
const std::string dateStr = SlintDateToStdString(date);
const auto sourceId = models().get_default_source_index();
auto source = miraiInstance_->getSourceById(sourceId == -1 ? 0 : sourceId);
// const auto sourceId = models().get_default_source_index();
// auto source = miraiInstance_->getSourceById(sourceId == -1 ? 0 : sourceId);
source->create_event({
.title = std::string(newEventParams.title),
.date = SlintDateToMiraiDate(newEventParams.date),
.startsAt = SlintTimeToMiraiTime(newEventParams.startsAt),
.endsAt = SlintTimeToMiraiTime(newEventParams.endsAt),
});
/* source->create_event({*/
/*.title = std::string(newEventParams.title),*/
/*.date = SlintDateToMiraiDate(newEventParams.date),*/
/*.starts_at = SlintTimeToMiraiTime(newEventParams.startsAt),*/
/*.ends_at = SlintTimeToMiraiTime(newEventParams.endsAt),*/
/*});*/
miraiInstance_->save();
view_.update();
// view_.update();
update_views();
reloadTasks();
});
}
@ -274,157 +276,410 @@ stdToSlintStringVector(const std::vector<std::string> &stdVector)
void AppWindow::reloadTasks()
{
days_->clear();
if (miraiInstance_->getSources().size() == 0) {
return;
}
auto todayDate = mirai::Date(std::chrono::system_clock::now());
auto dates = view_.getDates();
auto slintDays = std::make_shared<slint::VectorModel<ui::Day>>();
for (int dayIndex = 0; dayIndex < dates.size(); ++dayIndex) {
auto &currentDate = dates.at(dayIndex);
auto slintEvents = std::make_shared<slint::VectorModel<ui::Event>>();
auto slintDayTasks = std::make_shared<slint::VectorModel<ui::TaskData>>();
auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(
std::chrono::sys_days(currentDate.toStdChrono()) -
std::chrono::sys_days(todayDate.toStdChrono())
)
.count();
slintDays->push_back(
ui::Day{
.date = MiraiDateToSlintDate(currentDate),
.events = slintEvents,
.tasks = slintDayTasks,
.isLate = currentDate < todayDate,
.isToday = currentDate == todayDate,
.relativeDaysDiff = static_cast<int>(relativeDaysDiff)
}
);
// Day's tasks
const std::vector<mirai::Task> tasksForDate = view_.getTasksForDate(currentDate);
for (int taskIndex = 0; taskIndex < tasksForDate.size(); ++taskIndex) {
auto &task = tasksForDate.at(taskIndex);
slintDayTasks->push_back({
.sourceId = task.sourceId(),
.eventId = -1,
.id = task.id(),
.title = slint::SharedString(task.title()),
.checked = task.checked(),
});
}
/* days_->clear();*/
/*if (miraiInstance_->getSources().size() == 0) {*/
/*return;*/
/*}*/
/*auto todayDate = mirai::Date(std::chrono::system_clock::now());*/
/*auto dates = view_.getDates();*/
/*auto slintDays = std::make_shared<slint::VectorModel<ui::Day>>();*/
/*for (int dayIndex = 0; dayIndex < dates.size(); ++dayIndex) {*/
/*auto &currentDate = dates.at(dayIndex);*/
/*auto slintEvents = std::make_shared<slint::VectorModel<ui::Event>>();*/
/*auto slintDayTasks = std::make_shared<slint::VectorModel<ui::TaskData>>();*/
/*auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(*/
/*std::chrono::sys_days(currentDate.toStdChrono()) -*/
/*std::chrono::sys_days(todayDate.toStdChrono())*/
/*)*/
/*.count();*/
/*slintDays->push_back(*/
/*ui::Day{*/
/*.date = MiraiDateToSlintDate(currentDate),*/
/*.events = slintEvents,*/
/*.tasks = slintDayTasks,*/
/*.isLate = currentDate < todayDate,*/
/*.isToday = currentDate == todayDate,*/
/*.relativeDaysDiff = static_cast<int>(relativeDaysDiff)*/
/*}*/
/*);*/
/*Day's tasks*/
/*const std::vector<mirai::Task> tasksForDate = view_.getTasksForDate(currentDate);*/
/*for (int taskIndex = 0; taskIndex < tasksForDate.size(); ++taskIndex) {*/
/*auto &task = tasksForDate.at(taskIndex);*/
/*slintDayTasks->push_back({*/
/*.sourceId = task.sourceId(),*/
/*.eventId = -1,*/
/*.id = task.id(),*/
/*.title = slint::SharedString(task.title()),*/
/*.checked = task.checked(),*/
/*});*/
/*}*/
// Day's events
const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);
for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {
auto &currentEvent = eventsForDate.at(eventIndex);
auto slintTasks = std::make_shared<slint::VectorModel<ui::TaskData>>();
slintEvents->push_back(
ui::Event{
.sourceId = currentEvent.sourceId(),
.id = currentEvent.id(),
.title = slint::SharedString(currentEvent.title()),
.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),
.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),
.tasks = slintTasks,
}
);
auto eventTasks = currentEvent.queryTasks();
for (int taskIndex = 0; taskIndex < eventTasks.size(); ++taskIndex) {
auto &task = eventTasks.at(taskIndex);
slintTasks->push_back({
.sourceId = task.sourceId(),
.eventId = currentEvent.id(),
.id = task.id(),
.title = slint::SharedString(task.title()),
.checked = task.checked(),
});
}
}
}
days_ = slintDays;
models().set_days(days_);
/*Day's events*/
/*const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);*/
/*for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {*/
/*auto &currentEvent = eventsForDate.at(eventIndex);*/
/*auto slintTasks = std::make_shared<slint::VectorModel<ui::TaskData>>();*/
/*slintEvents->push_back(*/
/*ui::Event{*/
/*.sourceId = currentEvent.source_id(),*/
/*.id = currentEvent.id(),*/
/*.title = slint::SharedString(currentEvent.title()),*/
/*.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),*/
/*.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),*/
/*.tasks = slintTasks,*/
/*}*/
/*);*/
/*auto eventTasks = currentEvent.queryTasks();*/
/*for (int taskIndex = 0; taskIndex < eventTasks.size(); ++taskIndex) {*/
/*auto &task = eventTasks.at(taskIndex);*/
/*slintTasks->push_back({*/
/*.sourceId = task.sourceId(),*/
/*.eventId = currentEvent.id(),*/
/*.id = task.id(),*/
/*.title = slint::SharedString(task.title()),*/
/*.checked = task.checked(),*/
/*});*/
/*}*/
/*}*/
/*}*/
/*days_ = slintDays;*/
/*models().set_days(days_);*/
auto unscheduledTasksView = view_.getUnscheduledTasks();
unscheduledTasks_->clear();
for (int taskIndex = 0; taskIndex < unscheduledTasksView.size(); ++taskIndex) {
auto &task = unscheduledTasksView.at(taskIndex);
const auto &source = miraiInstance_->getSourceById(task.sourceId());
std::println("request name for source id {} : {}", task.sourceId(), source->name());
unscheduledTasks_->push_back({
.sourceId = task.sourceId(),
.eventId = -1,
.id = task.id(),
.title = slint::SharedString(task.title()),
.checked = task.checked(),
});
}
models().set_unscheduled_tasks(unscheduledTasks_);
/*auto unscheduledTasksView = view_.getUnscheduledTasks();*/
/*unscheduledTasks_->clear();*/
/*for (int taskIndex = 0; taskIndex < unscheduledTasksView.size(); ++taskIndex) {*/
/*auto &task = unscheduledTasksView.at(taskIndex);*/
/*const auto &source = miraiInstance_->getSourceById(task.sourceId());*/
/*std::println("request name for source id {} : {}", task.sourceId(), source->name());*/
/*unscheduledTasks_->push_back({*/
/*.sourceId = task.sourceId(),*/
/*.eventId = -1,*/
/*.id = task.id(),*/
/*.title = slint::SharedString(task.title()),*/
/*.checked = task.checked(),*/
/*});*/
/*}*/
/*models().set_unscheduled_tasks(unscheduledTasks_);*/
calendar_->clear();
for (int dayIndex = 0; dayIndex < 7; ++dayIndex) {
std::chrono::year_month_day nextDate =
std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now()) +
std::chrono::days{dayIndex};
auto currentDate = mirai::Date{nextDate};
auto events = view_.getEventsForDate(currentDate);
auto slintEvents = std::make_shared<slint::VectorModel<ui::CalendarDayEvent>>();
auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(
std::chrono::sys_days(currentDate.toStdChrono()) -
std::chrono::sys_days(todayDate.toStdChrono())
)
.count();
if (relativeDaysDiff < 0 || relativeDaysDiff >= 7) {
continue;
}
const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);
for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {
auto &currentEvent = eventsForDate.at(eventIndex);
slintEvents->push_back(
ui::CalendarDayEvent{
.sourceId = currentEvent.sourceId(),
.id = currentEvent.id(),
.title = slint::SharedString(currentEvent.title()),
.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),
.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),
}
);
}
/*calendar_->clear();*/
/*for (int dayIndex = 0; dayIndex < 7; ++dayIndex) {*/
/*std::chrono::year_month_day nextDate =*/
/*std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now()) +*/
/*std::chrono::days{dayIndex};*/
/*auto currentDate = mirai::Date{nextDate};*/
/*auto events = view_.getEventsForDate(currentDate);*/
/*auto slintEvents = std::make_shared<slint::VectorModel<ui::CalendarDayEvent>>();*/
/*auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(*/
/*std::chrono::sys_days(currentDate.toStdChrono()) -*/
/*std::chrono::sys_days(todayDate.toStdChrono())*/
/*)*/
/*.count();*/
/*if (relativeDaysDiff < 0 || relativeDaysDiff >= 7) {*/
/*continue;*/
/*}*/
/*const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);*/
/*for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {*/
/*auto &currentEvent = eventsForDate.at(eventIndex);*/
/*slintEvents->push_back(*/
/*ui::CalendarDayEvent{*/
/*.sourceId = currentEvent.source_id(),*/
/*.id = currentEvent.id(),*/
/*.title = slint::SharedString(currentEvent.title()),*/
/*.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),*/
/*.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),*/
/*}*/
/*);*/
/*}*/
auto calendarDay = ui::CalendarDay{
.events = slintEvents,
.date = MiraiDateToSlintDate(currentDate),
.header = slint::SharedString(
capitalize(formatDateRelative(MiraiDateToSlintDate(currentDate)))
)
};
calendar_->push_back(calendarDay);
}
/*auto calendarDay = ui::CalendarDay{*/
/*.events = slintEvents,*/
/*.date = MiraiDateToSlintDate(currentDate),*/
/*.header = slint::SharedString(*/
/*capitalize(formatDateRelative(MiraiDateToSlintDate(currentDate)))*/
/*)*/
/*};*/
/*calendar_->push_back(calendarDay);*/
/*}*/
}
void AppWindow::reloadSources()
{
sources_->clear();
bool noSourceSelected = miraiInstance_->getSources().size() == view_.activeSourceCount();
for (const auto &source : miraiInstance_->getSources()) {
bool isSourceSelected = view_.isSourceSelected(*source);
mirai::markdown_data_provider *sourceProvider =
dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());
sources_->push_back(
{.id = source->id,
.name = slint::SharedString(source->name()),
.selected = isSourceSelected && !noSourceSelected,
.path = slint::SharedString(sourceProvider->path())}
);
}
models().set_no_source_selected(noSourceSelected);
/*sources_->clear();*/
/*bool noSourceSelected = miraiInstance_->getSources().size() == view_.activeSourceCount();*/
/*for (const auto &source : miraiInstance_->getSources()) {*/
/*bool isSourceSelected = view_.isSourceSelected(*source);*/
/*mirai::markdown_data_provider *sourceProvider =*/
/*dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());*/
/*sources_->push_back(*/
/*{.id = source->id,*/
/*.name = slint::SharedString(source->name()),*/
/*.selected = isSourceSelected && !noSourceSelected,*/
/*.path = slint::SharedString(sourceProvider->path())}*/
/*);*/
/*}*/
/*models().set_no_source_selected(noSourceSelected);*/
}
void AppWindow::refreshModels()
{
view_.setAllSources();
view_.update();
reloadSources();
reloadTasks();
show_all_sources();
update_views();
}
void AppWindow::update_views()
{
update_sidebar_view();
update_calendar_view();
update_tasks_view();
}
void AppWindow::update_sidebar_view()
{
const auto &sources = miraiInstance_->getSources();
auto new_sources = std::make_shared<slint::VectorModel<ui::SidebarViewSources>>();
std::println("sources");
for (auto &source : sources) {
std::println("source: {}", source->name());
mirai::markdown_data_provider *sourceProvider =
dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());
new_sources->push_back(
{.id = source->id, .name = slint::SharedString(source->name()), .active = false}
);
}
_sidebar_view.sources = new_sources;
_sidebar_view.all_active = true; // TESTING
_sidebar_view.active_view = ui::SidebarViewActiveTab::Calendar;
models().set_sidebar_view(_sidebar_view);
}
std::vector<mirai::Event>
get_all_events_from_sources(std::vector<std::unique_ptr<mirai::source>> &sources)
{
std::vector<mirai::Event> all_events;
for (auto &source : sources) {
const auto &events = source->get_events();
all_events.insert(all_events.end(), events.begin(), events.end());
}
return all_events;
}
std::vector<mirai::Event>
get_events_for_date(const std::vector<mirai::Event> &events, const mirai::Date &date)
{
auto filtered_events = events | std::ranges::views::filter([&](const mirai::Event &event) {
return event.date() == date;
});
return std::ranges::to<std::vector>(filtered_events);
}
void AppWindow::update_calendar_view()
{
auto today = mirai::Date(std::chrono::system_clock::now());
auto new_slint_dates = std::make_shared<slint::VectorModel<ui::CalendarViewDate>>();
auto &sources = miraiInstance_->getSources();
auto all_events = get_all_events_from_sources(sources);
for (int day_index = 0; day_index < 7; ++day_index) {
std::chrono::year_month_day next_date =
std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now())
+ std::chrono::days{day_index};
auto current_date = mirai::Date{next_date};
auto new_slint_events = std::make_shared<slint::VectorModel<ui::CalendarViewEvent>>();
auto relative_days_diff = std::chrono::duration_cast<std::chrono::days>(
std::chrono::sys_days(current_date.toStdChrono())
- std::chrono::sys_days(today.toStdChrono())
)
.count();
if (relative_days_diff < 0 || relative_days_diff >= 7) {
continue;
}
auto events_for_date = get_events_for_date(all_events, current_date);
for (int event_index = 0; event_index < events_for_date.size(); ++event_index) {
auto &current_event = events_for_date.at(event_index);
new_slint_events->push_back(
ui::CalendarViewEvent{
.source_id = current_event.source_id(),
.id = current_event.id(),
.title = slint::SharedString(current_event.title()),
.starts_at = MiraiTimeToSlintTime(current_event.starts_at()),
.ends_at = MiraiTimeToSlintTime(current_event.ends_at()),
}
);
}
auto new_slint_date = ui::CalendarViewDate{
.events = new_slint_events,
.date = MiraiDateToSlintDate(current_date),
.header = slint::SharedString(
capitalize(formatDateRelative(MiraiDateToSlintDate(current_date)))
)
};
new_slint_dates->push_back(new_slint_date);
}
_calendar_view.dates = new_slint_dates;
models().set_calendar_view(_calendar_view);
}
std::vector<mirai::Task>
get_all_tasks_from_sources(std::vector<std::unique_ptr<mirai::source>> &sources)
{
std::vector<mirai::Task> all_tasks;
for (auto &source : sources) {
const auto &tasks = source->get_tasks();
all_tasks.insert(all_tasks.end(), tasks.begin(), tasks.end());
}
std::sort(all_tasks.begin(), all_tasks.end(), [](const mirai::Task &t1, const mirai::Task &t2) {
if (!t1.has_due_date() && !t2.has_due_date()) {
return false;
}
if (t1.has_due_date() && !t2.has_due_date()) {
return true;
}
if (!t1.has_due_date() && t2.has_due_date()) {
return false;
}
return t1.due_date() < t2.due_date();
});
return all_tasks;
}
struct tasks_source_group {
int id;
std::vector<mirai::Task> tasks;
};
struct tasks_date_group {
std::optional<mirai::Date> date;
std::vector<tasks_source_group> sources;
};
std::vector<tasks_date_group> group_tasks_by_date(const std::vector<mirai::Task> &tasks)
{
if (tasks.size() == 0) {
return {};
}
std::vector<tasks_date_group> dates_group;
int next_task_index = 0;
mirai::Task current_task = tasks.at(next_task_index);
while (next_task_index < tasks.size()) {
tasks_date_group date_group{.date = current_task.due_date()};
while (next_task_index < tasks.size() && current_task.due_date() == date_group.date) {
tasks_source_group source_group{.id = current_task.source_id()};
while (next_task_index < tasks.size() && current_task.due_date() == date_group.date
&& current_task.source_id() == source_group.id) {
source_group.tasks.push_back(current_task);
next_task_index++;
if (next_task_index >= tasks.size()) {
break;
}
current_task = tasks.at(next_task_index);
}
date_group.sources.push_back(source_group);
}
dates_group.push_back(date_group);
}
return dates_group;
};
void AppWindow::update_tasks_view()
{
auto today = mirai::Date(std::chrono::system_clock::now());
auto new_slint_dates = std::make_shared<slint::VectorModel<ui::TasksViewDate>>();
auto &sources = miraiInstance_->getSources();
auto all_tasks_dates = group_tasks_by_date(get_all_tasks_from_sources(sources));
for (int date_index = 0; date_index < all_tasks_dates.size(); ++date_index) {
auto &current_date_group = all_tasks_dates.at(date_index);
auto &current_date = current_date_group.date;
std::optional<int> relative_days_diff = std::nullopt;
if (current_date.has_value()) {
relative_days_diff = std::chrono::duration_cast<std::chrono::days>(
std::chrono::sys_days(current_date.value().toStdChrono())
- std::chrono::sys_days(today.toStdChrono())
)
.count();
}
auto new_slint_sources = std::make_shared<slint::VectorModel<ui::TasksViewSource>>();
for (auto &source : current_date_group.sources) {
auto new_slint_source = ui::TasksViewSource();
auto new_slint_tasks = std::make_shared<slint::VectorModel<ui::TasksViewTask>>();
for (auto &task : source.tasks) {
if (task.has_due_date() && task.due_date() < today) {
continue;
}
new_slint_tasks->push_back(
{.id = task.id(),
.source_id = source.id,
.title = slint::SharedString(task.title()),
.checked = task.checked()}
);
}
new_slint_source.tasks = new_slint_tasks;
new_slint_source.id = source.id;
new_slint_source.name =
slint::SharedString(miraiInstance_->getSourceById(source.id)->name());
const auto color =
selenite::hexStringToColor(miraiInstance_->getSourceById(source.id)->color());
new_slint_source.color = slint::Color::from_rgb_uint8(color.r, color.g, color.b);
if (new_slint_source.tasks->row_count() > 0) {
new_slint_sources->push_back(new_slint_source);
}
}
auto new_slint_date = ui::TasksViewDate{
.sources = new_slint_sources,
};
if (current_date.has_value()) {
new_slint_date.due_date = MiraiDateToSlintDate(current_date.value());
new_slint_date.is_late = current_date.value() < today;
} else {
new_slint_date.no_date = true;
}
if (new_slint_date.sources->row_count() > 0) {
new_slint_dates->push_back(new_slint_date);
}
_tasks_view.dates = new_slint_dates;
models().set_tasks_view(_tasks_view);
}
}
void AppWindow::show_source(const mirai::source &source)
{
}
void AppWindow::show_all_sources()
{
}
void AppWindow::hide_all_sources()
{
}
void AppWindow::show_completed_tasks()
{
}
void AppWindow::hide_completed_tasks()
{
}
bool AppWindow::should_hide_completed_tasks() const
{
return true;
}
void AppWindow::run()

27
src/windows/AppWindow/AppWindow.h
View file

@ -7,9 +7,10 @@
#pragma once
#include "mirai-core/Mirai.h"
#include "mirai-core/View.h"
#include "mirai-core/Source.h"
#include "slint.h"
#include "ui.h"
#include <vector>
class AppWindow
{
@ -23,18 +24,32 @@ class AppWindow
void reloadTasks();
void refreshModels();
void update_views();
void update_sidebar_view();
void update_calendar_view();
void update_tasks_view();
void show_all_sources();
void show_source(const mirai::source &source);
void hide_all_sources();
void show_completed_tasks();
void hide_completed_tasks();
bool should_hide_completed_tasks() const;
private:
void setupCallbacks();
const ui::AppModels &models();
const ui::AppActions &actions();
std::shared_ptr<slint::VectorModel<ui::Source>> sources_;
std::shared_ptr<slint::VectorModel<ui::Day>> days_;
std::shared_ptr<slint::VectorModel<ui::CalendarDay>> calendar_;
std::shared_ptr<slint::VectorModel<ui::TaskData>> unscheduledTasks_;
ui::SidebarView _sidebar_view;
ui::TasksView _tasks_view;
ui::CalendarView _calendar_view;
slint::ComponentHandle<ui::AppWindow> mainWindow_ = ui::AppWindow::create();
mirai::Mirai *miraiInstance_;
mirai::View view_;
std::vector<int> _source_filters;
bool _should_hide_completed_tasks;
};

5
src/windows/AppWindow/views/CalendarView.slint
View file

@ -1,8 +1,7 @@
import { AppModels, TaskData } from "../../../shared/Models.slint";
import { AppModels } from "../../../shared/Models.slint";
import { AppActions, NewTaskData, SaveTaskData } from "../../../shared/Actions.slint";
import { Button, VerticalBox, CheckBox, ScrollView, ComboBox } from "std-widgets.slint";
import { TaskLine } from "../../../components/TaskLine.slint";
import { EventGroup } from "../../../components/EventGroup.slint";
import { Calendar } from "../../../components/Calendar.slint";
import { VDatePicker, VTimePicker, VCheckBox, VButton, VTag, VText, VTextInput, Svg, Palette } from "@selenite";
import { CreateTaskOrEvent } from "../../../components/CreateTaskOrEvent.slint";
@ -41,7 +40,7 @@ export component CalendarView inherits Rectangle {
delete-event-request(source-id, event-id) => {
AppActions.delete-event(source-id, event-id)
}
days: AppModels.calendar;
days: AppModels.calendar-view.dates;
current-date: Utils.current-date;
current-time: Utils.current-time;
}

16
src/windows/AppWindow/views/SideBar.slint
View file

@ -1,4 +1,4 @@
import { AppModels, TaskData } from "../../../shared/Models.slint";
import { AppModels } from "../../../shared/Models.slint";
import { AppActions } from "../../../shared/Actions.slint";
import { VButton, ToggleButton, VActionButton, VText, Svg, Palette } from "@selenite";
import { EditSourceModal } from "../../../modals/EditSourceModal.slint";
@ -10,7 +10,7 @@ export component SideBar inherits Rectangle {
editSourcePopup.edit(source-id)
}
addSourcePopup := AddSourceModal{}
addSourcePopup := AddSourceModal{}
editSourcePopup := EditSourceModal {}
VerticalLayout {
@ -46,17 +46,17 @@ export component SideBar inherits Rectangle {
ToggleButton {
text: "All";
text-alignment: left;
active: AppModels.no-source-selected;
active: AppModels.sidebar-view.all-active;
clicked => { AppActions.source-clicked(-1) }
}
for item[index] in AppModels.sources-selected: ToggleButton {
text: item.name;
for source[index] in AppModels.sidebar-view.sources: ToggleButton {
text: source.name;
text-alignment: left;
active: item.selected;
clicked => { AppActions.source-clicked(item.id) }
right-clicked => { editSourcePopup.edit(item.id) }
active: source.active;
clicked => { AppActions.source-clicked(source.id) }
right-clicked => { editSourcePopup.edit(source.id) }
}
}
VerticalLayout {

151
src/windows/AppWindow/views/TasksView.slint
View file

@ -1,8 +1,7 @@
import { AppModels, TaskData } from "../../../shared/Models.slint";
import { AppModels } from "../../../shared/Models.slint";
import { AppActions, NewTaskData, SaveTaskData } from "../../../shared/Actions.slint";
import { Button, VerticalBox, CheckBox, ScrollView, ComboBox } from "std-widgets.slint";
import { TaskLine } from "../../../components/TaskLine.slint";
import { EventGroup } from "../../../components/EventGroup.slint";
import { Calendar } from "../../../components/Calendar.slint";
import { VPopupIconMenu, VDatePicker, VTimePicker, VCheckBox, VButton, VTag, VText, VTextInput, Svg, Palette } from "@selenite";
import { CreateTaskOrEvent } from "../../../components/CreateTaskOrEvent.slint";
@ -37,7 +36,7 @@ export component MainView inherits Rectangle {
}
CreateTaskOrEvent {
sources: AppModels.sources;
sources: AppModels.tasks-view.sources;
create-task(data) => {
AppActions.create-task({
sourceId: data.sourceId,
@ -54,106 +53,66 @@ export component MainView inherits Rectangle {
horizontal-stretch: 1;
VerticalLayout {
alignment: start;
if AppModels.days.length == 0 && AppModels.unscheduled-tasks.length == 0 : VText {
if AppModels.tasks-view.dates.length == 0 : VText {
text: "There is no task to show";
horizontal-alignment: center;
vertical-alignment: center;
}
for day[dayIndex] in AppModels.days: VerticalLayout {
spacing: day.tasks.length > 0 ? 16px : 0px;
for day[dayIndex] in AppModels.tasks-view.dates: VerticalLayout {
spacing: day.sources.length > 0 ? 16px : 0px;
padding-bottom: 32px;
if day.tasks.length > 0 : Rectangle {
border-radius: 8px;
VerticalLayout {
HorizontalLayout {
alignment: start;
VText {
text: Utils.format-date(day.date);
color: day.isLate ? Palette.orange : Palette.foreground;
font-size: 1.2rem;
}
VerticalLayout {
alignment: center;
VText {
text: day.relativeDaysDiff == 0 ? " - today" :
day.relativeDaysDiff == 1 ? " - tomorrow" :
day.relativeDaysDiff == -1 ? " - yesterday" :
day.relativeDaysDiff > 0 ? " - in \{day.relativeDaysDiff} days" :
" - \{-day.relativeDaysDiff} days ago";
color: Palette.foreground-hint;
font-size: 1rem;
}
}
}
for task[taskIndex] in day.tasks: VerticalLayout {
padding-top: taskIndex == 0 ? 16px : 0px;
padding-bottom: 8px;
TaskLine {
title: task.title;
source-name: AppModels.get-source-name-from-id(task.sourceId);
source-color: AppModels.get-source-color-from-id-as-color(task.sourceId);
scheduled: task.date.year != 0;
date: day.date;
checked: task.checked;
allow-edit-date: true;
delete => {
AppActions.delete-task-clicked(task.sourceId, task.id)
}
toggle-check => {
AppActions.task-clicked(task.sourceId, task.id);
}
edited(data) => {
AppActions.save-task({
id: task.id,
sourceId: task.sourceId,
title: data.title,
scheduled: data.scheduled,
date: data.date
})
}
}
}
HorizontalLayout {
alignment: start;
VText {
text: day.no-date ? "Unscheduled" : Utils.format-date(day.due-date);
color: day.is-late ? Palette.orange : Palette.foreground;
font-size: 1.2rem;
}
//VerticalLayout {
//alignment: center;
//VText {
//text: day.relativeDaysDiff == 0 ? " - today" :
//day.relativeDaysDiff == 1 ? " - tomorrow" :
//day.relativeDaysDiff == -1 ? " - yesterday" :
//day.relativeDaysDiff > 0 ? " - in \{day.relativeDaysDiff} days" :
//" - \{-day.relativeDaysDiff} days ago";
//color: Palette.foreground-hint;
//font-size: 1rem;
//}
//}
}
}
if AppModels.unscheduled-tasks.length > 0 : VerticalLayout {
Rectangle {
//background: Palette.card-background;
border-radius: 8px;
VerticalLayout {
HorizontalLayout {
alignment: start;
VText {
text: "Unscheduled";
color: Palette.foreground;
font-size: 1.2rem;
}
}
for task[taskIndex] in AppModels.unscheduled-tasks: VerticalLayout {
padding-top: taskIndex == 0 ? 16px : 0px;
padding-bottom: 8px;
TaskLine {
title: task.title;
source-name: AppModels.get-source-name-from-id(task.sourceId);
source-color: AppModels.get-source-color-from-id-as-color(task.sourceId);
checked: task.checked;
allow-edit-date: true;
delete => {
AppActions.delete-task-clicked(task.sourceId, task.id)
}
toggle-check => {
AppActions.task-clicked(task.sourceId, task.id);
}
edited(data) => {
AppActions.save-task({
id: task.id,
sourceId: task.sourceId,
title: data.title,
scheduled: data.scheduled,
date: data.date
})
for source[source-index] in day.sources: VerticalLayout {
VText {
text: source.name;
}
if source.tasks.length > 0 : Rectangle {
VerticalLayout {
for task[taskIndex] in source.tasks: VerticalLayout {
padding-top: taskIndex == 0 ? 16px : 0px;
padding-bottom: 8px;
TaskLine {
title: task.title;
source-name: AppModels.get-source-name-from-id(task.source-id);
source-color: AppModels.get-source-color-from-id-as-color(task.source-id);
checked: task.checked;
allow-edit-date: true;
delete => {
AppActions.delete-task-clicked(task.source-id, task.id)
}
toggle-check => {
AppActions.task-clicked(task.source-id, task.id);
}
edited(data) => {
AppActions.save-task({
id: task.id,
sourceId: task.source-id,
title: data.title,
scheduled: data.scheduled,
date: data.date
})
}
}
}
}