[WIP] full views rework

src/windows/AppWindow/AppWindow.cpp

@@ -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()