Rework mirai core

external/mirai-core-old/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.21)
+project(mirai LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_COMPILE_WARNING_AS_ERROR ON)
+
+add_library(mirai-core 
+	src/Mirai.cpp
+	src/Config.cpp
+	src/ConfigImpl.cpp
+	src/TaskItem.cpp
+	src/Day.cpp
+	src/Event.cpp
+	src/DateTime.cpp
+	src/EventEmitter.cpp 
+	src/BaseSource.cpp 
+	src/StdFileSource.cpp 
+	src/TasksView.cpp
+	src/TodoMd.cpp
+	src/utils.cpp
+)
+
+target_include_directories(mirai-core PRIVATE "external")
+target_include_directories(mirai-core PRIVATE "include/mirai-core")

external/mirai-core-old/external/cpp-utils/debug.h

@@ -0,0 +1,65 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#ifndef CPP_UTILS_DEBUG_H
+#define CPP_UTILS_DEBUG_H
+
+#include <algorithm>
+#include <chrono>
+#include <iostream>
+#include <ostream>
+#include <string>
+
+namespace cpputils::debug
+{
+
+class Timer
+{
+  public:
+	Timer() : startTime(std::chrono::steady_clock::now())
+	{
+	}
+
+	void start()
+	{
+		startTime = std::chrono::steady_clock::now();
+		isRunning = true;
+	}
+
+	void stop()
+	{
+		const auto now = std::chrono::steady_clock::now();
+		duration += std::chrono::duration_cast<std::chrono::milliseconds>(now - startTime).count();
+		isRunning = false;
+	}
+
+	void reset()
+	{
+		duration = 0;
+		isRunning = false;
+	}
+
+	void printTimeElapsed(const std::string &message) const
+	{
+		long durationToShow = duration;
+		if (isRunning) {
+			const auto now = std::chrono::steady_clock::now();
+			durationToShow +=
+				std::chrono::duration_cast<std::chrono::milliseconds>(now - startTime).count();
+		}
+		std::cout << "[Debug - Timer] " << message << ": " << durationToShow << " ms" << std::endl;
+	}
+
+  private:
+	std::chrono::time_point<std::chrono::steady_clock, std::chrono::nanoseconds> startTime;
+
+	// Timer are always running when created. You can use .reset() after creation.
+	bool isRunning = true;
+	long duration = 0;
+};
+} // namespace cpputils::debug
+
+#endif

external/mirai-core-old/external/cpp-utils/string.h

@@ -0,0 +1,27 @@
+/* 
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#ifndef CPP_UTILS_STRING_H
+#define CPP_UTILS_STRING_H
+
+#include <algorithm>
+#include <string>
+
+namespace cpputils::string {
+
+	inline std::string trim(std::string str) {
+		str.erase(str.begin(), std::ranges::find_if(str, [](unsigned char ch) {
+			return !std::isspace(ch);
+		}));
+		str.erase(std::ranges::find_if(str.rbegin(), str.rend(), [](unsigned char ch) {
+			return !std::isspace(ch);
+		}).base(), str.end());
+		return str;
+	}
+
+}
+
+#endif

external/mirai-core-old/external/cpp-utils/vector.h

@@ -0,0 +1,48 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#ifndef CPP_UTILS_VECTOR_H
+#define CPP_UTILS_VECTOR_H
+
+#include <algorithm>
+#include <vector>
+
+namespace cpputils::vector
+{
+
+template <typename C, typename T>
+concept AnyIterable = std::same_as<typename C::value_type, T> && requires(C c) {
+	{
+		c.begin()
+	} -> std::forward_iterator;
+	{
+		c.end()
+	} -> std::forward_iterator;
+	{
+		const_cast<const C &>(c).begin()
+	} -> std::forward_iterator;
+	{
+		const_cast<const C &>(c).end()
+	} -> std::forward_iterator;
+};
+
+template <typename T> bool contains(const std::vector<T> &vec, const T &value)
+{
+	return std::ranges::find(vec, value) != vec.end();
+}
+
+template <typename T> bool containsAll(const std::vector<T> &vec, const AnyIterable<T> auto vec2)
+{
+	for (auto &elem : vec) {
+		if (!contains(vec2, elem)) {
+			return false;
+		}
+	}
+	return true;
+}
+} // namespace cpputils::vector
+
+#endif

external/mirai-core-old/include/mirai-core/BaseSource.h

@@ -18,6 +18,25 @@
 namespace mirai
 {
 
+struct SourceData {
+	std::vector<std::unique_ptr<Day>> days;
+	std::vector<std::unique_ptr<Event>> events;
+	std::vector<std::unique_ptr<TaskItem>> tasks;
+};
+
+struct createTaskParams {
+	std::string title;
+	std::optional<Event> event;
+	std::optional<Date> date;
+};
+
+struct createEventParams {
+	std::string title;
+	Date date;
+	Time startsAt;
+	Time endsAt;
+};
+
 class BaseSource
 {
 
@@ -38,14 +57,21 @@ class BaseSource
 	void setName(std::string name);
 	const std::string &getName() const;
 
-	void addDay(const DayData &dayData);
-	void addUnscheduledTask(const TaskItemData &taskData);
-	Day *day(const Date &date);
-	std::vector<std::unique_ptr<TaskItem>> *unscheduledTasks();
-	std::vector<std::unique_ptr<Day>> *days();
+	void createTask(const createTaskParams &task);
+	void removeTask(const TaskItem &task);
+
 	TaskItem *getTaskById(int taskId);
 	Event *getEventById(int eventId);
-	void deleteTask(const TaskItem &task);
+	Day *day(const Date &date);
+
+	// --
+
+	// void addDay(const DayData &dayData);
+	// void addUnscheduledTask(const TaskItemData &taskData);
+	// std::vector<std::unique_ptr<TaskItem>> *unscheduledTasks();
+	// std::vector<std::unique_ptr<Day>> *days();
+
+	// void deleteTask(const TaskItem &task);
 
 	void setDirty(bool shouldBeDirty);
 	bool isDirty() const;
@@ -56,8 +82,9 @@ class BaseSource
 	static int nextId_;
 	int id_ = nextId_++;
 	std::string name_;
-	std::vector<std::unique_ptr<Day>> days_;
-	std::vector<std::unique_ptr<TaskItem>> unscheduledTasks_;
+	SourceData data;
+	// std::vector<std::unique_ptr<Day>> days_;
+	// std::vector<std::unique_ptr<TaskItem>> unscheduledTasks_;
 	bool isDirty_ = false;
 };
 

external/mirai-core-old/include/mirai-core/Config.h

@@ -0,0 +1,29 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace mirai
+{
+
+class ConfigImpl;
+
+class Config
+{
+  public:
+	Config(const std::string &path);
+	~Config();
+
+	std::vector<std::string> sources() const;
+
+  private:
+	std::unique_ptr<ConfigImpl> impl_;
+};
+} // namespace mirai

external/mirai-core-old/include/mirai-core/DateTime.h

@@ -0,0 +1,54 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include <bits/chrono.h>
+#include <chrono>
+#include <ctime>
+#include <optional>
+#include <string>
+
+namespace mirai
+{
+
+struct Date {
+	explicit Date(int year, unsigned month, unsigned day);
+
+	explicit Date(std::chrono::time_point<std::chrono::system_clock> tp);
+	explicit Date(std::chrono::year_month_day chronoDate);
+
+	bool operator==(const Date &other) const;
+	bool operator<(const Date &other) const;
+	bool operator>(const Date &other) const;
+
+	std::chrono::year_month_day toStdChrono() const
+	{
+		return std::chrono::year_month_day{
+			std::chrono::year(year),
+			std::chrono::month(month),
+			std::chrono::day(day),
+		};
+	}
+
+	int year;
+	unsigned month;
+	unsigned day;
+};
+
+struct Time {
+
+	bool operator==(const Time &other) const;
+	bool operator<(const Time &other) const;
+	bool operator>(const Time &other) const;
+
+	int hour;
+	int minute;
+};
+
+std::optional<mirai::Date> stringToDate(const std::string &dateStr);
+
+} // namespace mirai

external/mirai-core-old/include/mirai-core/Day.h

@@ -0,0 +1,56 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include "DateTime.h"
+#include "Event.h"
+#include "TaskItem.h"
+#include "using.h"
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace mirai
+{
+
+class BaseSource;
+
+struct DayData {
+	Date date;
+	std::vector<EventData> events;
+	std::vector<TaskItemData> tasks;
+};
+
+class Day
+{
+  public:
+	Day(BaseSource *source, const DayData &data);
+	void setDate(const Date &date);
+
+	Event *createEvent(const EventData &eventData);
+	TaskItem *createTask(const TaskItemData &taskData);
+	void insertTask(std::unique_ptr<TaskItem> &&task);
+	void deleteTask(const TaskItem &taskToDelete);
+	std::optional<std::unique_ptr<TaskItem>> takeTask(const TaskItem &taskToDelete);
+	void deleteEvent(const Event &eventToDelete);
+	std::vector<std::unique_ptr<Event>> *events();
+	std::vector<std::unique_ptr<TaskItem>> *tasks();
+
+	const Date &getDate() const;
+
+	Event *getEventById(int eventId);
+	BaseSource *source();
+
+  private:
+	void onChange();
+
+	BaseSource *source_;
+	std::vector<std::unique_ptr<Event>> events_;
+	std::vector<std::unique_ptr<TaskItem>> tasks_;
+	DayData data_;
+};
+} // namespace mirai

external/mirai-core-old/include/mirai-core/Event.h

@@ -0,0 +1,68 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include "DateTime.h"
+#include "TaskItem.h"
+#include "using.h"
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace mirai
+{
+
+class BaseSource;
+
+struct EventData {
+	std::string description;
+	Date date;
+	Time startTime;
+	Time endTime;
+	Tags tags;
+	std::vector<TaskItemData> tasks;
+};
+
+class Day;
+
+class Event
+{
+  private:
+  public:
+	Event(BaseSource *source, Day *parent, const EventData &data);
+
+	Event &operator=(const EventData &newData);
+
+	void setText(const std::string &text);
+	void setStartTime(const Time &time);
+	void setEndTime(const Time &time);
+
+	TaskItem *createTask(const TaskItemData &taskData);
+	void deleteTask(const TaskItem &taskToDelete);
+	std::vector<std::unique_ptr<TaskItem>> *tasks();
+
+	const std::string &getText() const;
+	const Date &getDate() const;
+	const Time &getStartTime() const;
+	const Time &getEndTime() const;
+	const Tags &getTags() const;
+	bool hasTag(const std::string &tag) const;
+
+	int id() const;
+	Day *day();
+
+  private:
+	void onChange();
+
+	static int nextId;
+	int id_ = nextId++;
+	Day *day_;
+	EventData data;
+	std::vector<std::unique_ptr<TaskItem>> tasks_;
+	BaseSource *source_;
+};
+} // namespace mirai

external/mirai-core-old/include/mirai-core/EventEmitter.h

@@ -0,0 +1,28 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include <functional>
+#include <vector>
+
+template <typename T> class EventEmitter
+{
+
+  public:
+	void registerCallback(std::function<T> func)
+	{
+		callbacks.push_back(func);
+	}
+
+	void emit(T data)
+	{
+		for (auto &callback : callbacks) {
+			callback(data);
+		}
+	}
+
+  private:
+	std::vector<std::function<T>> callbacks;
+};

external/mirai-core-old/include/mirai-core/Mirai.h

@@ -0,0 +1,45 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include "BaseFileSource.h"
+#include "BaseSource.h"
+#include "TaskItem.h"
+#include "TodoMd.h"
+#include <algorithm>
+#include <functional>
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace mirai
+{
+
+class Mirai
+{
+
+  public:
+	void loadSource(std::unique_ptr<BaseSource> &&resource);
+	void unloadAllSources();
+	void save();
+	void deleteTask(const TaskItem &taskItem);
+	std::optional<std::reference_wrapper<Source>> getSourceByName(const std::string &name);
+
+	std::vector<std::unique_ptr<BaseSource>> &getSources();
+	const std::vector<std::string> &getTags();
+
+	void reloadTags();
+
+	// Returns a non owning pointer to the requested resource or nullptr if not found.
+	BaseSource *getSourceById(int id);
+
+  private:
+	std::vector<std::unique_ptr<BaseSource>> sources_;
+	std::vector<std::string> tags_;
+};
+} // namespace mirai

external/mirai-core-old/include/mirai-core/TaskItem.h

@@ -13,7 +13,7 @@
 namespace mirai
 {
 
-class BaseSource;
+class SourceDataProvider;
 class Day;
 
 enum TaskItemState { TODO, DONE };
@@ -27,7 +27,7 @@ struct TaskItemData {
 class TaskItem
 {
   public:
-	TaskItem(BaseSource *source, Day *day, const TaskItemData data);
+	TaskItem(SourceDataProvider *source, Day *day, const TaskItemData data);
 
 	TaskItem &operator=(const TaskItemData &newData);
 
@@ -43,7 +43,7 @@ class TaskItem
 	bool hasTag(const std::string &tag) const;
 
 	int id() const;
-	BaseSource *source();
+	SourceDataProvider *source();
 	Day *day();
 
   private:
@@ -53,7 +53,7 @@ class TaskItem
 	int id_ = nextId++;
 	TaskItemData data;
 
-	BaseSource *source_;
+	SourceDataProvider *source_;
 	Day *day_;
 };
 

external/mirai-core-old/include/mirai-core/using.h

@@ -0,0 +1,16 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace mirai
+{
+using Tags = std::vector<std::string>;
+}

external/mirai-core-old/include/mirai-core/utils.h

@@ -0,0 +1,22 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <cctype>
+#include <cpp-utils/string.h>
+#include <cpp-utils/vector.h>
+#include <locale>
+#include <regex>
+
+namespace mirai
+{
+namespace stringUtils = cpputils::string;
+namespace vectorUtils = cpputils::vector;
+
+bool isDate(const std::string &dateStr);
+} // namespace mirai

external/mirai-core-old/src/Config.cpp

@@ -0,0 +1,30 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "Config.h"
+#include "ConfigImpl.h"
+#include "nlohmann/json.hpp"
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace mirai
+{
+
+Config::~Config() = default;
+
+Config::Config(const std::string &path) : impl_(new ConfigImpl(path))
+{
+}
+
+std::vector<std::string> Config::sources() const
+{
+	return impl_->sources();
+}
+
+}; // namespace mirai

external/mirai-core-old/src/ConfigImpl.cpp

@@ -0,0 +1,48 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "ConfigImpl.h"
+#include "nlohmann/json.hpp"
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace mirai
+{
+ConfigImpl::ConfigImpl(const std::string &path) : path_(path)
+{
+	std::ifstream file(path_);
+	if (!file) {
+		configJson_ = nlohmann::json::parse(R"(
+			{
+				"files": []
+			}
+		)");
+		return;
+	}
+	configJson_ = nlohmann::json::parse(file);
+}
+
+std::vector<std::string> ConfigImpl::sources() const
+{
+	std::vector<std::string> sources;
+	assert(configJson_.is_object());
+	assert(configJson_["files"].is_array());
+	auto jsonSources = configJson_["files"];
+	for (const auto &filePath : jsonSources) {
+		assert(filePath.is_string());
+		sources.push_back(filePath.get<std::string>());
+	}
+	return sources;
+}
+
+std::string ConfigImpl::path() const
+{
+	return path_;
+}
+
+}; // namespace mirai

external/mirai-core-old/src/ConfigImpl.h

@@ -0,0 +1,27 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include "nlohmann/json.hpp"
+#include <string>
+
+namespace mirai
+{
+
+class ConfigImpl
+{
+  public:
+	ConfigImpl(const std::string &path);
+
+	std::vector<std::string> sources() const;
+	std::string path() const;
+
+  private:
+	std::string path_;
+	nlohmann::json configJson_;
+};
+} // namespace mirai

external/mirai-core-old/src/DateTime.cpp

@@ -0,0 +1,105 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "DateTime.h"
+#include <charconv>
+#include <optional>
+#include <ranges>
+#include <string>
+#include <vector>
+
+namespace mirai
+{
+
+std::optional<mirai::Date> stringToDate(const std::string &dateStr)
+{
+	using std::operator""sv;
+
+	auto dateSplitView =
+		dateStr | std::views::split("-"sv) | std::views::transform([](auto v) -> int {
+			int i = 0;
+			std::from_chars(v.data(), v.data() + v.size(), i);
+			return i;
+		});
+	std::vector<int> dateSplit{dateSplitView.begin(), dateSplitView.end()};
+	if (dateSplit.size() != 3) {
+		return std::nullopt;
+	}
+
+	auto year = dateSplit[0];
+	auto month = dateSplit[1];
+	auto day = dateSplit[2];
+	return mirai::Date(year, static_cast<unsigned>(month), static_cast<unsigned>(day));
+}
+
+Date::Date(int year, unsigned month, unsigned day) : year(year), month(month), day(day)
+{
+}
+
+Date::Date(std::chrono::time_point<std::chrono::system_clock> tp)
+{
+	auto chronoDate = std::chrono::year_month_day(std::chrono::floor<std::chrono::days>(tp));
+	year = static_cast<int>(chronoDate.year());
+	month = static_cast<unsigned>(chronoDate.month());
+	day = static_cast<unsigned>(chronoDate.day());
+}
+
+Date::Date(std::chrono::year_month_day chronoDate)
+{
+	year = static_cast<int>(chronoDate.year());
+	month = static_cast<unsigned>(chronoDate.month());
+	day = static_cast<unsigned>(chronoDate.day());
+}
+
+int year;
+unsigned month;
+unsigned day;
+
+bool Date::operator==(const Date &other) const
+{
+	return other.year == year && other.month == month && other.day == day;
+}
+
+bool Date::operator<(const Date &other) const
+{
+	if (year < other.year) {
+		return true;
+	}
+	if (year == other.year && month < other.month) {
+		return true;
+	}
+	if (year == other.year && month == other.month && day < other.day) {
+		return true;
+	}
+	return false;
+}
+
+bool Date::operator>(const Date &other) const
+{
+	return !(*this < other) && !(*this == other);
+}
+
+bool Time::operator==(const Time &other) const
+{
+	return other.hour == hour && other.minute == minute;
+}
+
+bool Time::operator<(const Time &other) const
+{
+	if (hour < other.hour) {
+		return true;
+	}
+	if (hour == other.hour && minute < other.minute) {
+		return true;
+	}
+	return false;
+}
+
+bool Time::operator>(const Time &other) const
+{
+	return !(*this < other) && !(*this == other);
+}
+} // namespace mirai

external/mirai-core-old/src/Day.cpp

@@ -0,0 +1,126 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "Day.h"
+#include "BaseSource.h"
+#include "TaskItem.h"
+#include <algorithm>
+#include <iostream>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <vector>
+
+namespace mirai
+{
+
+Day::Day(BaseSource *source, const DayData &data) : source_(source), data_(data)
+{
+}
+
+Event *Day::createEvent(const EventData &eventData)
+{
+	auto event = std::make_unique<Event>(source_, this, eventData);
+	mirai::Event *eventPtr = event.get();
+	events_.push_back(std::move(event));
+	onChange();
+	return eventPtr;
+}
+
+std::vector<std::unique_ptr<Event>> *Day::events()
+{
+	return &events_;
+}
+
+const Date &Day::getDate() const
+{
+	return data_.date;
+}
+
+TaskItem *Day::createTask(const TaskItemData &taskData)
+{
+	auto task = std::make_unique<TaskItem>(source_, this, taskData);
+	mirai::TaskItem *taskPtr = task.get();
+	tasks_.push_back(std::move(task));
+	onChange();
+	return taskPtr;
+}
+
+void Day::insertTask(std::unique_ptr<TaskItem> &&task)
+{
+	tasks_.push_back(std::move(task));
+	onChange();
+}
+
+void Day::deleteTask(const TaskItem &taskToDelete)
+{
+	int id = taskToDelete.id();
+	tasks_.erase(
+		std::remove_if(
+			tasks_.begin(), tasks_.end(),
+			[&](const std::unique_ptr<TaskItem> &task) {
+				return task->id() == id;
+			}
+		),
+		tasks_.end()
+	);
+	onChange();
+}
+
+std::optional<std::unique_ptr<TaskItem>> Day::takeTask(const TaskItem &taskToDelete)
+{
+	auto taskIterator = std::ranges::find_if(tasks_, [&](const auto &task) {
+		return task->id() == taskToDelete.id();
+	});
+	if (taskIterator == tasks_.end()) {
+		return std::nullopt;
+	}
+	auto task = std::move(*taskIterator);
+	tasks_.erase(taskIterator);
+	onChange();
+	return task;
+}
+
+void Day::deleteEvent(const Event &eventToDelete)
+{
+	int id = eventToDelete.id();
+	events_.erase(
+		std::remove_if(
+			events_.begin(), events_.end(),
+			[&](const std::unique_ptr<Event> &event) {
+				return event->id() == id;
+			}
+		),
+		events_.end()
+	);
+	onChange();
+}
+
+void Day::onChange()
+{
+	source()->setDirty(true);
+}
+
+std::vector<std::unique_ptr<TaskItem>> *Day::tasks()
+{
+	return &tasks_;
+}
+
+Event *Day::getEventById(int eventId)
+{
+	for (auto &event : events_) {
+		if (event->id() == eventId) {
+			return event.get();
+		}
+	}
+	return nullptr;
+}
+
+BaseSource *Day::source()
+{
+	return source_;
+}
+} // namespace mirai

external/mirai-core-old/src/Event.cpp

@@ -0,0 +1,116 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "Event.h"
+#include "BaseSource.h"
+#include "TaskItem.h"
+#include "utils.h"
+
+namespace mirai
+{
+
+Event::Event(BaseSource *source, Day *parent, const EventData &data)
+	: source_(source), day_(parent), data(data)
+{
+}
+
+void Event::setText(const std::string &text)
+{
+	this->data.description = text;
+	onChange();
+}
+
+const std::string &Event::getText() const
+{
+	return data.description;
+}
+
+const Date &Event::getDate() const
+{
+	return data.date;
+}
+
+const Time &Event::getStartTime() const
+{
+	return data.startTime;
+}
+
+const Time &Event::getEndTime() const
+{
+	return data.endTime;
+}
+
+const Tags &Event::getTags() const
+{
+	return data.tags;
+}
+
+bool Event::hasTag(const std::string &tag) const
+{
+	return vectorUtils::contains(data.tags, tag);
+}
+
+TaskItem *Event::createTask(const TaskItemData &taskData)
+{
+	auto task = std::make_unique<TaskItem>(source_, day_, taskData);
+	mirai::TaskItem *taskPtr = task.get();
+	tasks_.push_back(std::move(task));
+	onChange();
+	return taskPtr;
+}
+
+void Event::deleteTask(const TaskItem &taskToDelete)
+{
+	tasks_.erase(std::remove_if(
+		tasks_.begin(), tasks_.end(),
+		[&](const std::unique_ptr<TaskItem> &task) {
+			return task->id() == taskToDelete.id();
+		}
+	));
+}
+
+std::vector<std::unique_ptr<TaskItem>> *Event::tasks()
+{
+	return &tasks_;
+}
+
+void Event::setStartTime(const Time &time)
+{
+	data.startTime = time;
+	onChange();
+}
+
+void Event::setEndTime(const Time &time)
+{
+	data.endTime = time;
+	onChange();
+}
+
+void Event::onChange()
+{
+	source_->setDirty(true);
+}
+
+Event &Event::operator=(const EventData &newData)
+{
+	data = newData;
+	onChange();
+	return *this;
+};
+
+int Event::id() const
+{
+	return id_;
+}
+
+Day *Event::day()
+{
+	return day_;
+}
+
+int Event::nextId = 0;
+
+} // namespace mirai

external/mirai-core-old/src/EventEmitter.cpp

@@ -0,0 +1,7 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "EventEmitter.h"

external/mirai-core-old/src/Mirai.cpp

@@ -0,0 +1,100 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "Mirai.h"
+#include "Config.h"
+#include "TaskItem.h"
+#include "cpp-utils/debug.h"
+#include "utils.h"
+#include <algorithm>
+#include <iostream>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <vector>
+
+namespace mirai
+{
+
+void Mirai::loadSource(std::unique_ptr<BaseSource> &&resource)
+{
+	resource->load();
+	sources_.push_back(std::move(resource));
+	reloadTags();
+};
+
+void Mirai::unloadAllSources()
+{
+	sources_.clear();
+}
+
+void Mirai::save()
+{
+	for (auto &resource : sources_) {
+		if (resource->isDirty()) {
+			resource->save();
+			resource->setDirty(false);
+		}
+	}
+	reloadTags();
+}
+
+void Mirai::deleteTask(const TaskItem &taskItem)
+{
+	for (auto &resource : sources_) {
+		resource->deleteTask(taskItem);
+	}
+}
+
+std::vector<std::unique_ptr<BaseSource>> &Mirai::getSources()
+{
+	return sources_;
+}
+
+std::optional<std::reference_wrapper<BaseSource>> Mirai::getSourceByName(const std::string &name)
+{
+	auto resourceIterator =
+		std::ranges::find_if(sources_, [&](const std::unique_ptr<BaseSource> &resource) {
+			return resource->getName() == name;
+		});
+
+	if (resourceIterator == sources_.end()) {
+		return std::nullopt;
+	}
+	return *(resourceIterator->get());
+}
+
+const std::vector<std::string> &Mirai::getTags()
+{
+	return tags_;
+}
+
+void Mirai::reloadTags()
+{
+	// TODO TAGS
+	/*cpputils::debug::Timer reloadingTagsDuration;*/
+	/*tags.clear();*/
+	/*for (auto &resource : resources) {*/
+	/*for (auto &task : resource->getTasks()) {*/
+	/*for (auto &tag : task->getTags()) {*/
+	/*if (!vectorUtils::contains(tags, tag)) {*/
+	/*tags.push_back(tag);*/
+	/*}*/
+	/*}*/
+	/*}*/
+	/*}*/
+	/*reloadingTagsDuration.printTimeElapsed("ReloadingTags");*/
+}
+
+BaseSource *Mirai::getSourceById(int id)
+{
+	if (id >= sources_.size()) {
+		return nullptr;
+	}
+	return sources_.at(id).get();
+}
+
+} // namespace mirai

external/mirai-core-old/src/utils.cpp

@@ -0,0 +1,38 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "utils.h"
+#include <cctype>
+
+namespace mirai
+{
+bool isDate(const std::string &dateStr)
+{
+	// std regex are really slow
+	/*std::regex regex("[0-9]{4}-[0-9]{2}-[0-9]{2}");*/
+	/*return std::regex_match(dateStr, regex);*/
+
+	// Quick hand made check instead of regex until I rework date to use timestamp or std::chrono
+	if (dateStr.length() != 10) {
+		return false;
+	}
+
+	if (dateStr[4] != '-' || dateStr[7] != '-') {
+		return false;
+	}
+
+	for (int i = 0; i < dateStr.length(); ++i) {
+		if (i == 4 || i == 7) {
+			// These are the '-' characters
+			continue;
+		}
+		if (!isdigit(dateStr[i])) {
+			return false;
+		}
+	}
+	return true;
+}
+} // namespace mirai

external/mirai-core/CMakeLists.txt

@@ -9,15 +9,15 @@ add_library(mirai-core
 	src/Mirai.cpp
 	src/Config.cpp
 	src/ConfigImpl.cpp
-	src/TaskItem.cpp
+	src/Task.cpp
 	src/Day.cpp
 	src/Event.cpp
 	src/DateTime.cpp
 	src/EventEmitter.cpp 
-	src/BaseSource.cpp 
-	src/StdFileSource.cpp 
-	src/TasksView.cpp
-	src/TodoMd.cpp
+	src/Source.cpp 
+	src/MarkdownDataProvider.cpp 
+	src/MarkdownDataProvider.Parser.cpp 
+	src/View.cpp
 	src/utils.cpp
 )
 

external/mirai-core/include/mirai-core/DateTime.h

@@ -24,6 +24,8 @@ struct Date {
 	bool operator==(const Date &other) const;
 	bool operator<(const Date &other) const;
 	bool operator>(const Date &other) const;
+	bool operator>=(const Date &other) const;
+	bool operator<=(const Date &other) const;
 
 	std::chrono::year_month_day toStdChrono() const
 	{
@@ -34,6 +36,11 @@ struct Date {
 		};
 	}
 
+	int toIntRepresentation()
+	{
+		return day + month * 100 + year * 10000;
+	}
+
 	int year;
 	unsigned month;
 	unsigned day;

external/mirai-core/include/mirai-core/Day.h

@@ -6,49 +6,33 @@
 
 #pragma once
 
-#include "DateTime.h"
-#include "Event.h"
-#include "TaskItem.h"
-#include "using.h"
-#include <memory>
-#include <string>
+#include "SourceDataProvider.h"
 #include <vector>
 
 namespace mirai
 {
 
-class BaseSource;
-
-struct DayData {
-	Date date;
-	std::vector<EventData> events;
-	std::vector<TaskItemData> tasks;
-};
+class Task;
+class Event;
 
 class Day
 {
+
   public:
-	Day(BaseSource *source, const DayData &data);
-	void setDate(const Date &date);
+	Day(SourceDataProvider *data, DayData day) : data_(data), dayData_(day) {};
 
-	Event *createEvent(const EventData &eventData);
-	TaskItem *createTask(const TaskItemData &taskData);
-	void deleteTask(const TaskItem &taskToDelete);
-	void deleteEvent(const Event &eventToDelete);
-	std::vector<std::unique_ptr<Event>> *events();
-	std::vector<std::unique_ptr<TaskItem>> *tasks();
+	Date date() const;
+	std::vector<Task> tasks();
+	std::vector<Event> events();
 
-	const Date &getDate() const;
+	void mergeDay(const Day &otherDay);
 
-	Event *getEventById(int eventId);
-	BaseSource *source();
+	int id() const;
+	int sourceId() const;
 
   private:
-	void onChange();
-
-	BaseSource *source_;
-	std::vector<std::unique_ptr<Event>> events_;
-	std::vector<std::unique_ptr<TaskItem>> tasks_;
-	DayData data_;
+	DayData dayData_;
+	SourceDataProvider *data_;
 };
+
 } // namespace mirai

external/mirai-core/include/mirai-core/Event.h

@@ -6,63 +6,39 @@
 
 #pragma once
 
-#include "DateTime.h"
-#include "TaskItem.h"
-#include "using.h"
-#include <memory>
+#include "Day.h"
+#include "SourceDataProvider.h"
 #include <string>
 #include <vector>
 
 namespace mirai
 {
 
-class BaseSource;
-
-struct EventData {
-	std::string description;
-	Date date;
-	Time startTime;
-	Time endTime;
-	Tags tags;
-	std::vector<TaskItemData> tasks;
-};
-
-class Day;
+class Task;
 
 class Event
 {
-  private:
+
   public:
-	Event(BaseSource *source, Day *parent, const EventData &data);
+	Event(SourceDataProvider *data, EventData eventData) : data_(data), eventData_(eventData) {};
 
-	Event &operator=(const EventData &newData);
+	std::string title() const;
+	Time startsAt() const;
+	Time endsAt() const;
 
-	void setText(const std::string &text);
+	std::vector<Task> queryTasks() const;
+
+	void setTitle(const std::string &newTitle);
+	void setDay(const Day &day);
 	void setStartTime(const Time &time);
 	void setEndTime(const Time &time);
 
-	TaskItem *createTask(const TaskItemData &taskData);
-	void deleteTask(const TaskItem &taskToDelete);
-	std::vector<std::unique_ptr<TaskItem>> *tasks();
-
-	const std::string &getText() const;
-	const Date &getDate() const;
-	const Time &getStartTime() const;
-	const Time &getEndTime() const;
-	const Tags &getTags() const;
-	bool hasTag(const std::string &tag) const;
-
 	int id() const;
-	Day *day();
+	int sourceId() const;
 
   private:
-	void onChange();
-
-	static int nextId;
-	int id_ = nextId++;
-	Day *day_;
-	EventData data;
-	std::vector<std::unique_ptr<TaskItem>> tasks_;
-	BaseSource *source_;
+	EventData eventData_;
+	SourceDataProvider *data_;
 };
+
 } // namespace mirai

external/mirai-core/include/mirai-core/MarkdownDataProvider.h

@@ -0,0 +1,76 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include "DateTime.h"
+#include "SourceDataProvider.h"
+#include <algorithm>
+#include <fstream>
+#include <iterator>
+#include <optional>
+#include <ranges>
+#include <string>
+#include <vector>
+
+namespace mirai
+{
+
+struct MarkdownData {
+	std::string name;
+	std::vector<TaskData> tasks;
+	std::vector<DayData> days;
+	std::vector<EventData> events;
+};
+
+class MarkdownDataProvider : public SourceDataProvider
+{
+  public:
+	MarkdownDataProvider(const std::string &filePath) : filePath_(filePath), SourceDataProvider()
+	{
+	}
+
+	std::string toMarkdown();
+	MarkdownData parseMarkdown(const std::string &content);
+
+	void save() override;
+	void load() override;
+
+	std::string name() const override;
+
+	// Tasks
+	TaskData insertTask(const TaskData &task) override;
+	void removeTaskById(int taskId) override;
+	std::optional<TaskData> getTaskById(int taskId) override;
+	std::vector<TaskData> getTasksByEventId(int eventId) override;
+	std::vector<TaskData> getTasksByDayId(int dayId) override;
+	std::vector<TaskData> getTasksByDate(Date date) override;
+	std::vector<TaskData> getTasksWithoutDate() override;
+	std::vector<TaskData> getTasks() override;
+	void updateTask(int taskId, UpdatableTaskData updateData) override;
+
+	// Events
+	EventData insertEvent(const EventData &task) override;
+	void removeEventById(int eventId) override;
+	std::optional<EventData> getEventById(int eventId) override;
+	std::vector<EventData> getEvents() override;
+	std::vector<EventData> getEventsByDate(Date date) override;
+	void updateEvent(int eventId, UpdatableEventData updateData) override;
+
+	// Days
+	DayData insertDay(const DayData &day) override;
+	void removeDayById(int dayId) override;
+	std::vector<DayData> getDays() override;
+	std::optional<DayData> getDayByDate(const Date &date) override;
+	void updateDay(int dayId, UpdatableDayData updateData) override;
+
+  private:
+	std::string name_;
+	std::string filePath_;
+	MarkdownData data;
+};
+
+} // namespace mirai

external/mirai-core/include/mirai-core/Mirai.h

@@ -6,13 +6,8 @@
 
 #pragma once
 
-#include "BaseFileSource.h"
-#include "BaseSource.h"
-#include "TaskItem.h"
-#include "TodoMd.h"
-#include <algorithm>
+#include "Source.h"
 #include <functional>
-#include <map>
 #include <memory>
 #include <optional>
 #include <string>
@@ -24,22 +19,20 @@ class Mirai
 {
 
   public:
-	void loadSource(std::unique_ptr<BaseSource> &&resource);
+	void loadSource(std::unique_ptr<SourceDataProvider> &&resource);
 	void unloadAllSources();
 	void save();
-	void deleteTask(const TaskItem &taskItem);
-	std::optional<std::reference_wrapper<BaseSource>> getSourceByName(const std::string &name);
+	std::optional<std::reference_wrapper<SourceDataProvider>>
+	getSourceByName(const std::string &name);
 
-	std::vector<std::unique_ptr<BaseSource>> &getSources();
+	std::vector<std::unique_ptr<Source>> &getSources();
 	const std::vector<std::string> &getTags();
 
-	void reloadTags();
-
 	// Returns a non owning pointer to the requested resource or nullptr if not found.
-	BaseSource *getSourceById(int id);
+	Source *getSourceById(int id);
 
   private:
-	std::vector<std::unique_ptr<BaseSource>> sources_;
-	std::vector<std::string> tags_;
+	std::vector<std::unique_ptr<Source>> sources_;
+	// std::vector<std::string> tags_;
 };
 } // namespace mirai

external/mirai-core/include/mirai-core/Source.h

@@ -0,0 +1,89 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include "DateTime.h"
+#include "Day.h"
+#include "Event.h"
+#include "SourceDataProvider.h"
+#include "Task.h"
+#include <string>
+#include <vector>
+
+namespace mirai
+{
+
+struct createTaskParams {
+	std::string title;
+	std::optional<Event> event;
+	std::optional<Date> date;
+};
+
+struct createEventParams {
+	std::string title;
+	Date date;
+	Time startsAt;
+	Time endsAt;
+};
+
+struct SourceConstructor {
+	SourceDataProvider *sourceDataProvider;
+};
+
+class Source
+{
+  public:
+	Source(SourceConstructor params) : data(params.sourceDataProvider)
+	{
+	}
+
+	Source(Source &) = delete;
+	Source(Source &&) = delete;
+	Source operator=(Source &) = delete;
+	Source operator=(Source &&) = delete;
+
+	~Source() = default;
+
+	void init();
+	void save();
+	void load();
+
+	std::string name() const;
+
+	void createTask(const createTaskParams &task);
+	void removeTask(const Task &task);
+	std::optional<Task> getTaskById(int taskId);
+	std::vector<Task> getTasksByDate(Date date);
+	std::vector<Task> getUnscheduledTasks();
+	std::vector<Task> getTasks();
+
+	void createEvent(const createEventParams &eventToCreate);
+	void removeEvent(const Event &event);
+	std::vector<Event> getEvents();
+	std::optional<Event> getEventById(int eventId);
+	std::vector<Event> getEventsByDate(Date date);
+
+	std::vector<Day> getDays();
+	std::optional<Day> getDayByDate(Date date);
+
+	const int id = Source::generateNextId();
+
+	bool isDirty() const
+	{
+		return data->isDirty();
+	};
+
+  private:
+	static int generateNextId()
+	{
+		static int nextId = 0;
+		return nextId++;
+	}
+
+	SourceDataProvider *data;
+};
+} // namespace mirai

external/mirai-core/include/mirai-core/SourceDataProvider.h

@@ -0,0 +1,120 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include "DateTime.h"
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace mirai
+{
+
+struct DayData {
+	int id;
+	Date date;
+};
+
+struct UpdatableDayData {
+	std::optional<Date> date;
+};
+
+enum TaskState { TODO, DONE };
+
+struct TaskData {
+	int id;
+	std::string title;
+	TaskState state;
+	std::optional<int> dayId;
+	std::optional<int> eventId;
+};
+
+struct UpdatableTaskData {
+	std::optional<std::string> title = std::nullopt;
+	std::optional<TaskState> state = std::nullopt;
+	std::optional<std::optional<int>> dayId = std::nullopt;
+	std::optional<std::optional<int>> eventId = std::nullopt;
+};
+
+struct EventData {
+	int id;
+	int dayId;
+	std::string title;
+	Time startsAt;
+	Time endsAt;
+};
+
+struct UpdatableEventData {
+	std::optional<int> dayId;
+	std::optional<std::string> title;
+	std::optional<Time> startsAt;
+	std::optional<Time> endsAt;
+};
+
+class SourceDataProvider
+{
+
+  public:
+	SourceDataProvider() {};
+	SourceDataProvider(SourceDataProvider &) = delete;
+	SourceDataProvider(SourceDataProvider &&) = delete;
+
+	virtual ~SourceDataProvider() = default;
+	virtual void save() = 0;
+	virtual void load() = 0;
+
+	virtual std::string name() const = 0;
+
+	// Tasks
+	virtual TaskData insertTask(const TaskData &task) = 0;
+	virtual void removeTaskById(int taskId) = 0;
+	virtual std::optional<TaskData> getTaskById(int taskId) = 0;
+	virtual std::vector<TaskData> getTasksByEventId(int eventId) = 0;
+	virtual std::vector<TaskData> getTasksByDayId(int dayId) = 0;
+	virtual std::vector<TaskData> getTasksByDate(Date date) = 0;
+	virtual std::vector<TaskData> getTasksWithoutDate() = 0;
+	virtual std::vector<TaskData> getTasks() = 0;
+	virtual void updateTask(int taskId, UpdatableTaskData updateData) = 0;
+
+	// Events
+	virtual EventData insertEvent(const EventData &task) = 0;
+	virtual void removeEventById(int eventId) = 0;
+	virtual std::optional<EventData> getEventById(int eventId) = 0;
+	virtual std::vector<EventData> getEvents() = 0;
+	virtual std::vector<EventData> getEventsByDate(Date date) = 0;
+	virtual void updateEvent(int eventId, UpdatableEventData updateData) = 0;
+
+	// Days
+	virtual DayData insertDay(const DayData &day) = 0;
+	virtual void removeDayById(int dayId) = 0;
+	virtual std::vector<DayData> getDays() = 0;
+	virtual std::optional<DayData> getDayByDate(const Date &date) = 0;
+	virtual void updateDay(int dayId, UpdatableDayData updateData) = 0;
+
+	const int id = SourceDataProvider::generateNextId();
+
+	void setDirty(bool dirty)
+	{
+		isDirty_ = dirty;
+	};
+
+	bool isDirty() const
+	{
+		return isDirty_;
+	};
+
+  private:
+	bool isDirty_ = false;
+
+	static int generateNextId()
+	{
+		static int nextId = 0;
+		return nextId++;
+	}
+};
+
+} // namespace mirai

external/mirai-core/include/mirai-core/Task.h

@@ -0,0 +1,41 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include "Event.h"
+#include "SourceDataProvider.h"
+#include <string>
+
+namespace mirai
+{
+
+class Day;
+
+class Task
+{
+
+  public:
+	Task(SourceDataProvider *data, TaskData task) : data_(data), task_(task) {};
+
+	std::string title() const;
+	mirai::TaskState state() const;
+	bool checked() const;
+
+	void setTitle(const std::string &newTitle);
+	void setDay(const Day &day);
+	void setEvent(const Event &event);
+	void setChecked(bool checked);
+
+	int id() const;
+	int sourceId() const;
+
+  private:
+	TaskData task_;
+	SourceDataProvider *data_;
+};
+
+} // namespace mirai

external/mirai-core/include/mirai-core/View.h

@@ -0,0 +1,58 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+#include "Mirai.h"
+#include "Task.h"
+#include <algorithm>
+#include <iterator>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace mirai
+{
+
+struct DateView {
+	std::vector<Task> tasks;
+	std::vector<Event> events;
+};
+
+class View
+{
+
+  public:
+	View(Mirai *mirai);
+
+	void hideCompletedTasks(bool hide);
+	bool shouldHideCompletedTasks() const;
+
+	std::vector<Date> getDates();
+
+	std::vector<Task> getTasksForDate(const Date &date);
+	std::vector<Event> getEventsForDate(const Date &date);
+	std::vector<Task> getUnscheduledTasks();
+
+	void update();
+
+	void removeSources();
+	void addSource(const Source &source);
+	void setSources(const std::vector<Source> &sources);
+	void setAllSources();
+	bool isSourceSelected(const Source &source) const;
+
+	size_t activeSourceCount() const;
+
+  private:
+	Mirai *mirai_;
+	std::vector<int> sourcesIds_;
+	std::vector<Task> unscheduledTasks_;
+	std::map<Date, DateView> dates;
+
+	bool shouldHideCompletedTasks_ = true;
+};
+} // namespace mirai

external/mirai-core/include/mirai-core/utils.h

@@ -6,12 +6,11 @@
 
 #pragma once
 
-#include <algorithm>
 #include <cctype>
 #include <cpp-utils/string.h>
 #include <cpp-utils/vector.h>
-#include <locale>
-#include <regex>
+#include <functional>
+#include <optional>
 
 namespace mirai
 {
@@ -19,4 +18,33 @@ namespace stringUtils = cpputils::string;
 namespace vectorUtils = cpputils::vector;
 
 bool isDate(const std::string &dateStr);
+
+template <typename T, typename F> T *ptrFindFirst(std::vector<T> &container, F f)
+{
+	auto element = std::ranges::find_if(container, f);
+	if (element == container.end()) {
+		return nullptr;
+	}
+	return &(*element);
+}
+
+// TODO use ref for container first arg
+template <typename T, typename F> std::optional<T> findFirst(std::vector<T> container, F f)
+{
+	auto element = std::ranges::find_if(container, f);
+	if (element == container.end()) {
+		return std::nullopt;
+	}
+	return *element;
+}
+
+template <typename T, typename F> std::vector<T> findAll(std::vector<T> container, F f)
+{
+	std::vector<T> result;
+	std::ranges::copy_if(container, std::back_inserter(result), f);
+	return result;
+}
+
+int generateUniqueId();
+
 } // namespace mirai

external/mirai-core/src/DateTime.cpp

@@ -82,6 +82,16 @@ bool Date::operator>(const Date &other) const
 	return !(*this < other) && !(*this == other);
 }
 
+bool Date::operator>=(const Date &other) const
+{
+	return (*this > other) || (*this == other);
+}
+
+bool Date::operator<=(const Date &other) const
+{
+	return (*this < other) || (*this == other);
+}
+
 bool Time::operator==(const Time &other) const
 {
 	return other.hour == hour && other.minute == minute;

external/mirai-core/src/Day.cpp

@@ -5,100 +5,56 @@
  */
 
 #include "Day.h"
-#include "BaseSource.h"
+#include "Task.h"
 #include <algorithm>
-#include <iostream>
-#include <memory>
-#include <ostream>
-#include <vector>
+#include <stdexcept>
 
 namespace mirai
 {
 
-Day::Day(BaseSource *source, const DayData &data) : source_(source), data_(data)
+int Day::id() const
 {
+	return dayData_.id;
 }
 
-Event *Day::createEvent(const EventData &eventData)
+int Day::sourceId() const
 {
-	auto event = std::make_unique<Event>(source_, this, eventData);
-	mirai::Event *eventPtr = event.get();
-	events_.push_back(std::move(event));
-	onChange();
-	return eventPtr;
+	return data_->id;
 }
 
-std::vector<std::unique_ptr<Event>> *Day::events()
+Date Day::date() const
 {
-	return &events_;
+	return dayData_.date;
 }
 
-const Date &Day::getDate() const
+std::vector<Task> Day::tasks()
 {
-	return data_.date;
-}
-
-TaskItem *Day::createTask(const TaskItemData &taskData)
-{
-	auto task = std::make_unique<TaskItem>(source_, this, taskData);
-	mirai::TaskItem *taskPtr = task.get();
-	tasks_.push_back(std::move(task));
-	onChange();
-	return taskPtr;
-}
-
-void Day::deleteTask(const TaskItem &taskToDelete)
-{
-	int id = taskToDelete.id();
-	tasks_.erase(
-		std::remove_if(
-			tasks_.begin(), tasks_.end(),
-			[&](const std::unique_ptr<TaskItem> &task) {
-				return task->id() == id;
-			}
-		),
-		tasks_.end()
-	);
-	onChange();
-}
-
-void Day::deleteEvent(const Event &eventToDelete)
-{
-	int id = eventToDelete.id();
-	events_.erase(
-		std::remove_if(
-			events_.begin(), events_.end(),
-			[&](const std::unique_ptr<Event> &event) {
-				return event->id() == id;
-			}
-		),
-		events_.end()
-	);
-	onChange();
-}
-
-void Day::onChange()
-{
-	source()->setDirty(true);
-}
-
-std::vector<std::unique_ptr<TaskItem>> *Day::tasks()
-{
-	return &tasks_;
-}
-
-Event *Day::getEventById(int eventId)
-{
-	for (auto &event : events_) {
-		if (event->id() == eventId) {
-			return event.get();
+	auto tasksData = data_->getTasksByDayId(id());
+	std::vector<Task> tasks;
+	std::transform(
+		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
+		[&](const TaskData &taskData) {
+			return Task{data_, taskData};
 		}
-	}
-	return nullptr;
+	);
+	return tasks;
 }
 
-BaseSource *Day::source()
+std::vector<Event> Day::events()
 {
-	return source_;
+	auto eventsData = data_->getEventsByDate(dayData_.date);
+	std::vector<Event> events;
+	std::transform(
+		eventsData.begin(), eventsData.end(), std::back_inserter(events),
+		[&](const EventData &eventData) {
+			return Event{data_, eventData};
+		}
+	);
+	return events;
+}
+
+void Day::mergeDay(const Day &otherDay)
+{
+	throw std::runtime_error("Not implemented yet");
 }
 } // namespace mirai

external/mirai-core/src/Event.cpp

@@ -5,112 +5,67 @@
  */
 
 #include "Event.h"
-#include "BaseSource.h"
-#include "TaskItem.h"
-#include "utils.h"
+#include "Task.h"
+#include <string>
 
 namespace mirai
 {
 
-Event::Event(BaseSource *source, Day *parent, const EventData &data)
-	: source_(source), day_(parent), data(data)
+int Event::id() const
 {
+	return eventData_.id;
 }
 
-void Event::setText(const std::string &text)
+int Event::sourceId() const
 {
-	this->data.description = text;
-	onChange();
+	return data_->id;
 }
 
-const std::string &Event::getText() const
+std::string Event::title() const
 {
-	return data.description;
+	return eventData_.title;
 }
 
-const Date &Event::getDate() const
+Time Event::startsAt() const
 {
-	return data.date;
+	return eventData_.startsAt;
 }
 
-const Time &Event::getStartTime() const
+Time Event::endsAt() const
 {
-	return data.startTime;
+	return eventData_.endsAt;
 }
 
-const Time &Event::getEndTime() const
+std::vector<Task> Event::queryTasks() const
 {
-	return data.endTime;
-}
-
-const Tags &Event::getTags() const
-{
-	return data.tags;
-}
-
-bool Event::hasTag(const std::string &tag) const
-{
-	return vectorUtils::contains(data.tags, tag);
-}
-
-TaskItem *Event::createTask(const TaskItemData &taskData)
-{
-	auto task = std::make_unique<TaskItem>(source_, day_, taskData);
-	mirai::TaskItem *taskPtr = task.get();
-	tasks_.push_back(std::move(task));
-	onChange();
-	return taskPtr;
-}
-
-void Event::deleteTask(const TaskItem &taskToDelete)
-{
-	tasks_.erase(std::remove_if(
-		tasks_.begin(), tasks_.end(),
-		[&](const std::unique_ptr<TaskItem> &task) {
-			return task->id() == taskToDelete.id();
+	auto tasksData = data_->getTasksByEventId(eventData_.id);
+	std::vector<Task> tasks;
+	std::transform(
+		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
+		[&](const TaskData &taskData) {
+			return Task{data_, taskData};
 		}
-	));
+	);
+	return tasks;
 }
 
-std::vector<std::unique_ptr<TaskItem>> *Event::tasks()
+void Event::setTitle(const std::string &newTitle)
 {
-	return &tasks_;
+	data_->updateEvent(id(), {.title = newTitle});
+}
+
+void Event::setDay(const Day &day)
+{
+	data_->updateEvent(id(), {.dayId = day.id()});
 }
 
 void Event::setStartTime(const Time &time)
 {
-	data.startTime = time;
-	onChange();
+	data_->updateEvent(id(), {.startsAt = time});
 }
 
 void Event::setEndTime(const Time &time)
 {
-	data.endTime = time;
-	onChange();
+	data_->updateEvent(id(), {.endsAt = time});
 }
-
-void Event::onChange()
-{
-	source_->setDirty(true);
-}
-
-Event &Event::operator=(const EventData &newData)
-{
-	data = newData;
-	onChange();
-	return *this;
-};
-
-int Event::id() const
-{
-	return id_;
-}
-
-Day *Event::day()
-{
-	return day_;
-}
-
-int Event::nextId = 0;
-
 } // namespace mirai

external/mirai-core/src/MarkdownDataProvider.Parser.cpp

@@ -0,0 +1,252 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "MarkdownDataProvider.h"
+#include "cpp-utils/debug.h"
+#include "utils.h"
+#include <regex>
+
+namespace mirai
+{
+
+/*Tags TodoMdFormat::extractTagsFromMetadata(std::string metadata)*/
+/*{*/
+/*Tags tags;*/
+
+/*std::regex regex("(#([a-zA-Z0-1]+))");*/
+/*std::smatch matches;*/
+
+/*while (std::regex_search(metadata, matches, regex)) {*/
+/*if (!vectorUtils::contains(tags, matches[2].str())) {*/
+/*tags.push_back(matches[2]);*/
+/*}*/
+/*metadata = matches.suffix();*/
+/*}*/
+/*return tags;*/
+/*}*/
+
+std::string fieldWithSpace(const std::string &field)
+{
+	if (field.length() == 0) {
+		return "";
+	}
+	return (field + " ");
+}
+
+TaskData stringToTask(const std::string &str, const std::string &date)
+{
+	std::smatch matches;
+	std::regex regex("- \\[(\\s|X)\\] (([0-9]{2}:[0-9]{2})-([0-9]{2}:[0-9]{2}) > )?(.*?)( -- (.*))?"
+	);
+	std::regex_match(str, matches, regex);
+
+	/*std::cout << "line " << str << std::endl;*/
+	/*std::cout << "M 0 " << matches[0] << std::endl;*/
+	/*std::cout << "M 1 " << matches[1] << std::endl;*/
+	/*std::cout << "M 2 " << matches[2] << std::endl;*/
+	/*std::cout << "M 3 " << matches[3] << std::endl;*/
+	/*std::cout << "M 4 " << matches[4] << std::endl;*/
+	/*std::cout << "M 5 " << matches[5] << std::endl;*/
+	/*std::cout << "M 6 " << matches[6] << std::endl;*/
+	/*std::cout << "M 7 " << matches[7] << std::endl;*/
+
+	std::string text = stringUtils::trim(matches[5]);
+
+	TaskData taskItem{
+		.title = text,
+		.state = str.substr(0, 5) == "- [X]" ? DONE : TODO,
+	};
+	return taskItem;
+}
+
+Time stringToTime(const std::string &str)
+{
+	if (str.length() != 5) {
+		throw std::runtime_error("Str time length must be 5 (got '" + str + "')");
+	}
+	if (str[2] != 'h') {
+		throw std::runtime_error("Malformated time range");
+	}
+	Time time{};
+	std::from_chars(str.data(), str.data() + 2, time.hour);
+	std::from_chars(str.data() + 3, str.data() + 5, time.minute);
+
+	return time;
+}
+
+EventData stringToEvent(const std::string &str, const std::string &dateString)
+{
+	std::smatch matches;
+	std::regex regex("> (([0-9]{2}h[0-9]{2})-([0-9]{2}h[0-9]{2}) )(.*?)( -- (.*))?");
+	std::regex_match(str, matches, regex);
+
+	/*std::cout << "line " << str << std::endl;*/
+	/*std::cout << "M 0 " << matches[0] << std::endl;*/
+	/*std::cout << "M 1 " << matches[1] << std::endl;*/
+	/*std::cout << "M 2 " << matches[2] << std::endl;*/
+	/*std::cout << "M 3 " << matches[3] << std::endl;*/
+	/*std::cout << "M 4 " << matches[4] << std::endl;*/
+	/*std::cout << "M 5 " << matches[5] << std::endl;*/
+	/*std::cout << "M 6 " << matches[6] << std::endl;*/
+
+	std::string text = stringUtils::trim(matches[4]);
+
+	auto date = stringToDate(dateString);
+
+	if (!date.has_value()) {
+		throw std::runtime_error("Malformated date");
+	}
+
+	EventData eventData{
+		.title = text, .startsAt = stringToTime(matches[2]), .endsAt = stringToTime(matches[3]),
+		//.tags = extractTagsFromMetadata(matches[6])
+	};
+	return eventData;
+}
+
+std::string taskToString(const TaskData &task)
+{
+	std::string str = task.title;
+	/*if (task.getTags().size() > 0) {*/
+	/*str += " --";*/
+	/*for (const std::string &tag : task.getTags()) {*/
+	/*str += " #" + tag;*/
+	/*}*/
+	/*}*/
+	str = (task.state == DONE ? "- [X] " : "- [ ] ") + str;
+	return str;
+}
+
+std::string MarkdownDataProvider::toMarkdown()
+{
+	const std::vector<DayData> days = getDays();
+	std::string result = "# " + name() + "\n\n";
+	std::string currentDate = "";
+
+	for (const auto &day : days) {
+		auto &date = day.date;
+		result +=
+			"## " + std::format("{:02d}-{:02d}-{:02d}", date.year, date.month, date.day) + "\n\n";
+		for (auto event : getEventsByDate(date)) {
+			auto &start = event.startsAt;
+			auto &end = event.endsAt;
+			result += "> " +
+					  std::format(
+						  "{:02d}h{:02d}-{:02d}h{:02d} {}", start.hour, start.minute, end.hour,
+						  end.minute, event.title
+					  ) +
+					  "\n";
+			for (const auto &task : getTasksByEventId(event.id)) {
+				result += taskToString(task) + '\n';
+			}
+			result += '\n';
+		}
+		for (const auto &task : getTasksByDayId(day.id)) {
+			result += taskToString(task) + '\n';
+		}
+		result += '\n';
+	}
+
+	auto unscheduledTasks = getTasksWithoutDate();
+	if (unscheduledTasks.size() > 0) {
+		result += "## Unscheduled\n\n";
+		for (const auto &task : unscheduledTasks) {
+			result += taskToString(task) + '\n';
+		}
+		result += '\n';
+	}
+	return result;
+};
+
+MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
+{
+	cpputils::debug::Timer readMdFormatDuration;
+
+	// std::vector<TaskItem> taskItems;
+	std::string line;
+
+	std::stringstream contentStream(content);
+
+	if (!std::getline(contentStream, line) || line.substr(0, 2) != "# ") {
+		std::cerr << "Couldn't find the task list name" << std::endl;
+	}
+
+	data.name = line.substr(2);
+	std::string currentDateString = "";
+
+	std::vector<mirai::DayData> daysData;
+	std::vector<mirai::TaskData> unscheduledTasks;
+	std::optional<Date> currentDate = std::nullopt;
+	std::optional<EventData> currentEvent = std::nullopt;
+
+	cpputils::debug::Timer stringToTaskDuration;
+	stringToTaskDuration.reset();
+	cpputils::debug::Timer gelinesDuration;
+	while (std::getline(contentStream, line)) {
+		if (std::string_view{line.data(), 3} == "## ") {
+			currentDateString = line.substr(3);
+			if (currentDateString == "Unscheduled") {
+				currentDate = std::nullopt;
+				continue;
+			}
+			currentDate = mirai::stringToDate(currentDateString);
+			if (!currentDate.has_value()) {
+				throw std::runtime_error("Malformated date (1)");
+			}
+			insertDay({.id = generateUniqueId(), .date = currentDate.value()});
+		} else if (line.starts_with("> ")) {
+			auto event = stringToEvent(line, currentDateString);
+			if (currentDate.has_value()) {
+				auto day = getDayByDate(currentDate.value());
+				currentEvent = insertEvent(
+					{.id = generateUniqueId(),
+					 .dayId = day->id,
+					 .title = event.title,
+					 .startsAt = event.startsAt,
+					 .endsAt = event.endsAt}
+				);
+			}
+		} else if (line.starts_with("- [ ]") || line.starts_with("- [X]")) {
+			stringToTaskDuration.start();
+			TaskData taskItemData = stringToTask(line, currentDateString);
+			stringToTaskDuration.stop();
+			if (currentEvent.has_value()) {
+				insertTask({
+					.id = generateUniqueId(),
+					.title = taskItemData.title,
+					.state = taskItemData.state,
+					.dayId = std::nullopt,
+					.eventId = currentEvent.value().id,
+				});
+			} else if (currentDate.has_value()) {
+				auto day = getDayByDate(currentDate.value());
+				insertTask({
+					.id = generateUniqueId(),
+					.title = taskItemData.title,
+					.state = taskItemData.state,
+					.dayId = day->id,
+					.eventId = std::nullopt,
+				});
+			} else {
+				insertTask({
+					.id = generateUniqueId(),
+					.title = taskItemData.title,
+					.state = taskItemData.state,
+					.dayId = std::nullopt,
+					.eventId = std::nullopt,
+				});
+			}
+		} else if (cpputils::string::trim(line) == "") {
+			currentEvent = std::nullopt;
+		}
+	}
+
+	gelinesDuration.printTimeElapsed("getlinesDuration");
+	stringToTaskDuration.printTimeElapsed("stringToTaskDuration");
+	readMdFormatDuration.printTimeElapsed("Reading MD File duration");
+	return data;
+}
+} // namespace mirai

external/mirai-core/src/MarkdownDataProvider.cpp

@@ -0,0 +1,251 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "MarkdownDataProvider.h"
+#include "SourceDataProvider.h"
+#include "cpp-utils/debug.h"
+#include "utils.h"
+#include <algorithm>
+#include <cassert>
+#include <functional>
+#include <optional>
+#include <regex>
+#include <vector>
+
+namespace mirai
+{
+
+std::string MarkdownDataProvider::name() const
+{
+	return data.name;
+}
+
+void MarkdownDataProvider::save()
+{
+	std::ofstream file(filePath_);
+	if (!file.is_open()) {
+		throw std::runtime_error("can't create " + filePath_);
+	}
+
+	const std::string content = toMarkdown();
+
+	file << content;
+	file.close();
+	setDirty(false);
+};
+
+void MarkdownDataProvider::load()
+{
+	std::ifstream file(filePath_);
+	if (!file.is_open()) {
+		return;
+	}
+	std::string content = "";
+	std::string line;
+
+	while (std::getline(file, line)) {
+		content += line + "\n";
+	}
+	file.close();
+	data = parseMarkdown(content);
+};
+
+TaskData MarkdownDataProvider::insertTask(const TaskData &taskData)
+{
+	data.tasks.push_back(taskData);
+	setDirty(true);
+	return taskData;
+}
+
+void MarkdownDataProvider::updateTask(int taskId, UpdatableTaskData updateData)
+{
+	auto taskData = ptrFindFirst(data.tasks, [&](const TaskData &task) {
+		return task.id == taskId;
+	});
+	assert(taskData != nullptr); // Shouldn't be possible
+	if (updateData.title.has_value()) {
+		taskData->title = updateData.title.value();
+	}
+	if (updateData.state.has_value()) {
+		taskData->state = updateData.state.value();
+	}
+	if (updateData.dayId.has_value()) {
+		taskData->dayId = updateData.dayId.value();
+	}
+	if (updateData.eventId.has_value()) {
+		taskData->eventId = updateData.eventId.value();
+	}
+	setDirty(true);
+}
+
+std::optional<TaskData> MarkdownDataProvider::getTaskById(int taskId)
+{
+	return findFirst(data.tasks, [&](const TaskData &task) {
+		return task.id == taskId;
+	});
+}
+
+std::vector<TaskData> MarkdownDataProvider::getTasksByEventId(int eventId)
+{
+	return findAll(data.tasks, [&](const TaskData &task) {
+		return task.eventId == eventId;
+	});
+}
+
+std::vector<TaskData> MarkdownDataProvider::getTasksByDayId(int dayId)
+{
+	return findAll(data.tasks, [&](const TaskData &task) {
+		return task.dayId == dayId;
+	});
+}
+
+std::vector<TaskData> MarkdownDataProvider::getTasksWithoutDate()
+{
+	return findAll(data.tasks, [](const TaskData &t) {
+		return t.dayId == std::nullopt && t.eventId == std::nullopt;
+	});
+}
+
+std::vector<TaskData> MarkdownDataProvider::getTasksByDate(Date date)
+{
+	auto day = getDayByDate(date);
+	if (!day.has_value()) {
+		return {};
+	}
+	return findAll(data.tasks, [&](const TaskData &t) {
+		return t.dayId == day.value().id;
+	});
+}
+
+std::vector<TaskData> MarkdownDataProvider::getTasks()
+{
+	return data.tasks;
+}
+
+void MarkdownDataProvider::removeTaskById(int taskId)
+{
+	data.tasks.erase(
+		std::remove_if(
+			data.tasks.begin(), data.tasks.end(),
+			[&](const TaskData &task) {
+				return task.id == taskId;
+			}
+		),
+		data.tasks.end()
+	);
+	setDirty(true);
+}
+
+DayData MarkdownDataProvider::insertDay(const DayData &dayData)
+{
+	data.days.push_back(dayData);
+	setDirty(true);
+	return dayData;
+}
+
+void MarkdownDataProvider::updateDay(int dayId, UpdatableDayData updateData)
+{
+	auto dayData = ptrFindFirst(data.days, [&](const DayData &day) {
+		return day.id == dayId;
+	});
+	assert(dayData != nullptr); // Shouldn't be possible
+	if (updateData.date.has_value()) {
+		dayData->date = updateData.date.value();
+	}
+	setDirty(true);
+}
+
+void MarkdownDataProvider::removeDayById(int dayId)
+{
+	data.days.erase(
+		std::remove_if(
+			data.days.begin(), data.days.end(),
+			[&](const DayData &day) {
+				return day.id == dayId;
+			}
+		),
+		data.days.end()
+	);
+	setDirty(true);
+}
+
+std::vector<DayData> MarkdownDataProvider::getDays()
+{
+	return data.days;
+}
+
+std::optional<DayData> MarkdownDataProvider::getDayByDate(const Date &date)
+{
+	return findFirst(data.days, [&](const DayData &day) {
+		return day.date == date;
+	});
+}
+
+EventData MarkdownDataProvider::insertEvent(const EventData &eventData)
+{
+	data.events.push_back(eventData);
+	setDirty(true);
+	return eventData;
+}
+
+void MarkdownDataProvider::updateEvent(int eventId, UpdatableEventData updateData)
+{
+	auto eventData = ptrFindFirst(data.events, [&](const EventData &event) {
+		return event.id == eventId;
+	});
+	assert(eventData != nullptr); // Shouldn't be possible
+	if (updateData.title.has_value()) {
+		eventData->title = updateData.title.value();
+	}
+	if (updateData.dayId.has_value()) {
+		eventData->dayId = updateData.dayId.value();
+	}
+	if (updateData.startsAt.has_value()) {
+		eventData->startsAt = updateData.startsAt.value();
+	}
+	if (updateData.endsAt.has_value()) {
+		eventData->endsAt = updateData.endsAt.value();
+	}
+	setDirty(true);
+}
+
+void MarkdownDataProvider::removeEventById(int eventId)
+{
+	data.events.erase(
+		std::remove_if(
+			data.events.begin(), data.events.end(),
+			[&](const EventData &event) {
+				return event.id == eventId;
+			}
+		),
+		data.events.end()
+	);
+	setDirty(true);
+}
+
+std::optional<EventData> MarkdownDataProvider::getEventById(int eventId)
+{
+	return findFirst(data.events, [&](const EventData &event) {
+		return event.id == eventId;
+	});
+}
+
+std::vector<EventData> MarkdownDataProvider::getEventsByDate(Date date)
+{
+	auto day = getDayByDate(date);
+	if (!day.has_value()) {
+		return {};
+	}
+	return findAll(data.events, [&](const EventData &event) {
+		return event.dayId == day.value().id;
+	});
+}
+
+std::vector<EventData> MarkdownDataProvider::getEvents()
+{
+	return data.events;
+}
+} // namespace mirai

external/mirai-core/src/Mirai.cpp

@@ -6,7 +6,8 @@
 
 #include "Mirai.h"
 #include "Config.h"
-#include "TaskItem.h"
+#include "Source.h"
+#include "SourceDataProvider.h"
 #include "cpp-utils/debug.h"
 #include "utils.h"
 #include <algorithm>
@@ -19,11 +20,13 @@
 namespace mirai
 {
 
-void Mirai::loadSource(std::unique_ptr<BaseSource> &&resource)
+void Mirai::loadSource(std::unique_ptr<SourceDataProvider> &&resource)
 {
-	resource->load();
-	sources_.push_back(std::move(resource));
-	reloadTags();
+	SourceDataProvider *sourceDataProvider = resource.release();
+	sourceDataProvider->load();
+	sources_.push_back(
+		std::make_unique<Source>(SourceConstructor{.sourceDataProvider = sourceDataProvider})
+	);
 };
 
 void Mirai::unloadAllSources()
@@ -33,63 +36,19 @@ void Mirai::unloadAllSources()
 
 void Mirai::save()
 {
-	for (auto &resource : sources_) {
-		if (resource->isDirty()) {
-			resource->save();
-			resource->setDirty(false);
+	for (auto &source : sources_) {
+		if (source->isDirty()) {
+			source->save();
 		}
 	}
-	reloadTags();
 }
 
-void Mirai::deleteTask(const TaskItem &taskItem)
-{
-	for (auto &resource : sources_) {
-		resource->deleteTask(taskItem);
-	}
-}
-
-std::vector<std::unique_ptr<BaseSource>> &Mirai::getSources()
+std::vector<std::unique_ptr<Source>> &Mirai::getSources()
 {
 	return sources_;
 }
 
-std::optional<std::reference_wrapper<BaseSource>> Mirai::getSourceByName(const std::string &name)
-{
-	auto resourceIterator =
-		std::ranges::find_if(sources_, [&](const std::unique_ptr<BaseSource> &resource) {
-			return resource->getName() == name;
-		});
-
-	if (resourceIterator == sources_.end()) {
-		return std::nullopt;
-	}
-	return *(resourceIterator->get());
-}
-
-const std::vector<std::string> &Mirai::getTags()
-{
-	return tags_;
-}
-
-void Mirai::reloadTags()
-{
-	// TODO TAGS
-	/*cpputils::debug::Timer reloadingTagsDuration;*/
-	/*tags.clear();*/
-	/*for (auto &resource : resources) {*/
-	/*for (auto &task : resource->getTasks()) {*/
-	/*for (auto &tag : task->getTags()) {*/
-	/*if (!vectorUtils::contains(tags, tag)) {*/
-	/*tags.push_back(tag);*/
-	/*}*/
-	/*}*/
-	/*}*/
-	/*}*/
-	/*reloadingTagsDuration.printTimeElapsed("ReloadingTags");*/
-}
-
-BaseSource *Mirai::getSourceById(int id)
+Source *Mirai::getSourceById(int id)
 {
 	if (id >= sources_.size()) {
 		return nullptr;

external/mirai-core/src/Source.cpp

@@ -0,0 +1,147 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "Source.h"
+#include "SourceDataProvider.h"
+#include "utils.h"
+#include <algorithm>
+#include <iterator>
+#include <optional>
+#include <vector>
+
+namespace mirai
+{
+
+void Source::save()
+{
+	data->save();
+}
+
+void Source::createTask(const createTaskParams &task)
+{
+	std::optional<int> dayId = std::nullopt;
+	std::optional<int> eventId = std::nullopt;
+
+	if (!task.event.has_value() && task.date.has_value()) {
+		auto day = data->getDayByDate(task.date.value());
+		if (!day.has_value() && task.date.has_value()) {
+			day = data->insertDay({.id = generateUniqueId(), .date = task.date.value()});
+			dayId = day->id;
+		}
+	}
+
+	if (task.event.has_value() && task.event->id()) {
+		eventId = task.event.value().id();
+	}
+
+	data->insertTask({
+		.id = generateUniqueId(),
+		.title = task.title,
+		.state = TODO,
+		.dayId = dayId,
+		.eventId = eventId,
+	});
+};
+
+std::vector<Day> Source::getDays()
+{
+	auto daysData = data->getDays();
+	std::vector<Day> days;
+	std::transform(
+		daysData.begin(), daysData.end(), std::back_inserter(days),
+		[&](const DayData &dayData) {
+			return Day{data, dayData};
+		}
+	);
+	return days;
+}
+
+std::optional<Day> Source::getDayByDate(Date date)
+{
+	auto day = data->getDayByDate(date);
+	if (!day.has_value()) {
+		return std::nullopt;
+	}
+	return Day{data, day.value()};
+}
+
+void Source::createEvent(const createEventParams &eventToCreate)
+{
+	std::optional<int> dayId = std::nullopt;
+
+	auto day = data->getDayByDate(eventToCreate.date);
+	if (!day.has_value()) {
+		day = data->insertDay({.id = generateUniqueId(), .date = eventToCreate.date});
+		dayId = day->id;
+	}
+
+	data->insertEvent({
+		.id = generateUniqueId(),
+		.dayId = day.value().id,
+		.title = eventToCreate.title,
+	});
+};
+
+std::optional<Event> Source::getEventById(int evendId)
+{
+	auto event = data->getEventById(evendId);
+	if (!event.has_value()) {
+		return std::nullopt;
+	}
+	return Event{data, event.value()};
+}
+
+void Source::removeEvent(const Event &event)
+{
+	data->removeEventById(event.id());
+}
+
+void Source::removeTask(const Task &task)
+{
+	data->removeTaskById(task.id());
+}
+
+std::optional<Task> Source::getTaskById(int taskId)
+{
+	auto taskData = data->getTaskById(taskId);
+	if (!taskData.has_value()) {
+		return std::nullopt;
+	}
+	Task task{data, taskData.value()};
+	return task;
+}
+
+std::vector<Task> Source::getTasks()
+{
+	auto tasksData = data->getTasks();
+	std::vector<Task> tasks;
+	std::transform(
+		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
+		[&](const TaskData &taskData) {
+			return Task{data, taskData};
+		}
+	);
+	return tasks;
+}
+
+std::vector<Task> Source::getUnscheduledTasks()
+{
+	auto tasksData = data->getTasksWithoutDate();
+	std::vector<Task> tasks;
+	std::transform(
+		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
+		[&](const TaskData &taskData) {
+			return Task{data, taskData};
+		}
+	);
+	return tasks;
+}
+
+std::string Source::name() const
+{
+	return data->name();
+}
+} // namespace mirai

external/mirai-core/src/Task.cpp

@@ -0,0 +1,63 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "Task.h"
+#include "Day.h"
+#include "SourceDataProvider.h"
+#include <optional>
+#include <string>
+
+namespace mirai
+{
+
+int Task::id() const
+{
+	return task_.id;
+}
+
+int Task::sourceId() const
+{
+	return data_->id;
+}
+
+std::string Task::title() const
+{
+	return task_.title;
+}
+
+mirai::TaskState Task::state() const
+{
+	return task_.state;
+}
+
+bool Task::checked() const
+{
+	return task_.state == mirai::DONE;
+}
+
+void Task::setTitle(const std::string &newTitle)
+{
+	data_->updateTask(id(), {.title = newTitle});
+}
+
+void Task::setDay(const Day &day)
+{
+	auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
+	data_->updateTask(id(), {.dayId = day.id(), .eventId = emptyEventId});
+}
+
+void Task::setEvent(const Event &event)
+{
+	auto emptyDayId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
+	data_->updateTask(id(), {.dayId = emptyDayId, .eventId = event.id()});
+}
+
+void Task::setChecked(bool checked)
+{
+	data_->updateTask(id(), {.state = checked ? DONE : TODO});
+}
+
+} // namespace mirai

external/mirai-core/src/View.cpp

@@ -0,0 +1,150 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "View.h"
+#include "utils.h"
+#include <iostream>
+#include <iterator>
+#include <ranges>
+
+namespace mirai
+{
+
+View::View(Mirai *mirai) : mirai_(mirai)
+{
+}
+
+void View::hideCompletedTasks(bool hide)
+{
+	shouldHideCompletedTasks_ = hide;
+}
+
+bool View::shouldHideCompletedTasks() const
+{
+	return shouldHideCompletedTasks_;
+}
+
+std::vector<Date> View::getDates()
+{
+	std::vector<Date> datesVector;
+	for (auto &date : dates) {
+		datesVector.push_back(date.first);
+	}
+	return datesVector;
+}
+
+std::vector<Task> View::getTasksForDate(const Date &date)
+{
+	return dates.at(date).tasks;
+}
+
+std::vector<Event> View::getEventsForDate(const Date &date)
+{
+	return dates.at(date).events;
+}
+
+std::vector<Task> View::getUnscheduledTasks()
+{
+	return unscheduledTasks_;
+}
+
+void View::update()
+{
+	dates.clear();
+	unscheduledTasks_.clear();
+
+	auto todayDate = Date(std::chrono::system_clock::now());
+
+	for (int sourceId : sourcesIds_) {
+		Source *source = mirai_->getSourceById(sourceId);
+		for (auto day : source->getDays()) {
+			// day's tasks
+			auto sourceTasks = day.tasks() | std::ranges::views::filter([&](const Task &task) {
+								   if (shouldHideCompletedTasks()) {
+									   return task.checked() == false;
+								   }
+								   return true;
+							   });
+			if (std::ranges::distance(sourceTasks) > 0) {
+
+				if (!dates.contains(day.date())) {
+					dates.insert_or_assign(day.date(), DateView{});
+				}
+				auto &tasks = dates.at(day.date()).tasks;
+				tasks.insert(tasks.end(), sourceTasks.begin(), sourceTasks.end());
+			}
+
+			// day's events
+			auto sourceEvents = day.events() | std::ranges::views::filter([&](const Event &event) {
+									return (day.date() >= todayDate) ||
+										   findFirst(event.queryTasks(), [&](const Task &task) {
+											   return task.checked() == false;
+										   }).has_value();
+								});
+
+			if (std::ranges::distance(sourceEvents) > 0) {
+				if (!dates.contains(day.date())) {
+					dates.insert_or_assign(day.date(), DateView{});
+				}
+				auto &events = dates.at(day.date()).events;
+				events.insert(events.end(), sourceEvents.begin(), sourceEvents.end());
+			}
+		}
+		// unscheduled tasks
+		auto tasks = source->getUnscheduledTasks();
+		unscheduledTasks_.insert(unscheduledTasks_.end(), tasks.begin(), tasks.end());
+	}
+}
+
+void View::removeSources()
+{
+	sourcesIds_.clear();
+}
+
+void View::addSource(const Source &source)
+{
+	sourcesIds_.push_back(source.id);
+}
+
+void View::setSources(const std::vector<Source> &sources)
+{
+	sourcesIds_.clear();
+	std::transform(
+		sources.begin(), sources.end(), std::back_inserter(sourcesIds_),
+		[](const Source &source) {
+			return source.id;
+		}
+	);
+}
+
+void View::setAllSources()
+{
+	const auto &sources = mirai_->getSources();
+	sourcesIds_.clear();
+	std::transform(
+		sources.begin(), sources.end(), std::back_inserter(sourcesIds_),
+		[](const std::unique_ptr<Source> &source) {
+			return source->id;
+		}
+	);
+}
+
+bool View::isSourceSelected(const Source &source) const
+{
+	for (auto &sourceId : sourcesIds_) {
+		if (sourceId == source.id) {
+			return true;
+		}
+	}
+	return false;
+}
+
+size_t View::activeSourceCount() const
+{
+	return sourcesIds_.size();
+}
+
+} // namespace mirai

external/mirai-core/src/utils.cpp

@@ -6,9 +6,12 @@
 
 #include "utils.h"
 #include <cctype>
+#include <functional>
+#include <optional>
 
 namespace mirai
 {
+
 bool isDate(const std::string &dateStr)
 {
 	// std regex are really slow
@@ -35,4 +38,10 @@ bool isDate(const std::string &dateStr)
 	}
 	return true;
 }
+
+int generateUniqueId()
+{
+	static int nextId = 0;
+	return nextId++;
+}
 } // namespace mirai

src/UiState.cpp

@@ -7,9 +7,9 @@
 #include "UiState.h"
 #include "Utils.h"
 #include "appwindow.h"
+#include "mirai-core/Day.h"
 #include "mirai-core/Mirai.h"
-#include "mirai-core/TaskItem.h"
-#include "mirai-core/TodoMd.h"
+#include "mirai-core/SourceDataProvider.h"
 #include "slint.h"
 #include "slint_sharedvector.h"
 #include "slint_string.h"
@@ -46,16 +46,11 @@ UiState::UiState(mirai::Mirai *miraiInstance) : miraiInstance_(miraiInstance), v
 	);
 
 	mainWindow_->global<Backend>().set_sources(sourcesNames);
-	taskWindow_->global<Backend>().set_sources_selected(sources_);
-	taskWindow_->global<Backend>().set_sources(sourcesNames);
-	taskWindow_->global<Backend>().set_tags(tags_);
-	eventWindow_->global<Backend>().set_sources_selected(sources_);
-	eventWindow_->global<Backend>().set_tags(tags_);
 
+	view_.setAllSources();
 	view_.update();
 
 	reloadSources();
-	reloadTags();
 	reloadTasks();
 
 	setupCallbacks();
@@ -82,147 +77,6 @@ std::optional<Date> stringToDate(const std::string &dateStr)
 	return Date{.year = year, .month = month, .day = day};
 }
 
-void UiState::setupTaskWindowCallbacks()
-{
-	mainWindow_->global<Backend>().on_saveTask([&](SaveTaskData newTaskData) {
-		auto source = miraiInstance_->getSourceById(newTaskData.sourceId);
-		assert(source);
-		auto task = source->getTaskById(newTaskData.id);
-		assert(task);
-		const Date &date = newTaskData.date;
-		const std::string dateStr = SlintDateToStdString(date);
-		auto taskData =
-			mirai::TodoMdFormat::stringToTask("- [ ] " + std::string(newTaskData.title), dateStr);
-
-		task->setText(taskData.text);
-		if (task->day() && task->day()->getDate() != SlintDateToMiraiDate(date)) {
-			auto newDate = source->day(SlintDateToMiraiDate(date));
-			newDate->createTask({
-				.text = taskData.text,
-				.state = task->getState(),
-				.tags = taskData.tags,
-			});
-			auto oldDate = task->day();
-			source->deleteTask(*task);
-		}
-		miraiInstance_->save();
-		view_.update();
-		reloadTasks();
-		taskWindow_->hide();
-	});
-
-	mainWindow_->global<Backend>().on_createTask([&](NewTaskData newTaskData) {
-		const Date &date = newTaskData.date;
-		const std::string dateStr = SlintDateToStdString(date);
-		auto source = miraiInstance_->getSourceById(newTaskData.sourceId);
-		auto task =
-			mirai::TodoMdFormat::stringToTask("- [ ] " + std::string(newTaskData.title), dateStr);
-
-		if (!newTaskData.scheduled) {
-			source->addUnscheduledTask(task);
-		} else if (newTaskData.eventId == -1) {
-			auto day = source->day(SlintDateToMiraiDate(date));
-			assert(day);
-			day->createTask(task);
-		} else {
-			auto event = source->getEventById(newTaskData.eventId);
-			assert(event);
-			event->createTask(task);
-		}
-
-		miraiInstance_->save();
-		view_.update();
-		reloadTasks();
-		taskWindow_->hide();
-	});
-}
-
-void UiState::setupEventWindowCallbacks()
-{
-	mainWindow_->global<Backend>().on_open_new_event_form([&]() {
-		auto todayDate = std::chrono::year_month_day{
-			std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now())
-		};
-		eventWindow_->set_eventId(-1);
-		eventWindow_->set_taskTitle("");
-		eventWindow_->set_taskDate({
-			.year = static_cast<int>(todayDate.year()),
-			// Try to directly use `unsigned`
-			.month = static_cast<int>(static_cast<unsigned>(todayDate.month())),
-			.day = static_cast<int>(static_cast<unsigned>(todayDate.day())),
-		});
-
-		eventWindow_->show();
-	});
-
-	mainWindow_->global<Backend>().on_open_edit_event_form([&](int sourceId, int eventId) {
-		auto source = miraiInstance_->getSourceById(sourceId);
-		assert(source);
-		auto event = source->getEventById(eventId);
-		assert(event);
-		eventWindow_->global<Backend>().set_sources_selected(sources_);
-		eventWindow_->global<Backend>().set_tags(tags_);
-
-		eventWindow_->set_sourceId(sourceId);
-		eventWindow_->set_eventId(eventId);
-		eventWindow_->set_taskTitle(slint::SharedString(event->getText()));
-		eventWindow_->set_taskDate(MiraiDateToSlintDate(event->getDate()));
-		eventWindow_->set_startsAt(MiraiTimeToSlintTime(event->getStartTime()));
-		eventWindow_->set_endsAt(MiraiTimeToSlintTime(event->getEndTime()));
-		eventWindow_->show();
-	});
-
-	mainWindow_->global<Backend>().on_delete_event_clicked([&](int sourceId, int eventId) {
-		auto source = miraiInstance_->getSourceById(sourceId);
-		assert(source);
-		auto event = source->getEventById(eventId);
-		assert(event);
-		auto day = event->day();
-		assert(day);
-		day->deleteEvent(*event);
-		miraiInstance_->save();
-		view_.update();
-		reloadTasks();
-	});
-
-	mainWindow_->global<Backend>().on_createEvent([&](NewEventParams newEventParams) {
-		const Date &date = newEventParams.date;
-		const std::string dateStr = SlintDateToStdString(date);
-		auto source = miraiInstance_->getSourceById(newEventParams.sourceId);
-
-		auto day = source->day(SlintDateToMiraiDate(date));
-		day->createEvent({
-			.description = std::string(newEventParams.title),
-			.date = SlintDateToMiraiDate(newEventParams.date),
-			.startTime = SlintTimeToMiraiTime(newEventParams.startsAt),
-			.endTime = SlintTimeToMiraiTime(newEventParams.endsAt),
-		});
-		miraiInstance_->save();
-		view_.update();
-		reloadTasks();
-		eventWindow_->hide();
-	});
-
-	mainWindow_->global<Backend>().on_saveEvent([&](SaveEventParams newEventParams) {
-		const Date &date = newEventParams.date;
-		const std::string dateStr = SlintDateToStdString(date);
-		auto source = miraiInstance_->getSourceById(newEventParams.sourceId);
-		assert(source);
-		auto event = source->getEventById(newEventParams.id);
-		assert(event);
-		event->setText(std::string(newEventParams.title));
-		event->setStartTime(SlintTimeToMiraiTime(newEventParams.startsAt));
-		event->setEndTime(SlintTimeToMiraiTime(newEventParams.endsAt));
-
-		// TODO we can't change the date of the event for now.
-
-		miraiInstance_->save();
-		view_.update();
-		reloadTasks();
-		eventWindow_->hide();
-	});
-}
-
 void UiState::setupUtilsCallbacks()
 {
 	mainWindow_->global<Backend>().on_formatDate([&](const Date &date) {
@@ -242,108 +96,48 @@ void UiState::setupCallbacks()
 		assert(source);
 		auto task = source->getTaskById(taskId);
 		assert(task);
-		task->getState() == mirai::DONE ? task->markAsUndone() : task->markAsDone();
+		task->setChecked(!task->checked());
+		// task->getState() == mirai::DONE ? task->markAsUndone() : task->markAsDone();
 		miraiInstance_->save();
 	});
 
 	mainWindow_->global<Backend>().on_source_clicked([&](int index) {
 		// index with value -1 is equal to no selection, aka "All"
 		if (index == -1) {
-			view_.removeFilters();
+			view_.setAllSources();
 		} else {
-			view_.removeFilters();
-			const auto &source = miraiInstance_->getSourceById(index);
-			const auto &sourceName = source->getName();
-			view_.addSourceFilter(sourceName);
-			/*
-			// Old behavior, I keep it here for now
-			const auto &source = miraiInstance_->getSourceById(index);
-			const auto &sourceName = source->getName();
-			if (std::ranges::find(view_.getActiveFilesFilter(), sourceName) ==
-				view_.getActiveFilesFilter().end()) {
-				view_.addSourceFilter(sourceName);
-			} else {
-				view_.removeSourceFilter(sourceName);
-			}
-			*/
+			view_.removeSources();
+			const mirai::Source *source = miraiInstance_->getSourceById(index);
+			view_.addSource(*source);
 		}
 		view_.update();
 		reloadSources();
 		reloadTasks();
 	});
 
-	mainWindow_->global<Backend>().on_tag_clicked([&](int index) {
-		const std::string &tag = miraiInstance_->getTags().at(index);
-		if (std::ranges::find(view_.getActiveTagsFilter(), tag) ==
-			view_.getActiveTagsFilter().end()) {
-			view_.addTagFilter(tag);
-		} else {
-			view_.removeTagFilter(tag);
-		}
-		view_.update();
-		reloadTasks();
-	});
+	/*mainWindow_->global<Backend>().on_tag_clicked([&](int index) {*/
+	/*const std::string &tag = miraiInstance_->getTags().at(index);*/
+	/*if (std::ranges::find(view_.getActiveTagsFilter(), tag) ==*/
+	/*view_.getActiveTagsFilter().end()) {*/
+	/*view_.addTagFilter(tag);*/
+	/*} else {*/
+	/*view_.removeTagFilter(tag);*/
+	/*}*/
+	/*view_.update();*/
+	/*reloadTasks();*/
+	/*});*/
 
 	mainWindow_->global<Backend>().on_delete_task_clicked([&](int sourceId, int taskId) {
 		auto source = miraiInstance_->getSourceById(sourceId);
 		assert(source);
 		auto task = source->getTaskById(taskId);
 		assert(task);
-		source->deleteTask(*task);
+		source->removeTask(*task);
 		miraiInstance_->save();
 		view_.update();
 		reloadTasks();
 	});
 
-	mainWindow_->global<Backend>().on_open_edit_task_form([&](int sourceId, int taskId) {
-		auto source = miraiInstance_->getSourceById(sourceId);
-		assert(source);
-		auto task = source->getTaskById(taskId);
-		assert(task);
-
-		taskWindow_->set_taskSourceIndex(sourceId);
-		taskWindow_->set_taskId(task->id());
-		taskWindow_->set_taskTitle(slint::SharedString(task->getText()));
-		if (task->day() != nullptr) {
-			taskWindow_->set_scheduled(true);
-			taskWindow_->set_taskDate(MiraiDateToSlintDate(task->day()->getDate()));
-		} else {
-			taskWindow_->set_scheduled(false);
-		}
-
-		taskWindow_->show();
-	});
-
-	mainWindow_->global<Backend>().on_open_new_task_form([&](OpenNewTaskFormParams params) {
-		taskWindow_->global<Backend>().set_sources_selected(sources_);
-		taskWindow_->global<Backend>().set_tags(tags_);
-
-		auto todayDate = std::chrono::year_month_day{
-			std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now())
-		};
-		taskWindow_->set_taskId(-1);
-		taskWindow_->set_eventId(params.eventId);
-		taskWindow_->set_taskSourceIndex(params.eventSourceId == -1 ? 0 : params.eventSourceId);
-		taskWindow_->set_taskTitle("");
-
-		if (params.eventId == -1) {
-			taskWindow_->set_taskDate({
-				.year = static_cast<int>(todayDate.year()),
-				// Try to directly use `unsigned`
-				.month = static_cast<int>(static_cast<unsigned>(todayDate.month())),
-				.day = static_cast<int>(static_cast<unsigned>(todayDate.day())),
-			});
-		} else {
-			auto source = miraiInstance_->getSourceById(params.eventSourceId);
-			assert(source);
-			auto event = source->getEventById(params.eventId);
-			assert(event);
-			taskWindow_->set_taskDate(MiraiDateToSlintDate(event->getDate()));
-		}
-
-		taskWindow_->show();
-	});
-
 	mainWindow_->global<Backend>().on_toggle_show_completed_tasks([&] {
 		view_.hideCompletedTasks(!view_.shouldHideCompletedTasks());
 		view_.update();
@@ -354,8 +148,95 @@ void UiState::setupCallbacks()
 	mainWindow_->global<Backend>().set_tags(tags_);
 	mainWindow_->global<Backend>().set_visible_tasks(days_);
 
-	setupTaskWindowCallbacks();
-	setupEventWindowCallbacks();
+	mainWindow_->global<Backend>().on_saveTask([&](SaveTaskData newTaskData) {
+		auto source = miraiInstance_->getSourceById(newTaskData.sourceId);
+		assert(source);
+		auto task = source->getTaskById(newTaskData.id);
+		assert(task);
+		const mirai::Date &date = SlintDateToMiraiDate(newTaskData.date);
+		const auto dayOpt = source->getDayByDate(date);
+
+		if (!dayOpt.has_value()) {
+			throw std::runtime_error("Missing auto day creation implementation");
+		}
+
+		const auto day = dayOpt.value();
+
+		task->setTitle(std::string(newTaskData.title));
+		task->setDay(day);
+
+		miraiInstance_->save();
+		view_.update();
+		reloadTasks();
+	});
+
+	mainWindow_->global<Backend>().on_createTask([&](NewTaskData newTaskData) {
+		std::optional<mirai::Date> date = std::nullopt;
+		if (newTaskData.date.year != 0) {
+			date = SlintDateToMiraiDate(newTaskData.date);
+		}
+		auto source = miraiInstance_->getSourceById(newTaskData.sourceId);
+
+		std::optional<mirai::Event> event = std::nullopt;
+		if (newTaskData.eventId >= 0) {
+			event = source->getEventById(newTaskData.eventId);
+		}
+
+		source->createTask({
+			.title = std::string(newTaskData.title),
+			.event = event,
+			.date = date,
+		});
+
+		miraiInstance_->save();
+		view_.update();
+		reloadTasks();
+	});
+
+	mainWindow_->global<Backend>().on_delete_event_clicked([&](int sourceId, int eventId) {
+		auto source = miraiInstance_->getSourceById(sourceId);
+		assert(source);
+		auto event = source->getEventById(eventId);
+		assert(event.has_value());
+		source->removeEvent(event.value());
+		miraiInstance_->save();
+		view_.update();
+		reloadTasks();
+	});
+
+	mainWindow_->global<Backend>().on_createEvent([&](NewEventParams newEventParams) {
+		const Date &date = newEventParams.date;
+		const std::string dateStr = SlintDateToStdString(date);
+		auto source = miraiInstance_->getSourceById(newEventParams.sourceId);
+
+		source->createEvent({
+			.title = std::string(newEventParams.title),
+			.date = SlintDateToMiraiDate(newEventParams.date),
+			.startsAt = SlintTimeToMiraiTime(newEventParams.startsAt),
+			.endsAt = SlintTimeToMiraiTime(newEventParams.endsAt),
+		});
+		miraiInstance_->save();
+		view_.update();
+		reloadTasks();
+	});
+
+	mainWindow_->global<Backend>().on_saveEvent([&](SaveEventParams newEventParams) {
+		const Date &date = newEventParams.date;
+		const std::string dateStr = SlintDateToStdString(date);
+		auto source = miraiInstance_->getSourceById(newEventParams.sourceId);
+		assert(source);
+		auto event = source->getEventById(newEventParams.id);
+		assert(event);
+		event->setTitle(std::string(newEventParams.title));
+		event->setStartTime(SlintTimeToMiraiTime(newEventParams.startsAt));
+		event->setEndTime(SlintTimeToMiraiTime(newEventParams.endsAt));
+
+		// TODO we can't change the date of the event for now.
+
+		miraiInstance_->save();
+		view_.update();
+		reloadTasks();
+	});
 	setupUtilsCallbacks();
 }
 
@@ -376,70 +257,58 @@ void UiState::reloadTasks()
 		return;
 	}
 	auto todayDate = mirai::Date(std::chrono::system_clock::now());
-	auto &days = view_;
+	auto dates = view_.getDates();
 	auto slintDays = std::make_shared<slint::VectorModel<Day>>();
-	for (int dayIndex = 0; dayIndex < days.count(); ++dayIndex) {
-		auto &currentDay = view_[dayIndex];
+	for (int dayIndex = 0; dayIndex < dates.size(); ++dayIndex) {
+		auto &currentDate = dates.at(dayIndex);
 		auto slintEvents = std::make_shared<slint::VectorModel<Event>>();
 		auto slintDayTasks = std::make_shared<slint::VectorModel<TaskData>>();
 		auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(
-									std::chrono::sys_days(currentDay.day->getDate().toStdChrono()) -
+									std::chrono::sys_days(currentDate.toStdChrono()) -
 									std::chrono::sys_days(todayDate.toStdChrono())
 		)
 									.count();
 		slintDays->push_back(
-			Day{.sourceId = currentDay.day->source()->id(),
-				.id = dayIndex,
-				.date = MiraiDateToSlintDate(currentDay.day->getDate()),
+			Day{.date = MiraiDateToSlintDate(currentDate),
 				.events = slintEvents,
 				.tasks = slintDayTasks,
-				.isLate = currentDay.day->getDate() < todayDate,
-				.isToday = currentDay.day->getDate() == todayDate,
+				.isLate = currentDate < todayDate,
+				.isToday = currentDate == todayDate,
 				.relativeDaysDiff = static_cast<int>(relativeDaysDiff)}
 		);
-		for (int taskIndex = 0; taskIndex < currentDay.filteredTasks.size(); ++taskIndex) {
-			auto &task = currentDay.filteredTasks.at(taskIndex);
-			std::vector<slint::SharedString> tags;
-			std::transform(
-				task->getTags().begin(), task->getTags().end(), std::back_inserter(tags),
-				[&](const std::string &tag) {
-					return slint::SharedString(tag);
-				}
-			);
+		// 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->source()->id(),
-				.id = task->id(),
-				.title = slint::SharedString(task->getText()),
-				.checked = task->getState() == mirai::DONE,
-				.tags = std::make_shared<slint::VectorModel<slint::SharedString>>(tags),
+				.sourceId = task.sourceId(),
+				.id = task.id(),
+				.title = slint::SharedString(task.title()),
+				.checked = task.checked(),
 			});
 		}
-		for (int eventIndex = 0; eventIndex < currentDay.filteredEvents.size(); ++eventIndex) {
-			auto &currentEvent = currentDay.filteredEvents.at(eventIndex);
+
+		// 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<TaskData>>();
 			slintEvents->push_back(Event{
-				.sourceId = currentEvent.event->day()->source()->id(),
-				.id = currentEvent.event->id(),
-				.title = slint::SharedString(currentEvent.event->getText()),
-				.startsAt = MiraiTimeToSlintTime(currentEvent.event->getStartTime()),
-				.endsAt = MiraiTimeToSlintTime(currentEvent.event->getEndTime()),
+				.sourceId = currentEvent.sourceId(),
+				.id = currentEvent.id(),
+				.title = slint::SharedString(currentEvent.title()),
+				.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),
+				.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),
 				.tasks = slintTasks,
 			});
-			for (int taskIndex = 0; taskIndex < currentEvent.filteredTasks.size(); ++taskIndex) {
-				auto &task = currentEvent.filteredTasks.at(taskIndex);
-				std::vector<slint::SharedString> tags;
-				std::transform(
-					task->getTags().begin(), task->getTags().end(), std::back_inserter(tags),
-					[&](const std::string &tag) {
-						return slint::SharedString(tag);
-					}
-				);
+			auto eventTasks = currentEvent.queryTasks();
+			for (int taskIndex = 0; taskIndex < eventTasks.size(); ++taskIndex) {
+				auto &task = eventTasks.at(taskIndex);
 				slintTasks->push_back({
-					.sourceId = task->source()->id(),
-					.id = task->id(),
-					.title = slint::SharedString(task->getText()),
-					.checked = task->getState() == mirai::DONE,
-					.tags = std::make_shared<slint::VectorModel<slint::SharedString>>(tags),
+					.sourceId = task.sourceId(),
+					.id = task.id(),
+					.title = slint::SharedString(task.title()),
+					.checked = task.checked(),
 				});
 			}
 		}
@@ -447,22 +316,15 @@ void UiState::reloadTasks()
 	days_ = slintDays;
 	mainWindow_->global<Backend>().set_visible_tasks(days_);
 
+	auto unscheduledTasksView = view_.getUnscheduledTasks();
 	unscheduledTasks_->clear();
-	for (int taskIndex = 0; taskIndex < view_.filteredUnscheduledTasks().size(); ++taskIndex) {
-		auto &task = view_.filteredUnscheduledTasks().at(taskIndex);
-		std::vector<slint::SharedString> tags;
-		std::transform(
-			task->getTags().begin(), task->getTags().end(), std::back_inserter(tags),
-			[&](const std::string &tag) {
-				return slint::SharedString(tag);
-			}
-		);
+	for (int taskIndex = 0; taskIndex < unscheduledTasksView.size(); ++taskIndex) {
+		auto &task = unscheduledTasksView.at(taskIndex);
 		unscheduledTasks_->push_back({
-			.sourceId = task->source()->id(),
-			.id = task->id(),
-			.title = slint::SharedString(task->getText()),
-			.checked = task->getState() == mirai::DONE,
-			.tags = std::make_shared<slint::VectorModel<slint::SharedString>>(tags),
+			.sourceId = task.sourceId(),
+			.id = task.id(),
+			.title = slint::SharedString(task.title()),
+			.checked = task.checked(),
 		});
 	}
 	mainWindow_->global<Backend>().set_unscheduled_tasks(unscheduledTasks_);
@@ -471,27 +333,17 @@ void UiState::reloadTasks()
 void UiState::reloadSources()
 {
 	sources_->clear();
-	bool noSourceSelected = true;
+	bool noSourceSelected = miraiInstance_->getSources().size() == view_.activeSourceCount();
 	for (const auto &source : miraiInstance_->getSources()) {
-		bool isSourceSelected = view_.isSourceFilterActive(source->getName());
+		bool isSourceSelected = view_.isSourceSelected(*source);
 		sources_->push_back(
-			{.name = slint::SharedString(source->getName()), .selected = isSourceSelected}
+			{.name = slint::SharedString(source->name()),
+			 .selected = isSourceSelected && !noSourceSelected}
 		);
-		if (isSourceSelected) {
-			noSourceSelected = false;
-		}
 	}
 	mainWindow_->global<Backend>().set_no_source_selected(noSourceSelected);
 }
 
-void UiState::reloadTags()
-{
-	tags_->clear();
-	for (const auto &tag : miraiInstance_->getTags()) {
-		tags_->push_back(slint::SharedString(tag));
-	}
-}
-
 void UiState::run()
 {
 	mainWindow_->run();

src/UiState.h

@@ -8,7 +8,7 @@
 
 #include "appwindow.h"
 #include "mirai-core/Mirai.h"
-#include "mirai-core/TasksView.h"
+#include "mirai-core/View.h"
 #include "slint.h"
 
 class UiState
@@ -20,13 +20,10 @@ class UiState
 	void run();
 
 	void reloadSources();
-	void reloadTags();
 	void reloadTasks();
 
   private:
 	void setupCallbacks();
-	void setupTaskWindowCallbacks();
-	void setupEventWindowCallbacks();
 	void setupUtilsCallbacks();
 
 	std::shared_ptr<slint::VectorModel<Source>> sources_;
@@ -35,9 +32,7 @@ class UiState
 	std::shared_ptr<slint::VectorModel<TaskData>> unscheduledTasks_;
 
 	slint::ComponentHandle<AppWindow> mainWindow_ = AppWindow::create();
-	slint::ComponentHandle<TaskWindow> taskWindow_ = TaskWindow::create();
-	slint::ComponentHandle<EventWindow> eventWindow_ = EventWindow::create();
 
 	mirai::Mirai *miraiInstance_;
-	mirai::TasksView view_;
+	mirai::View view_;
 };

src/main.cpp

@@ -6,9 +6,12 @@
 
 #include "UiState.h"
 #include "mirai-core/Config.h"
+#include "mirai-core/MarkdownDataProvider.h"
 #include "mirai-core/Mirai.h"
-#include "mirai-core/StdFileSource.h"
+#include "mirai-core/SourceDataProvider.h"
+#include <algorithm>
 #include <cstdlib>
+#include <memory>
 #include <string>
 
 int main(int argc, char **argv)
@@ -18,9 +21,8 @@ int main(int argc, char **argv)
 	mirai::Mirai mirai;
 
 	for (const auto &sourceFilePath : config.sources()) {
-		auto file = std::make_unique<mirai::StdFileSource>(
-			mirai::BaseFileSourceConstructor{.name = sourceFilePath, .path = sourceFilePath}
-		);
+		std::unique_ptr<mirai::SourceDataProvider> file =
+			std::make_unique<mirai::MarkdownDataProvider>(sourceFilePath);
 		mirai.loadSource(std::move(file));
 	}
 

ui/MainView.slint

@@ -5,6 +5,7 @@ import { TaskLine } from "TaskLine.slint";
 import { EventGroup } from "EventGroup.slint";
 import { VPopupIconMenu, VDatePicker, VTimePicker, VCheckBox, VButton, VTag, VText, VTextInput, Palette } from "@vynui";
 import { NewTaskData, SaveTaskData } from "Backend.slint";
+import { CreateTaskOrEvent } from "components/CreateTaskOrEvent.slint";
 
 export component MainView inherits Rectangle {
 
@@ -61,92 +62,8 @@ export component MainView inherits Rectangle {
 			height: 1px;
 		}
 
-		Rectangle {
-			border-color: newTaskTitleInput.text != "" ? Palette.card-background : transparent;
-			border-width: newTaskTitleInput.text != "" ? 4px : 0px;
-			border-radius: newTaskTitleInput.text != "" ? 8px : 0px;
-			animate border-color, border-width {
-				duration: 250ms;
-			}
-			VerticalLayout {
-				in-out property <int> task-or-event: 1;
-				spacing: 8px;
-				padding: newTaskTitleInput.text != "" ? 16px : 0px;
-				animate padding {
-					duration: 250ms;
-				}
-				Rectangle {
-					min-height: 0px;
-					max-height: newTaskTitleInput.text != "" ? 512px : 0px;
-					opacity: newTaskTitleInput.text != "" ? 1 : 0;
-					clip: true;
-					animate max-height, opacity {
-						 duration: 250ms;
-					}
-					
-					HorizontalLayout {
-						alignment: start;
-						spacing: 8px;
-						VerticalLayout {
-							alignment: end;
-							VButton {
-								text: task-or-event == 1 ? "Task" : "Event";
-								clicked => { task-or-event = task-or-event == 1 ? 0 : 1 }
-							}
-						}
-						VText { text: "for"; vertical-alignment: bottom;}
-						VerticalLayout {
-							alignment: end;
-							sourceInput := ComboBox {
-								model: Backend.sources; 
-							}
-						}
-						VText { text: "on"; vertical-alignment: bottom;}
-						taskDateInput := VDatePicker {
-							label: "Date";
-							enabled: true;
-						}
-						HorizontalLayout {
-							visible: task-or-event == 0;
-							HorizontalLayout {
-								spacing: 4px;
-								VText { text: "between"; vertical-alignment: bottom; }
-								eventStartTimeInput := VTimePicker {
-									label: "Starts at";
-								}
-								VText { text: "and"; vertical-alignment: bottom; }
-								eventEndTimeInput := VTimePicker {
-									label: "Ends at";
-								}
-							}
-						}
-						
-					}
-				}
-				newTaskTitleInput := VTextInput {
-					placeholder: "Add new Task / Event";
-					accepted => { 
-						if (task-or-event == 1) {
-							Backend.createTask({
-								sourceId: sourceInput.current-index,
-								eventId: -1,
-								title: newTaskTitleInput.text,
-								scheduled: taskDateInput.date.year != 0,
-								date: taskDateInput.date
-							})
-						} else {
-							Backend.createEvent({
-								sourceId: sourceInput.current-index,
-								title: newTaskTitleInput.text,
-								date: taskDateInput.date,
-								startsAt: eventStartTimeInput.time,
-								endsAt: eventEndTimeInput.time,
-							});
-						}
-						newTaskTitleInput.text = "";
-					}
-				}
-			}
+		CreateTaskOrEvent {
+		
 		}
 		
 		Flickable {
@@ -195,6 +112,7 @@ export component MainView inherits Rectangle {
 								padding-bottom: 8px;
 								TaskLine {
 									task: task;
+									date: day.date;
 									source-index: task.sourceId;
 									task-index: task.id;
 								}

ui/TaskLine.slint

@@ -1,9 +1,13 @@
 import { Backend, TaskData } from "Backend.slint";
 import { ToggleButton } from "@vynui";
 import { VPopupIconMenu, VTag, VButton, VCheckBox, Palette } from "@vynui";
+import { TaskEdit } from "components/TaskEdit.slint";
+import { Date } from "std-widgets.slint";
 
-export component TaskLine {
+export component TaskLine inherits VerticalLayout {
 	in property<TaskData> task;
+	in property<Date> date;
+	in property<int> event-index: -1;
 	in property<int> source-index: -1;
 	in property<int> task-index: -1;
 
@@ -16,72 +20,81 @@ export component TaskLine {
 		}
 	}
 
-
-	popup := VPopupIconMenu {
-		VButton {
-			icon-source: @image-url("./images/edit.png");
-			icon-colorize: Colors.grey;
-			icon-size: 1.5rem;
-			border-radius: 0;
-			clicked => { Backend.open_edit_task_form(source-index, task-index) }
-		}
-
-		VButton {
-			icon-source: @image-url("./images/delete.png");
-			icon-colorize: Colors.pink;
-			icon-size: 1.5rem;
-			border-radius: 0;
-			clicked => { Backend.delete_task_clicked(source-index, task-index) }
+	taskEdit := TaskEdit {
+		accepted(task) => {
+			Backend.saveTask({
+				id: task.id,
+				sourceId: task.sourceId,
+				title: task.title,
+				scheduled: task.date.year != 0,
+				date: task.date
+			});
+			taskEdit.close();
 		}
 	}
 
-	ta := TouchArea {
-		clicked => {
-			checkbox.checked = !checkbox.checked;
-			Backend.task_clicked(source-index, task-index);
-		}
-		pointer-event(e) => {
-			if (e.button == PointerEventButton.right && e.kind == PointerEventKind.up) {
-				popup.show(ta.mouse-x, ta.mouse-y);
-			}
-		}
-		z: 10;
-	}
-
-	
-
-	HorizontalLayout {
-		alignment: space-between;
-		HorizontalLayout {
-			alignment: start;
-			spacing: 8px;
-			checkbox := VCheckBox {
-				text: task.title;
-				checked: task.checked;
-				toggled => {
-					Backend.task_clicked(source-index, task-index)
-				}
-			}
-			for tag[tag-index] in task.tags: VTag {
-				text: tag;
-				size: 0.8rem;
-			}
-		}
-		HorizontalLayout {
-			alignment: end;
-			spacing: 8px;
-			// Not needed anymore, to remove later
-			/*VButton {
+	if !taskEdit.should-show : Rectangle {
+		popup := VPopupIconMenu {
+			VButton {
 				icon-source: @image-url("./images/edit.png");
 				icon-colorize: Colors.grey;
-				clicked => { Backend.open_edit_task_form(source-index, task-index) }
+				icon-size: 1.5rem;
+				border-radius: 0;
+				clicked => { 
+					taskEdit.show({
+						sourceId: task.sourceId,
+						id: task.id,
+						title: task.title,
+						scheduled: root.date.year != 0,
+						date: date,
+					});
+				}
 			}
 
 			VButton {
 				icon-source: @image-url("./images/delete.png");
 				icon-colorize: Colors.pink;
-				clicked => { Backend.delete_task_clicked(source-index, task-index) }
-			}*/
+				icon-size: 1.5rem;
+				border-radius: 0;
+				clicked => {
+					Backend.delete_task_clicked(source-index, task-index)
+				}
+			}
 		}
+
+		ta := TouchArea {
+			clicked => {
+				checkbox.checked = !checkbox.checked;
+				Backend.task_clicked(source-index, task-index);
+			}
+			pointer-event(e) => {
+				if (e.button == PointerEventButton.right && e.kind == PointerEventKind.up) {
+					popup.show(ta.mouse-x, ta.mouse-y);
+				}
+			}
+			z: 10;
+		}
+
+		HorizontalLayout {
+			alignment: space-between;
+			HorizontalLayout {
+				alignment: start;
+				spacing: 8px;
+				checkbox := VCheckBox {
+					text: task.title;
+					checked: task.checked;
+					toggled => {
+						Backend.task_clicked(source-index, task-index)
+					}
+				}
+				for tag[tag-index] in task.tags: VTag {
+					text: tag;
+					size: 0.8rem;
+				}
+			}
+			
+		}
+
 	}
+	
 }

ui/components/CreateTaskOrEvent.slint

@@ -0,0 +1,95 @@
+import { Backend, TaskData } from "../Backend.slint";
+import { Button, VerticalBox, CheckBox, ScrollView, ComboBox } from "std-widgets.slint";
+import { VPopupIconMenu, VDatePicker, VTimePicker, VCheckBox, VButton, VTag, VText, VTextInput, Palette } from "@vynui";
+import { NewTaskData, SaveTaskData } from "../Backend.slint";
+
+export component CreateTaskOrEvent inherits Rectangle {
+
+	Rectangle {
+		border-color: newTaskTitleInput.text != "" ? Palette.card-background : transparent;
+		border-width: newTaskTitleInput.text != "" ? 4px : 0px;
+		border-radius: newTaskTitleInput.text != "" ? 8px : 0px;
+		animate border-color, border-width {
+			duration: 250ms;
+		}
+		VerticalLayout {
+			in-out property <int> task-or-event: 1;
+			spacing: 8px;
+			padding: newTaskTitleInput.text != "" ? 16px : 0px;
+			animate padding {
+				duration: 250ms;
+			}
+			Rectangle {
+				min-height: 0px;
+				max-height: newTaskTitleInput.text != "" ? 512px : 0px;
+				opacity: newTaskTitleInput.text != "" ? 1 : 0;
+				clip: true;
+				animate max-height, opacity {
+					 duration: 250ms;
+				}
+				
+				HorizontalLayout {
+					alignment: start;
+					spacing: 8px;
+					VerticalLayout {
+						alignment: end;
+						VButton {
+							text: task-or-event == 1 ? "Task" : "Event";
+							clicked => { task-or-event = task-or-event == 1 ? 0 : 1 }
+						}
+					}
+					VText { text: "for"; vertical-alignment: bottom;}
+					VerticalLayout {
+						alignment: end;
+						sourceInput := ComboBox {
+							model: Backend.sources; 
+						}
+					}
+					VText { text: "on"; vertical-alignment: bottom;}
+					taskDateInput := VDatePicker {
+						label: "Date";
+						enabled: true;
+					}
+					HorizontalLayout {
+						visible: task-or-event == 0;
+						HorizontalLayout {
+							spacing: 4px;
+							VText { text: "between"; vertical-alignment: bottom; }
+							eventStartTimeInput := VTimePicker {
+								label: "Starts at";
+							}
+							VText { text: "and"; vertical-alignment: bottom; }
+							eventEndTimeInput := VTimePicker {
+								label: "Ends at";
+							}
+						}
+					}
+					
+				}
+			}
+			newTaskTitleInput := VTextInput {
+				placeholder: "Add new Task / Event";
+				accepted => { 
+					if (task-or-event == 1) {
+						Backend.createTask({
+							sourceId: sourceInput.current-index,
+							eventId: -1,
+							title: newTaskTitleInput.text,
+							scheduled: taskDateInput.date.year != 0,
+							date: taskDateInput.date
+						})
+					} else {
+						Backend.createEvent({
+							sourceId: sourceInput.current-index,
+							title: newTaskTitleInput.text,
+							date: taskDateInput.date,
+							startsAt: eventStartTimeInput.time,
+							endsAt: eventEndTimeInput.time,
+						});
+					}
+					newTaskTitleInput.text = "";
+				}
+			}
+		}
+	}
+}

ui/components/TaskEdit.slint

@@ -0,0 +1,51 @@
+import { Backend, TaskData } from "../Backend.slint";
+import { Button, VerticalBox, CheckBox, ScrollView, ComboBox } from "std-widgets.slint";
+import { VPopupIconMenu, VDatePicker, VTimePicker, VCheckBox, VButton, VTag, VText, VTextInput, Palette } from "@vynui";
+import { NewTaskData, SaveTaskData } from "../Backend.slint";
+
+export component TaskEdit inherits VerticalLayout {
+	in-out property <SaveTaskData> task;
+	out property <bool> should-show;
+
+	public function show(task: SaveTaskData) {
+		root.task = task;
+		should-show = true;
+	}
+	public function close() {
+	    should-show = false;
+	}
+	callback accepted(SaveTaskData);
+
+	if !should-show : Rectangle {}
+
+	if should-show : Rectangle {
+		background: Palette.background;
+		border-radius: 8px;
+		VerticalLayout {
+			padding: 16px;
+			spacing: 8px;
+		
+			newTaskTitleInput := VTextInput {
+				text: root.task.title;
+				accepted => { 
+					root.accepted({
+						id: task.id,
+						sourceId: task.sourceId,
+						title: newTaskTitleInput.text,
+						scheduled: taskDateInput.date.year != 0,
+						date: taskDateInput.date
+					});
+					
+				}
+			}
+			HorizontalLayout {
+				alignment: start;
+				spacing: 8px;
+				taskDateInput := VDatePicker {
+					date: task.date;
+					enabled: true;
+				}
+			}
+		}
+	}
+}