Several bugfixes

- Fixed event invisibility when offset is after event's half width
- Fixed event being shown outside timeline component
- When timer reaches 24:00:00, new day is automatically started

src/main.rs

@@ -5,7 +5,7 @@ use std::{error::Error, rc::Rc, sync::{Arc, Mutex}};
 
 use aliveline::{config::Config, load_config, log::{Event, Log}};
 use chrono::{Datelike, Timelike};
-use slint::{Model, ModelRc, SharedString, ToSharedString, VecModel};
+use slint::{Model, ModelRc, SharedString, ToSharedString, VecModel, Weak};
 use toml::value::{Date as TomlDate, Time};
 
 slint::include_modules!();
@@ -46,6 +46,20 @@ impl From<TimelineEvent> for Event {
     }
 }
 
+fn load_log(ui_weak: Weak<AppWindow>, log: Arc<Mutex<Log>>) {
+    let ui = ui_weak.unwrap();
+    let log_guard = log.lock().expect("Log shouldn't be used twice");
+    let events: Vec<TimelineEvent> = (*log_guard)
+        .events
+        .iter()
+        .map(|event| TimelineEvent::from((*event).clone()))
+        .collect();
+    let in_progress = events.iter().any(|event| !event.finished);
+    let model: ModelRc<TimelineEvent> = Rc::new(VecModel::from(events)).into();
+    ui.set_record_events(model);
+    ui.set_in_progress(in_progress);
+}
+
 fn main() -> Result<(), Box<dyn Error>> {
     let ui = AppWindow::new()?;
     
@@ -61,23 +75,9 @@ fn main() -> Result<(), Box<dyn Error>> {
     let config: Arc<Config> = Arc::new(load_config());
     let writing_log: Arc<Mutex<Log>> = Arc::new(Mutex::new(Log::load_from(&config, date)));
 
-    {
-        let ui_weak = ui.as_weak();
-        let log = writing_log.clone();
-        (move || {
-            let ui = ui_weak.unwrap();
-            let log_guard = log.lock().expect("Log shouldn't be used twice");
-            let events: Vec<TimelineEvent> = (*log_guard)
-                .events
-                .iter()
-                .map(|event| TimelineEvent::from((*event).clone()))
-                .collect();
-            let in_progress = events.iter().any(|event| !event.finished);
-            let model: ModelRc<TimelineEvent> = Rc::new(VecModel::from(events)).into();
-            ui.set_record_events(model);
-            ui.set_in_progress(in_progress);
-        })()
-    }
+    let ui_weak = ui.as_weak();
+    let log = writing_log.clone();
+    load_log(ui_weak, log);
 
     ui.invoke_update_record_offset(offset as i32);
 
@@ -165,7 +165,8 @@ fn main() -> Result<(), Box<dyn Error>> {
             let ui = ui_weak.unwrap();
             let events_rc = ui.get_record_events();
             let events = events_rc.as_any()
-                .downcast_ref::<VecModel<TimelineEvent>>().unwrap();
+                .downcast_ref::<VecModel<TimelineEvent>>()
+                .unwrap();
             let offset = ui.get_record_offset();
             
             let event_id = events.iter()
@@ -182,9 +183,9 @@ fn main() -> Result<(), Box<dyn Error>> {
 
             {
                 let mut log_guard = log.lock().expect("Log shouldn't be used twice");
-                (*log_guard).events.push(Event::from(new_event.clone()));
-                let index = (*log_guard).events.iter().position(|data| !data.finished).unwrap();
-                (*log_guard).events.swap_remove(index);
+                log_guard.events.push(Event::from(new_event.clone()));
+                let index = log_guard.events.iter().position(|data| !data.finished).unwrap();
+                log_guard.events.swap_remove(index);
             }
 
             ui.invoke_save_log();
@@ -202,6 +203,47 @@ fn main() -> Result<(), Box<dyn Error>> {
         }
     });
 
+    ui.on_new_day_started({
+        let ui_weak = ui.as_weak();
+        let log = writing_log.clone();
+        move || {
+            let ui = ui_weak.unwrap();
+            
+            let new_event: Option<Event> = {
+                let log_guard = log.lock().expect("Log shouldn't be used twice");
+
+                let maybe_unfinished_event = log_guard.events.iter().find(|event| !event.finished);
+                match maybe_unfinished_event {
+                    Some(unfinished_event) => Some(Event::new(unfinished_event.name.clone(), 0, 0, false)),
+                    None => None
+                }
+            };
+
+            ui.invoke_stop_event();
+
+            {
+                let mut log_guard = log.lock().expect("Log shouldn't be used twice");
+                log_guard.events.clear();
+                let now = chrono::Local::now();
+
+                let date = TomlDate {
+                    year: now.year() as u16,
+                    month: now.month() as u8,
+                    day: now.day() as u8
+                };
+
+                log_guard.date = date;
+                log_guard.events.clear();
+            
+                if let Some(event) = new_event {
+                    log_guard.events.push(event);
+                }
+            }
+
+            load_log(ui.as_weak(), log.clone());
+            ui.invoke_save_log();
+        }
+    });
 
     ui.run()?;