about to refactor

1 files changed, 44 insertions, 13 deletions

diff --git a/karlgui/src/views/calendar.rs b/karlgui/src/views/calendar.rs
index c332b80..a861c73 100644
--- a/karlgui/src/views/calendar.rs
+++ b/karlgui/src/views/calendar.rs
@@ -2,7 +2,7 @@ use std::ops::Range;
 
 use crate::{helper::weekday_to_str, Globals};
 use chrono::{Duration, NaiveDateTime};
-use egui::Ui;
+use egui::{Color32, Sense, Stroke, Ui, Vec2};
 use egui_extras::TableBuilder;
 
 #[derive(Default)]
@@ -27,6 +27,8 @@ impl Calendar {
             return;
         };
 
+        let height = 50.0;
+
         TableBuilder::new(ui)
             .column(egui_extras::Size::exact(50.0))
             .columns(egui_extras::Size::remainder(), 7)
@@ -42,20 +44,34 @@ impl Calendar {
                 let mut cols: [Vec<u64>; 7] =
                     [vec![], vec![], vec![], vec![], vec![], vec![], vec![]];
                 for h in 0..24 {
-                    ui.row(50.0, |mut ui| {
+                    ui.row(height, |mut ui| {
                         ui.col(|ui| {
                             ui.heading(&format!("{h:02}:00"));
                         });
                         for d in 0..7 {
                             let _col = &mut cols[d];
                             let time = start_dt + Duration::days(d as i64) + Duration::hours(h);
+                            let time_end = time + Duration::hours(1) - Duration::seconds(1);
                             let instances_here =
-                                instances.iter().filter(|(_, r)| r.includes(&time));
+                                instances.iter().filter(|(_, r)| r.overlaps(time..time_end));
 
                             ui.col(|ui| {
                                 for (id, _) in instances_here {
-                                    g.tasks.get(id).unwrap();
-                                    ui.label(&format!("{id}"));
+                                    let task = g.tasks.get(id).unwrap();
+                                    let (rect, response) =
+                                        ui.allocate_at_least(Vec2::new(10.0, 50.0), Sense::hover());
+                                    ui.painter().rect(
+                                        rect,
+                                        0.0,
+                                        Color32::KHAKI,
+                                        Stroke::new(0.0, Color32::WHITE),
+                                    );
+                                    response.on_hover_ui_at_pointer(|ui| {
+                                        ui.heading(&task.name);
+                                        if let Some(d) = &task.description {
+                                            ui.label(d);
+                                        }
+                                    });
                                 }
                             });
                         }
@@ -65,16 +81,31 @@ impl Calendar {
     }
 }
 
-trait Includes<T> {
-    fn includes(&self, p: &T) -> bool;
+pub trait Overlaps<T> {
+    fn overlaps(&self, v: T) -> bool;
+}
+impl Overlaps<NaiveDateTime> for Range<NaiveDateTime> {
+    fn overlaps(&self, v: NaiveDateTime) -> bool {
+        self.start <= v && v < self.end
+    }
+}
+impl Overlaps<NaiveDateTime> for Range<Option<NaiveDateTime>> {
+    fn overlaps(&self, v: NaiveDateTime) -> bool {
+        match (self.start, self.end) {
+            (Some(s), Some(e)) => s <= v && v < e,
+            (Some(s), None) => s <= v,
+            (None, Some(e)) => v < e,
+            (None, None) => false,
+        }
+    }
 }
-impl Includes<NaiveDateTime> for Range<Option<NaiveDateTime>> {
-    fn includes(&self, p: &NaiveDateTime) -> bool {
-        match (&self.start, &self.end) {
+impl Overlaps<Range<NaiveDateTime>> for Range<Option<NaiveDateTime>> {
+    fn overlaps(&self, v: Range<NaiveDateTime>) -> bool {
+        match (self.start, self.end) {
             (None, None) => false,
-            (None, Some(e)) => p < e,
-            (Some(s), None) => s <= p,
-            (Some(s), Some(e)) => s <= p && p < e,
+            (None, Some(e)) => v.start < e,
+            (Some(s), None) => v.end > s,
+            (Some(s), Some(e)) => v.start < e && v.end > s,
         }
     }
 }