Update the historical view when a change happens in the db

This isn't recording real data. It's basically discarding all
information from the weight edit field. But it is creating a record.

emseries/src/types.rs

@@ -178,7 +178,7 @@ impl fmt::Display for RecordId {
 /// directly, as the database will create them.
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct Record<T: Clone + Recordable> {
-    pub(crate) id: RecordId,
+    pub id: RecordId,
     pub data: T,
 }
 

fitnesstrax/app/resources/style.css

@@ -2,32 +2,38 @@
     margin: 64px;
 }
 
-.welcome-title {
+.welcome__title {
     font-size: larger;
     padding: 8px;
 }
 
-.welcome-content {
+.welcome__content {
     padding: 8px;
 }
 
-.welcome-footer {
+.welcome__footer {
 }
 
-.dialog-row {
+.historical {
-    margin: 8px 0px 8px 0px;
+    margin: 32px;
+    border-radius: 8px;
+}
+
+.day-summary {
     padding: 8px;
 }
 
-.daysummary {
+.day-summary__date {
-    padding: 8px;
-}
-
-.daysummary-date {
     font-size: larger;
     margin-bottom: 8px;
 }
 
-.daysummary-weight {
+.day-summary__weight {
     margin: 4px;
 }
+
+.weight-view {
+    padding: 8px;
+    margin: 8px;
+}
+

fitnesstrax/app/src/app.rs

@@ -14,7 +14,8 @@ General Public License for more details.
 You should have received a copy of the GNU General Public License along with FitnessTrax. If not, see <https://www.gnu.org/licenses/>.
 */
 
-use emseries::Series;
+use crate::types::DayInterval;
+use emseries::{time_range, Record, RecordId, Series, Timestamp};
 use ft_core::TraxRecord;
 use std::{
     path::{Path, PathBuf},
@@ -29,7 +30,13 @@ pub enum AppInvocation {
 
     /// Request a set of records from the core.
     // Note: this will require a time range, but doesn't yet.
-    RequestRecords,
+    RequestRecords(DayInterval),
+
+    UpdateRecord(Record<TraxRecord>),
+
+    PutRecord(TraxRecord),
+
+    DeleteRecord(RecordId),
 }
 
 /// Responses are messages that the core sends to the UI. Though they are called responses, the
@@ -46,12 +53,14 @@ pub enum AppResponse {
 
     /// The database is open and here is a set of records. Typically, the set of records will be
     /// all of the records within a time frame, but this can actually be any set of records.
-    Records,
+    Records(Vec<Record<TraxRecord>>),
 
     /// The database has been changed. This message is useful for telling the UI that a significant
     /// change has happened. Further, the UI needs to save PathBuf to settings, because the
     /// gio::Settings system can't be run in the fully async background.
     DatabaseChanged(PathBuf),
+
+    RecordSaved(RecordId),
 }
 
 /// The real, headless application. This is where all of the logic will reside.
@@ -76,13 +85,43 @@ impl App {
                 self.open_db(&db_path);
                 AppResponse::DatabaseChanged(db_path)
             }
-            AppInvocation::RequestRecords => {
+            AppInvocation::RequestRecords(interval) => match &*self.database.read().unwrap() {
-                if self.database.read().unwrap().is_none() {
+                Some(database) => {
-                    AppResponse::NoDatabase
+                    let records = database
-                } else {
+                        .search(time_range(
-                    AppResponse::Records
+                            Timestamp::Date(interval.start),
+                            true,
+                            Timestamp::Date(interval.end),
+                            true,
+                        ))
+                        .map(|record| record.clone())
+                        .collect::<Vec<Record<TraxRecord>>>();
+                    AppResponse::Records(records)
                 }
-            }
+                None => AppResponse::NoDatabase,
+            },
+            AppInvocation::UpdateRecord(record) => match *self.database.write().unwrap() {
+                Some(ref mut database) => {
+                    let id = record.id.clone();
+                    database.update(record).unwrap();
+                    AppResponse::RecordSaved(id)
+                }
+                None => AppResponse::NoDatabase,
+            },
+            AppInvocation::PutRecord(record) => match *self.database.write().unwrap() {
+                Some(ref mut database) => {
+                    let id = database.put(record).unwrap();
+                    AppResponse::RecordSaved(id)
+                }
+                None => AppResponse::NoDatabase,
+            },
+            AppInvocation::DeleteRecord(record_id) => match *self.database.write().unwrap() {
+                Some(ref mut database) => {
+                    database.delete(&record_id).unwrap();
+                    AppResponse::Records(vec![])
+                }
+                None => AppResponse::NoDatabase,
+            },
         }
     }
 

fitnesstrax/app/src/app_window.rs

@@ -16,13 +16,14 @@ You should have received a copy of the GNU General Public License along with Fit
 
 use crate::{
     app::{AppInvocation, AppResponse},
+    components::DayDetail,
     views::{HistoricalView, PlaceholderView, View, ViewName, WelcomeView},
 };
 use adw::prelude::*;
 use async_channel::Sender;
-use chrono::{NaiveDate, TimeZone};
+use chrono::{FixedOffset, NaiveDate, TimeZone};
-use chrono_tz::America::Anchorage;
 use dimensioned::si::{KG, M, S};
+use emseries::{Record, RecordId};
 use ft_core::{Steps, TimeDistance, TraxRecord, Weight};
 use gio::resources_lookup_data;
 use gtk::STYLE_PROVIDER_PRIORITY_USER;
@@ -85,7 +86,6 @@ impl AppWindow {
 
         let initial_view = View::Placeholder(PlaceholderView::new().upcast());
 
-        // layout.append(&header);
         layout.append(&initial_view.widget());
 
         let nav_layout = gtk::Box::new(gtk::Orientation::Vertical, 0);
@@ -102,6 +102,10 @@ impl AppWindow {
         window.set_content(Some(&navigation));
         window.present();
 
+        let gesture = gtk::GestureClick::new();
+        gesture.connect_released(|_, _, _, _| println!("detected gesture"));
+        layout.add_controller(gesture);
+
         let s = Self {
             app_tx,
             layout,
@@ -118,18 +122,43 @@ impl AppWindow {
     }
 
     pub fn process_response(&self, response: AppResponse) {
+        println!("processing response: {:?}", response);
         match response {
             AppResponse::DatabaseChanged(db_path) => {
                 self.settings
                     .set_string("series-path", db_path.to_str().unwrap())
                     .unwrap();
-                self.change_view(ViewName::Historical);
+                self.change_view(ViewName::Historical(vec![]));
             }
             AppResponse::NoDatabase => {
                 self.change_view(ViewName::Welcome);
             }
-            AppResponse::Records => {
+            AppResponse::RecordSaved(_) => match *self.current_view.borrow_mut() {
-                self.change_view(ViewName::Historical);
+                View::Historical(ref view) => {
+                    let _ = self
+                        .app_tx
+                        .send_blocking(AppInvocation::RequestRecords(view.time_window()));
+                }
+                _ => {}
+            },
+            AppResponse::Records(records) => {
+                let mut current = self.current_view.borrow_mut();
+                if let View::Historical(ref view) = *current {
+                    view.set_records(records);
+                } else {
+                    self.layout.remove(&current.widget());
+                    *current = self.construct_view(ViewName::Historical(records));
+                    self.layout.append(&current.widget());
+                }
+                /*
+                match self.current_view.borrow_mut() {
+                View::Historical(ref view) => view.set_records(records),
+                mut current => {
+                    self.layout.remove(&current.widget());
+                    *current = self.construct_view(ViewName::Historical(records));
+                    self.layout.append(&current.widget());
+                }
+                */
             }
         }
     }
@@ -159,7 +188,38 @@ impl AppWindow {
                 })
                 .upcast(),
             ),
-            ViewName::Historical => View::Historical(HistoricalView::new(vec![]).upcast()),
+            ViewName::Historical(records) => View::Historical(
+                HistoricalView::new(records, {
+                    let s = self.clone();
+                    Rc::new(move |date: chrono::NaiveDate, records| {
+                        let layout = gtk::Box::new(gtk::Orientation::Vertical, 0);
+                        layout.append(&adw::HeaderBar::new());
+                        layout.append(&DayDetail::new(
+                            date,
+                            records,
+                            {
+                                let app_tx = s.app_tx.clone();
+                                move |record| {
+                                    let _ = app_tx.send_blocking(AppInvocation::PutRecord(record));
+                                }
+                            },
+                            {
+                                let app_tx = s.app_tx.clone();
+                                move |record| {
+                                    let _ =
+                                        app_tx.send_blocking(AppInvocation::UpdateRecord(record));
+                                }
+                            },
+                        ));
+                        let page = &adw::NavigationPage::builder()
+                            .title(date.format("%Y-%m-%d").to_string())
+                            .child(&layout)
+                            .build();
+                        s.navigation.push(page);
+                    })
+                })
+                .upcast(),
+            ),
         }
     }
 }

fitnesstrax/app/src/components/day.rs

@@ -16,12 +16,13 @@ You should have received a copy of the GNU General Public License along with Fit
 
 // use chrono::NaiveDate;
 // use ft_core::TraxRecord;
-use ft_core::TraxRecord;
+use dimensioned::si;
+use emseries::Record;
+use ft_core::{RecordType, TimeDistance, TraxRecord, Weight};
 use glib::Object;
 use gtk::{prelude::*, subclass::prelude::*};
-use std::cell::RefCell;
+use std::{cell::RefCell, rc::Rc};
 
-#[derive(Default)]
 pub struct DaySummaryPrivate {
     date: gtk::Label,
     weight: RefCell<Option<gtk::Label>>,
@@ -35,7 +36,7 @@ impl ObjectSubclass for DaySummaryPrivate {
 
     fn new() -> Self {
         let date = gtk::Label::builder()
-            .css_classes(["daysummary-date"])
+            .css_classes(["day-summary__date"])
             .halign(gtk::Align::Start)
             .build();
         Self {
@@ -59,14 +60,14 @@ impl DaySummary {
     pub fn new() -> Self {
         let s: Self = Object::builder().build();
         s.set_orientation(gtk::Orientation::Vertical);
-        s.set_css_classes(&["daysummary"]);
+        s.set_css_classes(&["day-summary"]);
 
         s.append(&s.imp().date);
 
         s
     }
 
-    pub fn set_data(&self, date: chrono::NaiveDate, records: Vec<TraxRecord>) {
+    pub fn set_data(&self, date: chrono::NaiveDate, records: Vec<Record<TraxRecord>>) {
         self.imp()
             .date
             .set_text(&date.format("%Y-%m-%d").to_string());
@@ -75,16 +76,339 @@ impl DaySummary {
             self.remove(weight_label);
         }
 
-        if let Some(TraxRecord::Weight(weight_record)) =
+        if let Some(Record {
-            records.iter().filter(|f| f.is_weight()).next()
+            data: TraxRecord::Weight(weight_record),
+            ..
+        }) = records.iter().filter(|f| f.data.is_weight()).next()
         {
             let label = gtk::Label::builder()
                 .halign(gtk::Align::Start)
                 .label(&format!("{}", weight_record.weight))
-                .css_classes(["daysummary-weight"])
+                .css_classes(["day-summary__weight"])
                 .build();
             self.append(&label);
             *self.imp().weight.borrow_mut() = Some(label);
         }
+
+        /*
+        self.append(
+            &gtk::Label::builder()
+                .halign(gtk::Align::Start)
+                .label("15km of biking in 60 minutes")
+                .build(),
+        );
+        */
+    }
+}
+
+pub struct DayDetailPrivate {
+    date: gtk::Label,
+    weight: RefCell<Option<gtk::Label>>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for DayDetailPrivate {
+    const NAME: &'static str = "DayDetail";
+    type Type = DayDetail;
+    type ParentType = gtk::Box;
+
+    fn new() -> Self {
+        let date = gtk::Label::builder()
+            .css_classes(["daysummary-date"])
+            .halign(gtk::Align::Start)
+            .build();
+        Self {
+            date,
+            weight: RefCell::new(None),
+        }
+    }
+}
+
+impl ObjectImpl for DayDetailPrivate {}
+impl WidgetImpl for DayDetailPrivate {}
+impl BoxImpl for DayDetailPrivate {}
+
+glib::wrapper! {
+    pub struct DayDetail(ObjectSubclass<DayDetailPrivate>) @extends gtk::Box, gtk::Widget, @implements gtk::Orientable;
+}
+
+impl DayDetail {
+    pub fn new<SaveRecordFn, UpdateRecordFn>(
+        date: chrono::NaiveDate,
+        records: Vec<Record<TraxRecord>>,
+        on_save_record: SaveRecordFn,
+        on_update_record: UpdateRecordFn,
+    ) -> Self
+    where
+        SaveRecordFn: Fn(TraxRecord) + 'static,
+        UpdateRecordFn: Fn(Record<TraxRecord>) + 'static,
+    {
+        let s: Self = Object::builder().build();
+        s.set_orientation(gtk::Orientation::Vertical);
+
+        let click_controller = gtk::GestureClick::new();
+        click_controller.connect_released({
+            let s = s.clone();
+            move |_, _, _, _| {
+                println!("clicked outside of focusable entity");
+                if let Some(widget) = s.focus_child().and_downcast_ref::<WeightView>() {
+                    println!("focused child is the weight view");
+                    widget.blur();
+                }
+            }
+        });
+        s.add_controller(click_controller);
+
+        let weight_record = records.iter().find_map(|record| match record {
+            Record {
+                id,
+                data: TraxRecord::Weight(record),
+            } => Some((id.clone(), record.clone())),
+            _ => None,
+        });
+
+        let weight_view = match weight_record {
+            Some((id, data)) => WeightView::new(Some(data.clone()), move |weight| {
+                on_update_record(Record {
+                    id: id.clone(),
+                    data: TraxRecord::Weight(Weight { date, weight }),
+                })
+            }),
+            None => WeightView::new(None, move |weight| {
+                on_save_record(TraxRecord::Weight(Weight { date, weight }));
+            }),
+        };
+        s.append(&weight_view);
+
+        records.into_iter().for_each(|record| {
+            let record_view = match record {
+                Record {
+                    data: TraxRecord::BikeRide(record),
+                    ..
+                } => Some(
+                    TimeDistanceView::new(RecordType::BikeRide, record).upcast::<gtk::Widget>(),
+                ),
+                Record {
+                    data: TraxRecord::Row(record),
+                    ..
+                } => Some(TimeDistanceView::new(RecordType::Row, record).upcast::<gtk::Widget>()),
+                Record {
+                    data: TraxRecord::Run(record),
+                    ..
+                } => Some(TimeDistanceView::new(RecordType::Row, record).upcast::<gtk::Widget>()),
+                Record {
+                    data: TraxRecord::Swim(record),
+                    ..
+                } => Some(TimeDistanceView::new(RecordType::Row, record).upcast::<gtk::Widget>()),
+                Record {
+                    data: TraxRecord::Walk(record),
+                    ..
+                } => Some(TimeDistanceView::new(RecordType::Row, record).upcast::<gtk::Widget>()),
+                _ => None,
+            };
+
+            if let Some(record_view) = record_view {
+                record_view.add_css_class("day-detail");
+                record_view.set_halign(gtk::Align::Start);
+
+                s.append(&record_view);
+            }
+        });
+
+        s
+    }
+}
+
+pub struct WeightViewPrivate {
+    record: RefCell<Option<Weight>>,
+    view: RefCell<gtk::Label>,
+    edit: RefCell<gtk::Entry>,
+    current: RefCell<gtk::Widget>,
+    on_edit_finished: RefCell<Box<dyn Fn(si::Kilogram<f64>)>>,
+}
+
+impl Default for WeightViewPrivate {
+    fn default() -> Self {
+        let view = gtk::Label::builder()
+            .css_classes(["card", "weight-view"])
+            .halign(gtk::Align::Start)
+            .can_focus(true)
+            .build();
+        let edit = gtk::Entry::builder().halign(gtk::Align::Start).build();
+
+        let current = view.clone();
+
+        Self {
+            record: RefCell::new(None),
+            view: RefCell::new(view),
+            edit: RefCell::new(edit),
+            current: RefCell::new(current.upcast()),
+            on_edit_finished: RefCell::new(Box::new(|_| {})),
+        }
+    }
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for WeightViewPrivate {
+    const NAME: &'static str = "WeightView";
+    type Type = WeightView;
+    type ParentType = gtk::Box;
+}
+
+impl ObjectImpl for WeightViewPrivate {}
+impl WidgetImpl for WeightViewPrivate {}
+impl BoxImpl for WeightViewPrivate {}
+
+glib::wrapper! {
+    pub struct WeightView(ObjectSubclass<WeightViewPrivate>) @extends gtk::Box, gtk::Widget;
+}
+
+impl WeightView {
+    pub fn new<OnEditFinished>(weight: Option<Weight>, on_edit_finished: OnEditFinished) -> Self
+    where
+        OnEditFinished: Fn(si::Kilogram<f64>) + 'static,
+    {
+        let s: Self = Object::builder().build();
+
+        *s.imp().on_edit_finished.borrow_mut() = Box::new(on_edit_finished);
+
+        *s.imp().record.borrow_mut() = weight;
+        s.view();
+
+        let view_click_controller = gtk::GestureClick::new();
+        view_click_controller.connect_released({
+            let s = s.clone();
+            move |_, _, _, _| {
+                s.edit();
+            }
+        });
+
+        s.imp().view.borrow().add_controller(view_click_controller);
+        s
+    }
+
+    fn view(&self) {
+        let view = self.imp().view.borrow();
+        match *self.imp().record.borrow() {
+            Some(ref record) => {
+                view.remove_css_class("dim_label");
+                view.set_label(&format!("{:?}", record.weight));
+            }
+            None => {
+                view.add_css_class("dim_label");
+                view.set_label("No weight recorded");
+            }
+        }
+        self.swap(view.clone().upcast());
+    }
+
+    fn edit(&self) {
+        let edit = self.imp().edit.borrow();
+        match *self.imp().record.borrow() {
+            Some(ref record) => edit.buffer().set_text(&format!("{:?}", record.weight)),
+            None => edit.buffer().set_text(""),
+        }
+        self.swap(edit.clone().upcast());
+        edit.grab_focus();
+    }
+
+    fn swap(&self, new_view: gtk::Widget) {
+        let mut current = self.imp().current.borrow_mut();
+        self.remove(&*current);
+        self.append(&new_view);
+        *current = new_view;
+    }
+
+    fn blur(&self) {
+        let edit = self.imp().edit.borrow();
+        if *self.imp().current.borrow() == *edit {
+            let w = edit.buffer().text().parse::<f64>().unwrap();
+            self.imp().on_edit_finished.borrow()(w * si::KG);
+            self.view();
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct TimeDistanceViewPrivate {
+    record: RefCell<Option<TimeDistance>>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for TimeDistanceViewPrivate {
+    const NAME: &'static str = "TimeDistanceView";
+    type Type = TimeDistanceView;
+    type ParentType = gtk::Box;
+}
+
+impl ObjectImpl for TimeDistanceViewPrivate {}
+impl WidgetImpl for TimeDistanceViewPrivate {}
+impl BoxImpl for TimeDistanceViewPrivate {}
+
+glib::wrapper! {
+    pub struct TimeDistanceView(ObjectSubclass<TimeDistanceViewPrivate>) @extends gtk::Box, gtk::Widget, @implements gtk::Orientable;
+}
+
+impl TimeDistanceView {
+    pub fn new(type_: RecordType, record: TimeDistance) -> Self {
+        let s: Self = Object::builder().build();
+        s.set_orientation(gtk::Orientation::Vertical);
+        s.set_hexpand(true);
+
+        let first_row = gtk::Box::builder().homogeneous(true).build();
+
+        first_row.append(
+            &gtk::Label::builder()
+                .halign(gtk::Align::Start)
+                .label(&record.datetime.format("%H:%M").to_string())
+                .build(),
+        );
+
+        first_row.append(
+            &gtk::Label::builder()
+                .halign(gtk::Align::Start)
+                .label(format!("{:?}", type_))
+                .build(),
+        );
+
+        first_row.append(
+            &gtk::Label::builder()
+                .halign(gtk::Align::Start)
+                .label(
+                    record
+                        .distance
+                        .map(|dist| format!("{}", dist))
+                        .unwrap_or("".to_owned()),
+                )
+                .build(),
+        );
+
+        first_row.append(
+            &gtk::Label::builder()
+                .halign(gtk::Align::Start)
+                .label(
+                    record
+                        .duration
+                        .map(|duration| format!("{}", duration))
+                        .unwrap_or("".to_owned()),
+                )
+                .build(),
+        );
+
+        s.append(&first_row);
+
+        s.append(
+            &gtk::Label::builder()
+                .halign(gtk::Align::Start)
+                .label(
+                    record
+                        .comments
+                        .map(|comments| format!("{}", comments))
+                        .unwrap_or("".to_owned()),
+                )
+                .build(),
+        );
+
+        s
     }
 }

fitnesstrax/app/src/components/mod.rs

@@ -15,8 +15,8 @@ You should have received a copy of the GNU General Public License along with Fit
 */
 
 mod day;
+pub use day::{DayDetail, DaySummary};
 
-pub use day::DaySummary;
 use glib::Object;
 use gtk::{prelude::*, subclass::prelude::*};
 use std::{cell::RefCell, path::PathBuf, rc::Rc};

fitnesstrax/app/src/main.rs

@@ -17,11 +17,13 @@ You should have received a copy of the GNU General Public License along with Fit
 mod app;
 mod app_window;
 mod components;
+mod types;
 mod views;
 
 use adw::prelude::*;
 use app_window::AppWindow;
 use std::{env, path::PathBuf};
+use types::DayInterval;
 
 const APP_ID_DEV: &str = "com.luminescent-dreams.fitnesstrax.dev";
 const APP_ID_PROD: &str = "com.luminescent-dreams.fitnesstrax";
@@ -86,7 +88,9 @@ fn main() {
         glib::spawn_future_local(async move {
             // The app requests data to start with. This kicks everything off. The response from
             // the app will cause the window to be updated shortly.
-            let _ = app_tx.send(app::AppInvocation::RequestRecords).await;
+            let _ = app_tx
+                .send(app::AppInvocation::RequestRecords(DayInterval::default()))
+                .await;
 
             while let Ok(response) = ui_rx.recv().await {
                 window.process_response(response);

fitnesstrax/app/src/types.rs

@@ -0,0 +1,47 @@
+use chrono::{Duration, Local, NaiveDate};
+
+// This interval doesn't feel right, either. The idea that I have a specific interval type for just
+// NaiveDate is odd. This should be genericized, as should the iterator. Also, it shouldn't live
+// here, but in utilities.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct DayInterval {
+    pub start: NaiveDate,
+    pub end: NaiveDate,
+}
+
+impl Default for DayInterval {
+    fn default() -> Self {
+        Self {
+            start: (Local::now() - Duration::days(7)).date_naive(),
+            end: Local::now().date_naive(),
+        }
+    }
+}
+
+impl DayInterval {
+    pub fn days(&self) -> impl Iterator<Item = NaiveDate> {
+        DayIterator {
+            current: self.start.clone(),
+            end: self.end.clone(),
+        }
+    }
+}
+
+struct DayIterator {
+    current: NaiveDate,
+    end: NaiveDate,
+}
+
+impl Iterator for DayIterator {
+    type Item = NaiveDate;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.current <= self.end {
+            let val = self.current.clone();
+            self.current += Duration::days(1);
+            Some(val)
+        } else {
+            None
+        }
+    }
+}

fitnesstrax/app/src/views/historical_view.rs

@@ -14,17 +14,21 @@ General Public License for more details.
 You should have received a copy of the GNU General Public License along with FitnessTrax. If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::components::DaySummary;
+use crate::{components::DaySummary, types::DayInterval};
-use emseries::{Recordable, Timestamp};
+use chrono::{Duration, Local, NaiveDate};
+use emseries::Record;
 use ft_core::TraxRecord;
 use glib::Object;
 use gtk::{prelude::*, subclass::prelude::*};
-use std::{cell::RefCell, collections::HashMap};
+use std::{cell::RefCell, collections::HashMap, rc::Rc};
 
 /// The historical view will show a window into the main database. It will show some version of
 /// daily summaries, daily details, and will provide all functions the user may need for editing
 /// records.
-pub struct HistoricalViewPrivate {}
+pub struct HistoricalViewPrivate {
+    time_window: RefCell<DayInterval>,
+    list_view: gtk::ListView,
+}
 
 #[glib::object_subclass]
 impl ObjectSubclass for HistoricalViewPrivate {
@@ -33,28 +37,6 @@ impl ObjectSubclass for HistoricalViewPrivate {
     type ParentType = gtk::Box;
 
     fn new() -> Self {
-        Self {}
-    }
-}
-
-impl ObjectImpl for HistoricalViewPrivate {}
-impl WidgetImpl for HistoricalViewPrivate {}
-impl BoxImpl for HistoricalViewPrivate {}
-
-glib::wrapper! {
-    pub struct HistoricalView(ObjectSubclass<HistoricalViewPrivate>) @extends gtk::Box, gtk::Widget, @implements gtk::Orientable;
-}
-
-impl HistoricalView {
-    pub fn new(records: Vec<TraxRecord>) -> Self {
-        let s: Self = Object::builder().build();
-        s.set_orientation(gtk::Orientation::Vertical);
-
-        let day_records: GroupedRecords = GroupedRecords::from(records);
-
-        let model = gio::ListStore::new::<DayRecords>();
-        model.extend_from_slice(&day_records.0);
-
         let factory = gtk::SignalListItemFactory::new();
         factory.connect_setup(move |_, list_item| {
             list_item
@@ -81,30 +63,79 @@ impl HistoricalView {
             summary.set_data(records.date(), records.records());
         });
 
-        let lst = gtk::ListView::builder()
+        Self {
-            .model(&gtk::NoSelection::new(Some(model)))
+            time_window: RefCell::new(DayInterval::default()),
-            .factory(&factory)
+            list_view: gtk::ListView::builder()
-            .single_click_activate(true)
+                .factory(&factory)
-            .build();
+                .single_click_activate(true)
-        lst.connect_activate(|s, idx| {
+                .build(),
-            // This gets triggered whenever the user clicks on an item on the list. What we
+        }
-            // actually want to do here is to open a modal dialog that shows all of the details of
+    }
-            // the day and which allows the user to edit items within that dialog.
+}
-            let item = s.model().unwrap().item(idx).unwrap();
+
-            let records = item.downcast_ref::<DayRecords>().unwrap();
+impl ObjectImpl for HistoricalViewPrivate {}
-            println!("list item activated: [{:?}] {:?}", idx, records.date());
+impl WidgetImpl for HistoricalViewPrivate {}
+impl BoxImpl for HistoricalViewPrivate {}
+
+glib::wrapper! {
+    pub struct HistoricalView(ObjectSubclass<HistoricalViewPrivate>) @extends gtk::Box, gtk::Widget, @implements gtk::Orientable;
+}
+
+impl HistoricalView {
+    pub fn new<SelectFn>(records: Vec<Record<TraxRecord>>, on_select_day: Rc<SelectFn>) -> Self
+    where
+        SelectFn: Fn(chrono::NaiveDate, Vec<Record<TraxRecord>>) + 'static,
+    {
+        let s: Self = Object::builder().build();
+        s.set_orientation(gtk::Orientation::Vertical);
+        s.set_css_classes(&["historical"]);
+
+        let grouped_records =
+            GroupedRecords::new((*s.imp().time_window.borrow()).clone()).with_data(records);
+
+        let mut model = gio::ListStore::new::<DayRecords>();
+        model.extend(grouped_records.items());
+        s.imp()
+            .list_view
+            .set_model(Some(&gtk::NoSelection::new(Some(model))));
+
+        s.imp().list_view.connect_activate({
+            let on_select_day = on_select_day.clone();
+            move |s, idx| {
+                // This gets triggered whenever the user clicks on an item on the list. What we
+                // actually want to do here is to open a modal dialog that shows all of the details of
+                // the day and which allows the user to edit items within that dialog.
+                let item = s.model().unwrap().item(idx).unwrap();
+                let records = item.downcast_ref::<DayRecords>().unwrap();
+                on_select_day(records.date(), records.records());
+            }
         });
 
-        s.append(&lst);
+        s.append(&s.imp().list_view);
 
         s
     }
+
+    pub fn set_records(&self, records: Vec<Record<TraxRecord>>) {
+        println!("set_records: {:?}", records);
+        let grouped_records =
+            GroupedRecords::new((self.imp().time_window.borrow()).clone()).with_data(records);
+        let mut model = gio::ListStore::new::<DayRecords>();
+        model.extend(grouped_records.items());
+        self.imp()
+            .list_view
+            .set_model(Some(&gtk::NoSelection::new(Some(model))));
+    }
+
+    pub fn time_window(&self) -> DayInterval {
+        self.imp().time_window.borrow().clone()
+    }
 }
 
 #[derive(Default)]
 pub struct DayRecordsPrivate {
     date: RefCell<chrono::NaiveDate>,
-    records: RefCell<Vec<TraxRecord>>,
+    records: RefCell<Vec<Record<TraxRecord>>>,
 }
 
 #[glib::object_subclass]
@@ -120,7 +151,7 @@ glib::wrapper! {
 }
 
 impl DayRecords {
-    pub fn new(date: chrono::NaiveDate, records: Vec<TraxRecord>) -> Self {
+    pub fn new(date: chrono::NaiveDate, records: Vec<Record<TraxRecord>>) -> Self {
         let s: Self = Object::builder().build();
 
         *s.imp().date.borrow_mut() = date;
@@ -133,36 +164,53 @@ impl DayRecords {
         self.imp().date.borrow().clone()
     }
 
-    pub fn records(&self) -> Vec<TraxRecord> {
+    pub fn records(&self) -> Vec<Record<TraxRecord>> {
         self.imp().records.borrow().clone()
     }
 
-    pub fn add_record(&self, record: TraxRecord) {
+    pub fn add_record(&self, record: Record<TraxRecord>) {
         self.imp().records.borrow_mut().push(record);
     }
 }
 
-struct GroupedRecords(Vec<DayRecords>);
+// This isn't feeling quite right. DayRecords is a glib object, but I'm not sure that I want to
+// really be passing that around. It seems not generic enough. I feel like this whole grouped
+// records thing can be made more generic.
+struct GroupedRecords {
+    interval: DayInterval,
+    data: HashMap<NaiveDate, DayRecords>,
+}
 
-impl From<Vec<TraxRecord>> for GroupedRecords {
+impl GroupedRecords {
-    fn from(records: Vec<TraxRecord>) -> GroupedRecords {
+    fn new(interval: DayInterval) -> Self {
-        GroupedRecords(
+        let mut s = Self {
-            records
+            interval: interval.clone(),
-                .into_iter()
+            data: HashMap::new(),
-                .fold(HashMap::new(), |mut acc, rec| {
+        };
-                    let date = match rec.timestamp() {
+        interval.days().for_each(|date| {
-                        Timestamp::DateTime(dtz) => dtz.date_naive(),
+            let _ = s.data.insert(date, DayRecords::new(date, vec![]));
-                        Timestamp::Date(date) => date,
+        });
-                    };
+        s
-                    acc.entry(date)
+    }
-                        .and_modify(|entry: &mut DayRecords| (*entry).add_record(rec.clone()))
+
-                        .or_insert(DayRecords::new(date, vec![rec]));
+    fn with_data(mut self, records: Vec<Record<TraxRecord>>) -> Self {
-                    acc
+        records.into_iter().for_each(|record| {
-                })
+            self.data
-                .values()
+                .entry(record.date())
-                .cloned()
+                .and_modify(|entry: &mut DayRecords| (*entry).add_record(record.clone()))
-                .collect::<Vec<DayRecords>>(),
+                .or_insert(DayRecords::new(record.date(), vec![record]));
-        )
+        });
+
+        self
+    }
+
+    fn items<'a>(&'a self) -> impl Iterator<Item = DayRecords> + 'a {
+        self.interval.days().map(|date| {
+            self.data
+                .get(&date)
+                .map(|rec| rec.clone())
+                .unwrap_or(DayRecords::new(date, vec![]))
+        })
     }
 }
 
@@ -170,7 +218,6 @@ impl From<Vec<TraxRecord>> for GroupedRecords {
 mod test {
     use super::GroupedRecords;
     use chrono::{FixedOffset, NaiveDate, TimeZone};
-    use chrono_tz::America::Anchorage;
     use dimensioned::si::{KG, M, S};
     use emseries::{Record, RecordId};
     use ft_core::{Steps, TimeDistance, TraxRecord, Weight};
@@ -178,36 +225,51 @@ mod test {
     #[test]
     fn groups_records() {
         let records = vec![
-            TraxRecord::Steps(Steps {
+            Record {
-                date: NaiveDate::from_ymd_opt(2023, 10, 13).unwrap(),
+                id: RecordId::default(),
-                count: 1500,
+                data: TraxRecord::Steps(Steps {
-            }),
+                    date: NaiveDate::from_ymd_opt(2023, 10, 13).unwrap(),
-            TraxRecord::Weight(Weight {
+                    count: 1500,
-                date: NaiveDate::from_ymd_opt(2023, 10, 13).unwrap(),
+                }),
-                weight: 85. * KG,
+            },
-            }),
+            Record {
-            TraxRecord::Weight(Weight {
+                id: RecordId::default(),
-                date: NaiveDate::from_ymd_opt(2023, 10, 14).unwrap(),
+                data: TraxRecord::Weight(Weight {
-                weight: 86. * KG,
+                    date: NaiveDate::from_ymd_opt(2023, 10, 13).unwrap(),
-            }),
+                    weight: 85. * KG,
-            TraxRecord::BikeRide(TimeDistance {
+                }),
-                datetime: FixedOffset::west_opt(10 * 60 * 60)
+            },
-                    .unwrap()
+            Record {
-                    .with_ymd_and_hms(2019, 6, 15, 12, 0, 0)
+                id: RecordId::default(),
-                    .unwrap(),
+                data: TraxRecord::Weight(Weight {
-                distance: Some(1000. * M),
+                    date: NaiveDate::from_ymd_opt(2023, 10, 14).unwrap(),
-                duration: Some(150. * S),
+                    weight: 86. * KG,
-                comments: Some("Test Comments".to_owned()),
+                }),
-            }),
+            },
-            TraxRecord::BikeRide(TimeDistance {
+            Record {
-                datetime: FixedOffset::west_opt(10 * 60 * 60)
+                id: RecordId::default(),
-                    .unwrap()
+                data: TraxRecord::BikeRide(TimeDistance {
-                    .with_ymd_and_hms(2019, 6, 15, 23, 0, 0)
+                    datetime: FixedOffset::west_opt(10 * 60 * 60)
-                    .unwrap(),
+                        .unwrap()
-                distance: Some(1000. * M),
+                        .with_ymd_and_hms(2019, 6, 15, 12, 0, 0)
-                duration: Some(150. * S),
+                        .unwrap(),
-                comments: Some("Test Comments".to_owned()),
+                    distance: Some(1000. * M),
-            }),
+                    duration: Some(150. * S),
+                    comments: Some("Test Comments".to_owned()),
+                }),
+            },
+            Record {
+                id: RecordId::default(),
+                data: TraxRecord::BikeRide(TimeDistance {
+                    datetime: FixedOffset::west_opt(10 * 60 * 60)
+                        .unwrap()
+                        .with_ymd_and_hms(2019, 6, 15, 23, 0, 0)
+                        .unwrap(),
+                    distance: Some(1000. * M),
+                    duration: Some(150. * S),
+                    comments: Some("Test Comments".to_owned()),
+                }),
+            },
         ];
 
         let groups = GroupedRecords::from(records).0;

fitnesstrax/app/src/views/mod.rs

@@ -25,10 +25,13 @@ pub use placeholder_view::PlaceholderView;
 mod welcome_view;
 pub use welcome_view::WelcomeView;
 
+use emseries::Record;
+use ft_core::TraxRecord;
+
 #[derive(Clone, Debug, PartialEq)]
 pub enum ViewName {
     Welcome,
-    Historical,
+    Historical(Vec<Record<TraxRecord>>),
 }
 
 pub enum View {

fitnesstrax/app/src/views/welcome_view.rs

@@ -55,11 +55,10 @@ impl WelcomeView {
         // branch.
         let title = gtk::Label::builder()
             .label("Welcome to FitnessTrax")
-            .css_classes(["welcome-title"])
+            .css_classes(["welcome__title"])
             .build();
 
         let content = gtk::Box::builder()
-            .css_classes(["model-content"])
             .orientation(gtk::Orientation::Vertical)
             .vexpand(true)
             .build();

fitnesstrax/core/src/lib.rs

@@ -1,3 +1,4 @@
 mod legacy;
+
 mod types;
-pub use types::{Steps, TimeDistance, TraxRecord, Weight};
+pub use types::{RecordType, Steps, TimeDistance, TraxRecord, Weight};

fitnesstrax/core/src/types.rs

@@ -54,6 +54,17 @@ pub struct Weight {
     pub weight: si::Kilogram<f64>,
 }
 
+#[derive(Clone, Debug, PartialEq)]
+pub enum RecordType {
+    BikeRide,
+    Row,
+    Run,
+    Steps,
+    Swim,
+    Walk,
+    Weight,
+}
+
 /// The unified data structure for all records that are part of the app.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum TraxRecord {
@@ -67,6 +78,18 @@ pub enum TraxRecord {
 }
 
 impl TraxRecord {
+    pub fn workout_type(&self) -> RecordType {
+        match self {
+            TraxRecord::BikeRide(_) => RecordType::BikeRide,
+            TraxRecord::Row(_) => RecordType::Row,
+            TraxRecord::Run(_) => RecordType::Run,
+            TraxRecord::Steps(_) => RecordType::Steps,
+            TraxRecord::Swim(_) => RecordType::Swim,
+            TraxRecord::Walk(_) => RecordType::Walk,
+            TraxRecord::Weight(_) => RecordType::Weight,
+        }
+    }
+
     pub fn is_weight(&self) -> bool {
         match self {
             TraxRecord::Weight(_) => true,