From 9bdeb4a022e7929c35b182312853a4590f25b6d2 Mon Sep 17 00:00:00 2001
From: Martin Ling <martin-git@earth.li>
Date: Tue, 20 Aug 2024 23:54:27 +0100
Subject: [PATCH 1/6] Define macros to avoid repetition in GObject subclass
 code.

---
 src/model/imp.rs    | 100 ++++++++++----------------
 src/model/mod.rs    | 170 ++++++++++++++++----------------------------
 src/row_data/imp.rs |  43 +++++------
 src/row_data/mod.rs |  71 ++++++++----------
 4 files changed, 146 insertions(+), 238 deletions(-)

diff --git a/src/model/imp.rs b/src/model/imp.rs
index 33a251ec..028e4c5b 100644
--- a/src/model/imp.rs
+++ b/src/model/imp.rs
@@ -8,73 +8,47 @@ use crate::capture::{TrafficItem, DeviceItem};
 use crate::row_data::{TrafficRowData, DeviceRowData};
 use crate::tree_list_model::TreeListModel;
 
-#[derive(Default)]
-pub struct TrafficModel {
-    pub(super) tree: RefCell<Option<TreeListModel<TrafficItem, super::TrafficModel, TrafficRowData>>>,
-}
-
-#[derive(Default)]
-pub struct DeviceModel {
-    pub(super) tree: RefCell<Option<TreeListModel<DeviceItem, super::DeviceModel, DeviceRowData>>>,
-}
-
-/// Basic declaration of our type for the GObject type system
-#[glib::object_subclass]
-impl ObjectSubclass for TrafficModel {
-    const NAME: &'static str = "TrafficModel";
-    type Type = super::TrafficModel;
-    type Interfaces = (gio::ListModel,);
-}
-#[glib::object_subclass]
-impl ObjectSubclass for DeviceModel {
-    const NAME: &'static str = "DeviceModel";
-    type Type = super::DeviceModel;
-    type Interfaces = (gio::ListModel,);
-}
-
-impl ObjectImpl for TrafficModel {}
-impl ObjectImpl for DeviceModel {}
-
-impl ListModelImpl for TrafficModel {
-    fn item_type(&self) -> glib::Type {
-        TrafficRowData::static_type()
-    }
-
-    fn n_items(&self) -> u32 {
-        match self.tree.borrow().as_ref() {
-            Some(tree) => tree.n_items(),
-            None => 0
+macro_rules! model {
+    ($model:ident, $item:ident, $row_data:ident) => {
+        #[derive(Default)]
+        pub struct $model {
+            pub(super) tree: RefCell<Option<
+                TreeListModel<$item, super::$model, $row_data>>>,
         }
-    }
 
-    fn item(&self, position: u32)
-        -> Option<glib::Object>
-    {
-        match self.tree.borrow().as_ref() {
-            Some(tree) => tree.item(position),
-            None => None
+        /// Basic declaration of our type for the GObject type system
+        #[glib::object_subclass]
+        impl ObjectSubclass for $model {
+            const NAME: &'static str = stringify!($model);
+            type Type = super::$model;
+            type Interfaces = (gio::ListModel,);
         }
-    }
-}
-
-impl ListModelImpl for DeviceModel {
-    fn item_type(&self) -> glib::Type {
-        DeviceRowData::static_type()
-    }
 
-    fn n_items(&self) -> u32 {
-        match self.tree.borrow().as_ref() {
-            Some(tree) => tree.n_items(),
-            None => 0
-        }
-    }
-
-    fn item(&self, position: u32)
-        -> Option<glib::Object>
-    {
-        match self.tree.borrow().as_ref() {
-            Some(tree) => tree.item(position),
-            None => None
+        impl ObjectImpl for $model {}
+
+        impl ListModelImpl for $model {
+            fn item_type(&self) -> glib::Type {
+                $row_data::static_type()
+            }
+
+            fn n_items(&self) -> u32 {
+                match self.tree.borrow().as_ref() {
+                    Some(tree) => tree.n_items(),
+                    None => 0
+                }
+            }
+
+            fn item(&self, position: u32)
+                -> Option<glib::Object>
+            {
+                match self.tree.borrow().as_ref() {
+                    Some(tree) => tree.item(position),
+                    None => None
+                }
+            }
         }
     }
 }
+
+model!(TrafficModel, TrafficItem, TrafficRowData);
+model!(DeviceModel, DeviceItem, DeviceRowData);
diff --git a/src/model/mod.rs b/src/model/mod.rs
index c64a6736..87cf786c 100644
--- a/src/model/mod.rs
+++ b/src/model/mod.rs
@@ -16,14 +16,6 @@ use anyhow::Error;
 use crate::capture::{CaptureReader, TrafficItem, DeviceItem};
 use crate::tree_list_model::{TreeListModel, ItemNodeRc};
 
-// Public part of the Model type.
-glib::wrapper! {
-    pub struct TrafficModel(ObjectSubclass<imp::TrafficModel>) @implements gio::ListModel;
-}
-glib::wrapper! {
-    pub struct DeviceModel(ObjectSubclass<imp::DeviceModel>) @implements gio::ListModel;
-}
-
 pub trait GenericModel<Item> where Self: Sized {
     const HAS_TIMES: bool;
     fn new(capture: CaptureReader,
@@ -41,106 +33,68 @@ pub trait GenericModel<Item> where Self: Sized {
     fn connectors(&self, item: &Item) -> String;
 }
 
-impl GenericModel<TrafficItem> for TrafficModel {
-    const HAS_TIMES: bool = true;
-
-    fn new(capture: CaptureReader,
-           #[cfg(any(test, feature="record-ui-test"))]
-           on_item_update: Rc<RefCell<dyn FnMut(u32, String)>>)
-        -> Result<Self, Error>
-    {
-        let model: TrafficModel = glib::Object::new::<TrafficModel>();
-        let tree = TreeListModel::new(
-            capture,
-            #[cfg(any(test, feature="record-ui-test"))]
-            on_item_update)?;
-        model.imp().tree.replace(Some(tree));
-        Ok(model)
-    }
-
-    fn set_expanded(&self,
-                    node: &ItemNodeRc<TrafficItem>,
-                    position: u32,
-                    expanded: bool)
-        -> Result<(), Error>
-    {
-        let tree_opt  = self.imp().tree.borrow();
-        let tree = tree_opt.as_ref().unwrap();
-        tree.set_expanded(self, node, position as u64, expanded)
-    }
-
-    fn update(&self) -> Result<bool, Error> {
-        let tree_opt = self.imp().tree.borrow();
-        let tree = tree_opt.as_ref().unwrap();
-        tree.update(self)
-    }
-
-    fn description(&self, item: &TrafficItem, detail: bool) -> String {
-        let tree_opt = self.imp().tree.borrow();
-        let tree = tree_opt.as_ref().unwrap();
-        tree.description(item, detail)
-    }
-
-    fn timestamp(&self, item: &TrafficItem) -> u64 {
-        let tree_opt = self.imp().tree.borrow();
-        let tree = tree_opt.as_ref().unwrap();
-        tree.timestamp(item)
-    }
-
-    fn connectors(&self, item: &TrafficItem) -> String {
-        let tree_opt = self.imp().tree.borrow();
-        let tree = tree_opt.as_ref().unwrap();
-        tree.connectors(item)
+macro_rules! model {
+    ($model: ident, $item: ident, $has_times: literal) => {
+        // Public part of the Model type.
+        glib::wrapper! {
+            pub struct $model(ObjectSubclass<imp::$model>)
+                @implements gio::ListModel;
+        }
+
+        impl GenericModel<$item> for $model {
+            const HAS_TIMES: bool = $has_times;
+
+            fn new(capture: CaptureReader,
+                   #[cfg(any(test, feature="record-ui-test"))]
+                   on_item_update: Rc<RefCell<dyn FnMut(u32, String)>>)
+                -> Result<Self, Error>
+            {
+                let model: $model = glib::Object::new::<$model>();
+                let tree = TreeListModel::new(
+                    capture,
+                    #[cfg(any(test, feature="record-ui-test"))]
+                    on_item_update)?;
+                model.imp().tree.replace(Some(tree));
+                Ok(model)
+            }
+
+            fn set_expanded(&self,
+                            node: &ItemNodeRc<$item>,
+                            position: u32,
+                            expanded: bool)
+                -> Result<(), Error>
+            {
+                let tree_opt  = self.imp().tree.borrow();
+                let tree = tree_opt.as_ref().unwrap();
+                tree.set_expanded(self, node, position as u64, expanded)
+            }
+
+            fn update(&self) -> Result<bool, Error> {
+                let tree_opt = self.imp().tree.borrow();
+                let tree = tree_opt.as_ref().unwrap();
+                tree.update(self)
+            }
+
+            fn description(&self, item: &$item, detail: bool) -> String {
+                let tree_opt = self.imp().tree.borrow();
+                let tree = tree_opt.as_ref().unwrap();
+                tree.description(item, detail)
+            }
+
+            fn timestamp(&self, item: &$item) -> u64 {
+                let tree_opt = self.imp().tree.borrow();
+                let tree = tree_opt.as_ref().unwrap();
+                tree.timestamp(item)
+            }
+
+            fn connectors(&self, item: &$item) -> String {
+                let tree_opt = self.imp().tree.borrow();
+                let tree = tree_opt.as_ref().unwrap();
+                tree.connectors(item)
+            }
+        }
     }
 }
 
-impl GenericModel<DeviceItem> for DeviceModel {
-    const HAS_TIMES: bool = false;
-
-    fn new(capture: CaptureReader,
-           #[cfg(any(test, feature="record-ui-test"))]
-           on_item_update: Rc<RefCell<dyn FnMut(u32, String)>>)
-        -> Result<Self, Error>
-    {
-        let model: DeviceModel = glib::Object::new::<DeviceModel>();
-        let tree = TreeListModel::new(
-            capture,
-            #[cfg(any(test, feature="record-ui-test"))]
-            on_item_update)?;
-        model.imp().tree.replace(Some(tree));
-        Ok(model)
-    }
-
-    fn set_expanded(&self,
-                    node: &ItemNodeRc<DeviceItem>,
-                    position: u32,
-                    expanded: bool)
-        -> Result<(), Error>
-    {
-        let tree_opt  = self.imp().tree.borrow();
-        let tree = tree_opt.as_ref().unwrap();
-        tree.set_expanded(self, node, position as u64, expanded)
-    }
-
-    fn update(&self) -> Result<bool, Error> {
-        let tree_opt = self.imp().tree.borrow();
-        let tree = tree_opt.as_ref().unwrap();
-        tree.update(self)
-    }
-
-    fn description(&self, item: &DeviceItem, detail: bool) -> String {
-        let tree_opt = self.imp().tree.borrow();
-        let tree = tree_opt.as_ref().unwrap();
-        tree.description(item, detail)
-    }
-
-    fn timestamp(&self, _item: &DeviceItem) -> u64 {
-        unreachable!();
-    }
-
-    fn connectors(&self, item: &DeviceItem) -> String {
-        let tree_opt = self.imp().tree.borrow();
-        let tree = tree_opt.as_ref().unwrap();
-        tree.connectors(item)
-    }
-}
+model!(TrafficModel, TrafficItem, true);
+model!(DeviceModel, DeviceItem, false);
diff --git a/src/row_data/imp.rs b/src/row_data/imp.rs
index f022ca34..66d3addf 100644
--- a/src/row_data/imp.rs
+++ b/src/row_data/imp.rs
@@ -4,31 +4,26 @@ use std::cell::RefCell;
 use crate::capture::{TrafficItem, DeviceItem};
 use crate::tree_list_model::ItemNodeRc;
 
-// The actual data structure that stores our values. This is not accessible
-// directly from the outside.
-#[derive(Default)]
-pub struct TrafficRowData {
-    pub(super) node: RefCell<Option<Result<ItemNodeRc<TrafficItem>, String>>>,
+macro_rules! row_data {
+    ($row_data: ident, $item: ident) => {
+        // The actual data structure that stores our values. This is not accessible
+        // directly from the outside.
+        #[derive(Default)]
+        pub struct $row_data {
+            pub(super) node: RefCell<Option<
+                Result<ItemNodeRc<$item>, String>>>,
+        }
 
-}
-
-#[derive(Default)]
-pub struct DeviceRowData {
-    pub(super) node: RefCell<Option<Result<ItemNodeRc<DeviceItem>, String>>>,
-}
-
-// Basic declaration of our type for the GObject type system
-#[glib::object_subclass]
-impl ObjectSubclass for TrafficRowData {
-    const NAME: &'static str = "TrafficRowData";
-    type Type = super::TrafficRowData;
-}
+        // Basic declaration of our type for the GObject type system
+        #[glib::object_subclass]
+        impl ObjectSubclass for $row_data {
+            const NAME: &'static str = stringify!($row_data);
+            type Type = super::$row_data;
+        }
 
-#[glib::object_subclass]
-impl ObjectSubclass for DeviceRowData {
-    const NAME: &'static str = "DeviceRowData";
-    type Type = super::DeviceRowData;
+        impl ObjectImpl for $row_data {}
+    }
 }
 
-impl ObjectImpl for TrafficRowData {}
-impl ObjectImpl for DeviceRowData {}
+row_data!(TrafficRowData, TrafficItem);
+row_data!(DeviceRowData, DeviceItem);
diff --git a/src/row_data/mod.rs b/src/row_data/mod.rs
index 54306925..da725666 100644
--- a/src/row_data/mod.rs
+++ b/src/row_data/mod.rs
@@ -15,59 +15,44 @@ use gtk::prelude::Cast;
 use crate::capture::{TrafficItem, DeviceItem};
 use crate::tree_list_model::ItemNodeRc;
 
-// Public part of the RowData type. This behaves like a normal gtk-rs-style GObject
-// binding
-glib::wrapper! {
-    pub struct TrafficRowData(ObjectSubclass<imp::TrafficRowData>);
-}
-glib::wrapper! {
-    pub struct DeviceRowData(ObjectSubclass<imp::DeviceRowData>);
-}
-
 pub trait GenericRowData<Item> where Item: Copy {
     fn new(node: Result<ItemNodeRc<Item>, String>) -> Self where Self: Sized;
     fn node(&self) -> Result<ItemNodeRc<Item>, String>;
 }
 
-impl GenericRowData<TrafficItem> for TrafficRowData {
-    fn new(node: Result<ItemNodeRc<TrafficItem>, String>) -> TrafficRowData {
-        let row: TrafficRowData = glib::Object::new::<TrafficRowData>();
-        row.imp().node.replace(Some(node));
-        row
-    }
-
-    fn node(&self) -> Result<ItemNodeRc<TrafficItem>, String> {
-        self.imp().node.borrow().as_ref().unwrap().clone()
-    }
-}
-
-impl GenericRowData<DeviceItem> for DeviceRowData {
-    fn new(node: Result<ItemNodeRc<DeviceItem>, String>) -> DeviceRowData {
-        let row: DeviceRowData = glib::Object::new::<DeviceRowData>();
-        row.imp().node.replace(Some(node));
-        row
-    }
-
-    fn node(&self) -> Result<ItemNodeRc<DeviceItem>, String> {
-        self.imp().node.borrow().as_ref().unwrap().clone()
-    }
-}
-
 pub trait ToGenericRowData<Item> {
     #[cfg(any(test, feature="record-ui-test"))]
     fn to_generic_row_data(self) -> Box<dyn GenericRowData<Item>>;
 }
 
-impl ToGenericRowData<TrafficItem> for glib::Object {
-    #[cfg(any(test, feature="record-ui-test"))]
-    fn to_generic_row_data(self) -> Box<dyn GenericRowData<TrafficItem>> {
-        Box::new(self.downcast::<TrafficRowData>().unwrap())
+macro_rules! row_data {
+    ($row_data: ident, $item: ident) => {
+        // Public part of the RowData type. This behaves like a normal gtk-rs-style GObject
+        // binding
+        glib::wrapper! {
+            pub struct $row_data(ObjectSubclass<imp::$row_data>);
+        }
+
+        impl GenericRowData<$item> for $row_data {
+            fn new(node: Result<ItemNodeRc<$item>, String>) -> $row_data{
+                let row: $row_data = glib::Object::new::<$row_data>();
+                row.imp().node.replace(Some(node));
+                row
+            }
+
+            fn node(&self) -> Result<ItemNodeRc<$item>, String> {
+                self.imp().node.borrow().as_ref().unwrap().clone()
+            }
+        }
+
+        impl ToGenericRowData<$item> for glib::Object {
+            #[cfg(any(test, feature="record-ui-test"))]
+            fn to_generic_row_data(self) -> Box<dyn GenericRowData<$item>> {
+                Box::new(self.downcast::<$row_data>().unwrap())
+            }
+        }
     }
 }
 
-impl ToGenericRowData<DeviceItem> for glib::Object {
-    #[cfg(any(test, feature="record-ui-test"))]
-    fn to_generic_row_data(self) -> Box<dyn GenericRowData<DeviceItem>> {
-        Box::new(self.downcast::<DeviceRowData>().unwrap())
-    }
-}
+row_data!(TrafficRowData, TrafficItem);
+row_data!(DeviceRowData, DeviceItem);

From 4de87b0b3f0085c7534cbfbc1dc0566e75696440 Mon Sep 17 00:00:00 2001
From: Martin Ling <martin-git@earth.li>
Date: Wed, 21 Aug 2024 04:49:57 +0100
Subject: [PATCH 2/6] Merge each GObject implementation into a single file.

---
 src/{expander/mod.rs => expander.rs} | 35 ++++++++++++++++-
 src/expander/imp.rs                  | 30 ---------------
 src/{model/mod.rs => model.rs}       | 57 +++++++++++++++++++++++++++-
 src/model/imp.rs                     | 54 --------------------------
 src/{row_data/mod.rs => row_data.rs} | 34 ++++++++++++++++-
 src/row_data/imp.rs                  | 29 --------------
 6 files changed, 120 insertions(+), 119 deletions(-)
 rename src/{expander/mod.rs => expander.rs} (66%)
 delete mode 100644 src/expander/imp.rs
 rename src/{model/mod.rs => model.rs} (65%)
 delete mode 100644 src/model/imp.rs
 rename src/{row_data/mod.rs => row_data.rs} (65%)
 delete mode 100644 src/row_data/imp.rs

diff --git a/src/expander/mod.rs b/src/expander.rs
similarity index 66%
rename from src/expander/mod.rs
rename to src/expander.rs
index 1c939903..f23d2fe2 100644
--- a/src/expander/mod.rs
+++ b/src/expander.rs
@@ -1,5 +1,3 @@
-mod imp;
-
 use std::cell::RefMut;
 use gtk::{
     self,
@@ -62,3 +60,36 @@ impl Default for ExpanderWrapper {
         Self::new()
     }
 }
+
+mod imp {
+    use gtk::{
+        self,
+        subclass::prelude::*,
+        glib::{self, SignalHandlerId},
+        Expander,
+        Label,
+    };
+    use std::cell::RefCell;
+
+    unsafe impl IsSubclassable<ExpanderWrapper> for Expander {}
+
+    #[derive(Default)]
+    pub struct ExpanderWrapper {
+        pub text_label: RefCell<Label>,
+        pub conn_label: RefCell<Label>,
+        pub expander: RefCell<Expander>,
+        pub handler: RefCell<Option<SignalHandlerId>>,
+    }
+
+    // Basic declaration of our type for the GObject type system
+    #[glib::object_subclass]
+    impl ObjectSubclass for ExpanderWrapper {
+        const NAME: &'static str = "ExpanderWrapper";
+        type Type = super::ExpanderWrapper;
+        type ParentType = gtk::Box;
+    }
+
+    impl BoxImpl for ExpanderWrapper {}
+    impl WidgetImpl for ExpanderWrapper {}
+    impl ObjectImpl for ExpanderWrapper {}
+}
diff --git a/src/expander/imp.rs b/src/expander/imp.rs
deleted file mode 100644
index bfab9528..00000000
--- a/src/expander/imp.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use gtk::{
-    self,
-    subclass::prelude::*,
-    glib::{self, SignalHandlerId},
-    Expander,
-    Label,
-};
-use std::cell::RefCell;
-
-unsafe impl IsSubclassable<ExpanderWrapper> for Expander {}
-
-#[derive(Default)]
-pub struct ExpanderWrapper {
-    pub text_label: RefCell<Label>,
-    pub conn_label: RefCell<Label>,
-    pub expander: RefCell<Expander>,
-    pub handler: RefCell<Option<SignalHandlerId>>,
-}
-
-// Basic declaration of our type for the GObject type system
-#[glib::object_subclass]
-impl ObjectSubclass for ExpanderWrapper {
-    const NAME: &'static str = "ExpanderWrapper";
-    type Type = super::ExpanderWrapper;
-    type ParentType = gtk::Box;
-}
-
-impl BoxImpl for ExpanderWrapper {}
-impl WidgetImpl for ExpanderWrapper {}
-impl ObjectImpl for ExpanderWrapper {}
diff --git a/src/model/mod.rs b/src/model.rs
similarity index 65%
rename from src/model/mod.rs
rename to src/model.rs
index 87cf786c..258c9395 100644
--- a/src/model/mod.rs
+++ b/src/model.rs
@@ -1,7 +1,5 @@
 //! Defines our custom model
 
-mod imp;
-
 #[cfg(any(test, feature="record-ui-test"))]
 use {
     std::cell::RefCell,
@@ -98,3 +96,58 @@ macro_rules! model {
 
 model!(TrafficModel, TrafficItem, true);
 model!(DeviceModel, DeviceItem, false);
+
+mod imp {
+    use gio::subclass::prelude::*;
+    use gtk::{gio, glib, prelude::*};
+
+    use std::cell::RefCell;
+    use crate::capture::{TrafficItem, DeviceItem};
+    use crate::row_data::{TrafficRowData, DeviceRowData};
+    use crate::tree_list_model::TreeListModel;
+
+    macro_rules! model {
+        ($model:ident, $item:ident, $row_data:ident) => {
+            #[derive(Default)]
+            pub struct $model {
+                pub(super) tree: RefCell<Option<
+                    TreeListModel<$item, super::$model, $row_data>>>,
+            }
+
+            /// Basic declaration of our type for the GObject type system
+            #[glib::object_subclass]
+            impl ObjectSubclass for $model {
+                const NAME: &'static str = stringify!($model);
+                type Type = super::$model;
+                type Interfaces = (gio::ListModel,);
+            }
+
+            impl ObjectImpl for $model {}
+
+            impl ListModelImpl for $model {
+                fn item_type(&self) -> glib::Type {
+                    $row_data::static_type()
+                }
+
+                fn n_items(&self) -> u32 {
+                    match self.tree.borrow().as_ref() {
+                        Some(tree) => tree.n_items(),
+                        None => 0
+                    }
+                }
+
+                fn item(&self, position: u32)
+                    -> Option<glib::Object>
+                {
+                    match self.tree.borrow().as_ref() {
+                        Some(tree) => tree.item(position),
+                        None => None
+                    }
+                }
+            }
+        }
+    }
+
+    model!(TrafficModel, TrafficItem, TrafficRowData);
+    model!(DeviceModel, DeviceItem, DeviceRowData);
+}
diff --git a/src/model/imp.rs b/src/model/imp.rs
deleted file mode 100644
index 028e4c5b..00000000
--- a/src/model/imp.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//! Defines the implementation of our model
-
-use gio::subclass::prelude::*;
-use gtk::{gio, glib, prelude::*};
-
-use std::cell::RefCell;
-use crate::capture::{TrafficItem, DeviceItem};
-use crate::row_data::{TrafficRowData, DeviceRowData};
-use crate::tree_list_model::TreeListModel;
-
-macro_rules! model {
-    ($model:ident, $item:ident, $row_data:ident) => {
-        #[derive(Default)]
-        pub struct $model {
-            pub(super) tree: RefCell<Option<
-                TreeListModel<$item, super::$model, $row_data>>>,
-        }
-
-        /// Basic declaration of our type for the GObject type system
-        #[glib::object_subclass]
-        impl ObjectSubclass for $model {
-            const NAME: &'static str = stringify!($model);
-            type Type = super::$model;
-            type Interfaces = (gio::ListModel,);
-        }
-
-        impl ObjectImpl for $model {}
-
-        impl ListModelImpl for $model {
-            fn item_type(&self) -> glib::Type {
-                $row_data::static_type()
-            }
-
-            fn n_items(&self) -> u32 {
-                match self.tree.borrow().as_ref() {
-                    Some(tree) => tree.n_items(),
-                    None => 0
-                }
-            }
-
-            fn item(&self, position: u32)
-                -> Option<glib::Object>
-            {
-                match self.tree.borrow().as_ref() {
-                    Some(tree) => tree.item(position),
-                    None => None
-                }
-            }
-        }
-    }
-}
-
-model!(TrafficModel, TrafficItem, TrafficRowData);
-model!(DeviceModel, DeviceItem, DeviceRowData);
diff --git a/src/row_data/mod.rs b/src/row_data.rs
similarity index 65%
rename from src/row_data/mod.rs
rename to src/row_data.rs
index da725666..e7459cd7 100644
--- a/src/row_data/mod.rs
+++ b/src/row_data.rs
@@ -4,8 +4,6 @@
 //! and are exposed via normal GObject properties. This allows us to use property
 //! bindings below to bind the values with what widgets display in the UI
 
-mod imp;
-
 use gtk::glib;
 use gtk::subclass::prelude::*;
 
@@ -56,3 +54,35 @@ macro_rules! row_data {
 
 row_data!(TrafficRowData, TrafficItem);
 row_data!(DeviceRowData, DeviceItem);
+
+mod imp {
+    use gtk::glib::{self, subclass::prelude::*};
+    use std::cell::RefCell;
+
+    use crate::capture::{TrafficItem, DeviceItem};
+    use crate::tree_list_model::ItemNodeRc;
+
+    macro_rules! row_data {
+        ($row_data: ident, $item: ident) => {
+            // The actual data structure that stores our values. This is not accessible
+            // directly from the outside.
+            #[derive(Default)]
+            pub struct $row_data {
+                pub(super) node: RefCell<Option<
+                    Result<ItemNodeRc<$item>, String>>>,
+            }
+
+            // Basic declaration of our type for the GObject type system
+            #[glib::object_subclass]
+            impl ObjectSubclass for $row_data {
+                const NAME: &'static str = stringify!($row_data);
+                type Type = super::$row_data;
+            }
+
+            impl ObjectImpl for $row_data {}
+        }
+    }
+
+    row_data!(TrafficRowData, TrafficItem);
+    row_data!(DeviceRowData, DeviceItem);
+}
diff --git a/src/row_data/imp.rs b/src/row_data/imp.rs
deleted file mode 100644
index 66d3addf..00000000
--- a/src/row_data/imp.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use gtk::glib::{self, subclass::prelude::*};
-use std::cell::RefCell;
-
-use crate::capture::{TrafficItem, DeviceItem};
-use crate::tree_list_model::ItemNodeRc;
-
-macro_rules! row_data {
-    ($row_data: ident, $item: ident) => {
-        // The actual data structure that stores our values. This is not accessible
-        // directly from the outside.
-        #[derive(Default)]
-        pub struct $row_data {
-            pub(super) node: RefCell<Option<
-                Result<ItemNodeRc<$item>, String>>>,
-        }
-
-        // Basic declaration of our type for the GObject type system
-        #[glib::object_subclass]
-        impl ObjectSubclass for $row_data {
-            const NAME: &'static str = stringify!($row_data);
-            type Type = super::$row_data;
-        }
-
-        impl ObjectImpl for $row_data {}
-    }
-}
-
-row_data!(TrafficRowData, TrafficItem);
-row_data!(DeviceRowData, DeviceItem);

From 4de48a5e7140bb744cb4120948c359eb88b1a403 Mon Sep 17 00:00:00 2001
From: Martin Ling <martin-git@earth.li>
Date: Wed, 21 Aug 2024 05:01:43 +0100
Subject: [PATCH 3/6] Remove comments left over from example code.

---
 src/expander.rs |  1 -
 src/model.rs    |  4 ----
 src/row_data.rs | 11 -----------
 3 files changed, 16 deletions(-)

diff --git a/src/expander.rs b/src/expander.rs
index f23d2fe2..122e8c7a 100644
--- a/src/expander.rs
+++ b/src/expander.rs
@@ -81,7 +81,6 @@ mod imp {
         pub handler: RefCell<Option<SignalHandlerId>>,
     }
 
-    // Basic declaration of our type for the GObject type system
     #[glib::object_subclass]
     impl ObjectSubclass for ExpanderWrapper {
         const NAME: &'static str = "ExpanderWrapper";
diff --git a/src/model.rs b/src/model.rs
index 258c9395..a7e04afb 100644
--- a/src/model.rs
+++ b/src/model.rs
@@ -1,5 +1,3 @@
-//! Defines our custom model
-
 #[cfg(any(test, feature="record-ui-test"))]
 use {
     std::cell::RefCell,
@@ -33,7 +31,6 @@ pub trait GenericModel<Item> where Self: Sized {
 
 macro_rules! model {
     ($model: ident, $item: ident, $has_times: literal) => {
-        // Public part of the Model type.
         glib::wrapper! {
             pub struct $model(ObjectSubclass<imp::$model>)
                 @implements gio::ListModel;
@@ -114,7 +111,6 @@ mod imp {
                     TreeListModel<$item, super::$model, $row_data>>>,
             }
 
-            /// Basic declaration of our type for the GObject type system
             #[glib::object_subclass]
             impl ObjectSubclass for $model {
                 const NAME: &'static str = stringify!($model);
diff --git a/src/row_data.rs b/src/row_data.rs
index e7459cd7..cdac24d9 100644
--- a/src/row_data.rs
+++ b/src/row_data.rs
@@ -1,9 +1,3 @@
-//! Our GObject subclass for carrying a name and count for the ListBox model
-//!
-//! Both name and count are stored in a RefCell to allow for interior mutability
-//! and are exposed via normal GObject properties. This allows us to use property
-//! bindings below to bind the values with what widgets display in the UI
-
 use gtk::glib;
 use gtk::subclass::prelude::*;
 
@@ -25,8 +19,6 @@ pub trait ToGenericRowData<Item> {
 
 macro_rules! row_data {
     ($row_data: ident, $item: ident) => {
-        // Public part of the RowData type. This behaves like a normal gtk-rs-style GObject
-        // binding
         glib::wrapper! {
             pub struct $row_data(ObjectSubclass<imp::$row_data>);
         }
@@ -64,15 +56,12 @@ mod imp {
 
     macro_rules! row_data {
         ($row_data: ident, $item: ident) => {
-            // The actual data structure that stores our values. This is not accessible
-            // directly from the outside.
             #[derive(Default)]
             pub struct $row_data {
                 pub(super) node: RefCell<Option<
                     Result<ItemNodeRc<$item>, String>>>,
             }
 
-            // Basic declaration of our type for the GObject type system
             #[glib::object_subclass]
             impl ObjectSubclass for $row_data {
                 const NAME: &'static str = stringify!($row_data);

From a5aa4a8124bbc802cb3236f818ab4933f8d430b8 Mon Sep 17 00:00:00 2001
From: Martin Ling <martin-git@earth.li>
Date: Wed, 21 Aug 2024 05:37:54 +0100
Subject: [PATCH 4/6] Add new comments to all GObject subclass implementations.

---
 src/expander.rs | 11 +++++++++++
 src/model.rs    | 24 ++++++++++++++++++++++++
 src/row_data.rs | 12 ++++++++++++
 3 files changed, 47 insertions(+)

diff --git a/src/expander.rs b/src/expander.rs
index 122e8c7a..c4f41bde 100644
--- a/src/expander.rs
+++ b/src/expander.rs
@@ -1,3 +1,5 @@
+//! GObject subclass for our custom widget.
+
 use std::cell::RefMut;
 use gtk::{
     self,
@@ -11,12 +13,14 @@ use gtk::{
 };
 
 glib::wrapper! {
+    /// The outer type exposed to our Rust code.
     pub struct ExpanderWrapper(ObjectSubclass<imp::ExpanderWrapper>)
     @extends gtk::Box, gtk::Widget,
     @implements gtk::Orientable;
 }
 
 impl ExpanderWrapper {
+    /// Create a new widget.
     pub fn new() -> ExpanderWrapper {
         let wrapper: ExpanderWrapper = glib::Object::new::<ExpanderWrapper>();
         wrapper.imp().text_label.replace(
@@ -33,22 +37,27 @@ impl ExpanderWrapper {
         wrapper
     }
 
+    /// Fetch the Expander from the widget.
     pub fn expander(&self) -> RefMut<Expander> {
         self.imp().expander.borrow_mut()
     }
 
+    /// Store a signal handler to be retained by this widget.
     pub fn set_handler(&self, handler: SignalHandlerId) {
         self.imp().handler.replace(Some(handler));
     }
 
+    /// Take the signal handler retained by this widget.
     pub fn take_handler(&self) -> Option<SignalHandlerId> {
         self.imp().handler.take().take()
     }
 
+    /// Set the summary text on this widget.
     pub fn set_text(&self, text: String) {
         self.imp().text_label.borrow_mut().set_text(&text);
     }
 
+    /// Set the connecting lines on this widget.
     pub fn set_connectors(&self, connectors: String) {
         self.imp().conn_label.borrow_mut().set_markup(
                 format!("<tt>{connectors}</tt>").as_str());
@@ -61,6 +70,7 @@ impl Default for ExpanderWrapper {
     }
 }
 
+/// The internal implementation module.
 mod imp {
     use gtk::{
         self,
@@ -73,6 +83,7 @@ mod imp {
 
     unsafe impl IsSubclassable<ExpanderWrapper> for Expander {}
 
+    /// The inner type to be used in the GObject type system.
     #[derive(Default)]
     pub struct ExpanderWrapper {
         pub text_label: RefCell<Label>,
diff --git a/src/model.rs b/src/model.rs
index a7e04afb..59437e42 100644
--- a/src/model.rs
+++ b/src/model.rs
@@ -1,3 +1,5 @@
+//! GObject subclasses implementing ListModel for each UI view.
+
 #[cfg(any(test, feature="record-ui-test"))]
 use {
     std::cell::RefCell,
@@ -12,25 +14,43 @@ use anyhow::Error;
 use crate::capture::{CaptureReader, TrafficItem, DeviceItem};
 use crate::tree_list_model::{TreeListModel, ItemNodeRc};
 
+/// Trait implemented by each of our ListModel implementations.
 pub trait GenericModel<Item> where Self: Sized {
+    /// Whether this model has timestamps.
     const HAS_TIMES: bool;
+
+    /// Create a new model instance for the given capture.
     fn new(capture: CaptureReader,
            #[cfg(any(test, feature="record-ui-test"))]
            on_item_update: Rc<RefCell<dyn FnMut(u32, String)>>)
         -> Result<Self, Error>;
+
+    /// Set whether a tree node is expanded.
     fn set_expanded(&self,
                     node: &ItemNodeRc<Item>,
                     position: u32,
                     expanded: bool)
         -> Result<(), Error>;
+
+    /// Update the model with new data from the capture.
+    ///
+    /// Returns true if there will be further updates in future.
     fn update(&self) -> Result<bool, Error>;
+
+    /// Fetch the description for a given item.
     fn description(&self, item: &Item, detail: bool) -> String;
+
+    /// Fetch the timestamp for a given item.
     fn timestamp(&self, item: &Item) -> u64;
+
+    /// Fetch the connecting lines for a given item.
     fn connectors(&self, item: &Item) -> String;
 }
 
+/// Define the outer type exposed to our Rust code.
 macro_rules! model {
     ($model: ident, $item: ident, $has_times: literal) => {
+
         glib::wrapper! {
             pub struct $model(ObjectSubclass<imp::$model>)
                 @implements gio::ListModel;
@@ -91,9 +111,11 @@ macro_rules! model {
     }
 }
 
+// Repeat the above boilerplate for each model.
 model!(TrafficModel, TrafficItem, true);
 model!(DeviceModel, DeviceItem, false);
 
+/// The internal implementation module.
 mod imp {
     use gio::subclass::prelude::*;
     use gtk::{gio, glib, prelude::*};
@@ -103,6 +125,7 @@ mod imp {
     use crate::row_data::{TrafficRowData, DeviceRowData};
     use crate::tree_list_model::TreeListModel;
 
+    /// Define the inner type to be used in the GObject type system.
     macro_rules! model {
         ($model:ident, $item:ident, $row_data:ident) => {
             #[derive(Default)]
@@ -144,6 +167,7 @@ mod imp {
         }
     }
 
+    // Repeat the above boilerplate for each model.
     model!(TrafficModel, TrafficItem, TrafficRowData);
     model!(DeviceModel, DeviceItem, DeviceRowData);
 }
diff --git a/src/row_data.rs b/src/row_data.rs
index cdac24d9..32dc0b9d 100644
--- a/src/row_data.rs
+++ b/src/row_data.rs
@@ -1,3 +1,5 @@
+//! GObject subclasses for row data in each UI view.
+
 use gtk::glib;
 use gtk::subclass::prelude::*;
 
@@ -7,16 +9,22 @@ use gtk::prelude::Cast;
 use crate::capture::{TrafficItem, DeviceItem};
 use crate::tree_list_model::ItemNodeRc;
 
+/// Trait implemented by each of our row data types.
 pub trait GenericRowData<Item> where Item: Copy {
+    /// Create a row for the given node.
     fn new(node: Result<ItemNodeRc<Item>, String>) -> Self where Self: Sized;
+
+    /// Fetch the node for this row.
     fn node(&self) -> Result<ItemNodeRc<Item>, String>;
 }
 
+/// Trait for converting an arbitrary GObject to one of our row data types.
 pub trait ToGenericRowData<Item> {
     #[cfg(any(test, feature="record-ui-test"))]
     fn to_generic_row_data(self) -> Box<dyn GenericRowData<Item>>;
 }
 
+/// Define the outer type exposed to our Rust code.
 macro_rules! row_data {
     ($row_data: ident, $item: ident) => {
         glib::wrapper! {
@@ -44,9 +52,11 @@ macro_rules! row_data {
     }
 }
 
+// Repeat the above boilerplate for each row type.
 row_data!(TrafficRowData, TrafficItem);
 row_data!(DeviceRowData, DeviceItem);
 
+/// The internal implementation module.
 mod imp {
     use gtk::glib::{self, subclass::prelude::*};
     use std::cell::RefCell;
@@ -54,6 +64,7 @@ mod imp {
     use crate::capture::{TrafficItem, DeviceItem};
     use crate::tree_list_model::ItemNodeRc;
 
+    /// Define the inner type to be used in the GObject type system.
     macro_rules! row_data {
         ($row_data: ident, $item: ident) => {
             #[derive(Default)]
@@ -72,6 +83,7 @@ mod imp {
         }
     }
 
+    // Repeat the above boilerplate for each row type.
     row_data!(TrafficRowData, TrafficItem);
     row_data!(DeviceRowData, DeviceItem);
 }

From b7ce5acb96890654e49e7c2bde2b2c4846e4ba3a Mon Sep 17 00:00:00 2001
From: Martin Ling <martin-git@earth.li>
Date: Wed, 21 Aug 2024 13:34:42 +0100
Subject: [PATCH 5/6] Remove unnecessary unsafe impl.

This is left over from when we subclassed gtk::Expander, but we now only
subclass gtk::Box.
---
 src/expander.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/expander.rs b/src/expander.rs
index c4f41bde..6506c297 100644
--- a/src/expander.rs
+++ b/src/expander.rs
@@ -81,8 +81,6 @@ mod imp {
     };
     use std::cell::RefCell;
 
-    unsafe impl IsSubclassable<ExpanderWrapper> for Expander {}
-
     /// The inner type to be used in the GObject type system.
     #[derive(Default)]
     pub struct ExpanderWrapper {

From 691e593494015eb07de7fd21fb1a0b6e791cf7c2 Mon Sep 17 00:00:00 2001
From: Martin Ling <martin-git@earth.li>
Date: Tue, 27 Aug 2024 11:04:28 +0100
Subject: [PATCH 6/6] Rename ExpanderWrapper to ItemWidget.

---
 src/{expander.rs => item_widget.rs} | 24 +++++++++---------
 src/main.rs                         |  2 +-
 src/tree_list_model.rs              | 14 +++++------
 src/ui.rs                           | 38 ++++++++++++++---------------
 4 files changed, 39 insertions(+), 39 deletions(-)
 rename src/{expander.rs => item_widget.rs} (81%)

diff --git a/src/expander.rs b/src/item_widget.rs
similarity index 81%
rename from src/expander.rs
rename to src/item_widget.rs
index 6506c297..6911227b 100644
--- a/src/expander.rs
+++ b/src/item_widget.rs
@@ -14,15 +14,15 @@ use gtk::{
 
 glib::wrapper! {
     /// The outer type exposed to our Rust code.
-    pub struct ExpanderWrapper(ObjectSubclass<imp::ExpanderWrapper>)
+    pub struct ItemWidget(ObjectSubclass<imp::ItemWidget>)
     @extends gtk::Box, gtk::Widget,
     @implements gtk::Orientable;
 }
 
-impl ExpanderWrapper {
+impl ItemWidget {
     /// Create a new widget.
-    pub fn new() -> ExpanderWrapper {
-        let wrapper: ExpanderWrapper = glib::Object::new::<ExpanderWrapper>();
+    pub fn new() -> ItemWidget {
+        let wrapper: ItemWidget = glib::Object::new::<ItemWidget>();
         wrapper.imp().text_label.replace(
             Label::builder()
                 .ellipsize(EllipsizeMode::End)
@@ -64,7 +64,7 @@ impl ExpanderWrapper {
     }
 }
 
-impl Default for ExpanderWrapper {
+impl Default for ItemWidget {
     fn default() -> Self {
         Self::new()
     }
@@ -83,7 +83,7 @@ mod imp {
 
     /// The inner type to be used in the GObject type system.
     #[derive(Default)]
-    pub struct ExpanderWrapper {
+    pub struct ItemWidget {
         pub text_label: RefCell<Label>,
         pub conn_label: RefCell<Label>,
         pub expander: RefCell<Expander>,
@@ -91,13 +91,13 @@ mod imp {
     }
 
     #[glib::object_subclass]
-    impl ObjectSubclass for ExpanderWrapper {
-        const NAME: &'static str = "ExpanderWrapper";
-        type Type = super::ExpanderWrapper;
+    impl ObjectSubclass for ItemWidget {
+        const NAME: &'static str = "ItemWidget";
+        type Type = super::ItemWidget;
         type ParentType = gtk::Box;
     }
 
-    impl BoxImpl for ExpanderWrapper {}
-    impl WidgetImpl for ExpanderWrapper {}
-    impl ObjectImpl for ExpanderWrapper {}
+    impl BoxImpl for ItemWidget {}
+    impl WidgetImpl for ItemWidget {}
+    impl ObjectImpl for ItemWidget {}
 }
diff --git a/src/main.rs b/src/main.rs
index d4d576ea..a7fcaf21 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -23,9 +23,9 @@ mod capture;
 mod compact_index;
 mod data_stream;
 mod decoder;
-mod expander;
 mod id;
 mod index_stream;
+mod item_widget;
 mod model;
 mod pcap;
 mod rcu;
diff --git a/src/tree_list_model.rs b/src/tree_list_model.rs
index 0398d639..94fb827d 100644
--- a/src/tree_list_model.rs
+++ b/src/tree_list_model.rs
@@ -18,7 +18,7 @@ use itertools::Itertools;
 use crate::capture::{CaptureReader, ItemSource};
 use crate::model::GenericModel;
 use crate::row_data::GenericRowData;
-use crate::expander::ExpanderWrapper;
+use crate::item_widget::ItemWidget;
 
 type RootNodeRc<Item> = Rc<RefCell<RootNode<Item>>>;
 pub type ItemNodeRc<Item> = Rc<RefCell<ItemNode<Item>>>;
@@ -92,7 +92,7 @@ pub struct ItemNode<Item> {
     children: Children<Item>,
 
     /// Widgets to update when this item changes.
-    widgets: RefCell<HashSet<ExpanderWrapper>>,
+    widgets: RefCell<HashSet<ItemWidget>>,
 }
 
 impl<Item> Children<Item> {
@@ -265,11 +265,11 @@ impl<Item> ItemNode<Item> where Item: Copy {
         self.children.total_count != 0
     }
 
-    pub fn attach_widget(&self, widget: &ExpanderWrapper) {
+    pub fn attach_widget(&self, widget: &ItemWidget) {
         self.widgets.borrow_mut().insert(widget.clone());
     }
 
-    pub fn remove_widget(&self, widget: &ExpanderWrapper) {
+    pub fn remove_widget(&self, widget: &ItemWidget) {
         self.widgets.borrow_mut().remove(widget);
     }
 }
@@ -779,12 +779,12 @@ where Item: 'static + Copy + Debug,
                     let mut on_item_update = self.on_item_update.borrow_mut();
                     on_item_update(position, summary.clone());
                 }
-                for widget in item_node.widgets.borrow().iter() {
-                    widget.set_text(summary.clone());
+                for item_widget in item_node.widgets.borrow().iter() {
+                    item_widget.set_text(summary.clone());
                     // If there were no previous children, the row was not
                     // previously expandable.
                     if children_added > 0 && old_direct_count == 0 {
-                        widget.expander().set_visible(true);
+                        item_widget.expander().set_visible(true);
                     }
                 }
             }
diff --git a/src/ui.rs b/src/ui.rs
index 26a752fd..fd3c0475 100644
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -74,7 +74,7 @@ use crate::capture::{
     PacketId,
 };
 use crate::decoder::Decoder;
-use crate::expander::ExpanderWrapper;
+use crate::item_widget::ItemWidget;
 use crate::pcap::{Loader, Writer};
 use crate::model::{GenericModel, TrafficModel, DeviceModel};
 use crate::row_data::{
@@ -578,8 +578,8 @@ fn create_view<Item, Model, RowData>(
     let selection_model = SingleSelection::new(Some(model.clone()));
     let factory = SignalListItemFactory::new();
     factory.connect_setup(move |_, list_item| {
-        let expander = ExpanderWrapper::new();
-        list_item.set_child(Some(&expander));
+        let widget = ItemWidget::new();
+        list_item.set_child(Some(&widget));
     });
     let bind = move |list_item: &ListItem| -> Result<(), Error> {
         let row = list_item
@@ -588,20 +588,20 @@ fn create_view<Item, Model, RowData>(
             .downcast::<RowData>()
             .or_else(|_| bail!("Item is not RowData"))?;
 
-        let expander_wrapper = list_item
+        let item_widget = list_item
             .child()
             .context("ListItem has no child widget")?
-            .downcast::<ExpanderWrapper>()
-            .or_else(|_| bail!("Child widget is not an ExpanderWrapper"))?;
+            .downcast::<ItemWidget>()
+            .or_else(|_| bail!("Child widget is not an ItemWidget"))?;
 
-        let expander = expander_wrapper.expander();
+        let expander = item_widget.expander();
         match row.node() {
             Ok(node_ref) => {
                 let node = node_ref.borrow();
                 let summary = bind_model.description(&node.item, false);
                 let connectors = bind_model.connectors(&node.item);
-                expander_wrapper.set_text(summary);
-                expander_wrapper.set_connectors(connectors);
+                item_widget.set_text(summary);
+                item_widget.set_connectors(connectors);
                 expander.set_visible(node.expandable());
                 expander.set_expanded(node.expanded());
                 let model = bind_model.clone();
@@ -620,12 +620,12 @@ fn create_view<Item, Model, RowData>(
                     display_error(
                         model.set_expanded(&node_ref, position, expanded))
                 });
-                expander_wrapper.set_handler(handler);
-                node.attach_widget(&expander_wrapper);
+                item_widget.set_handler(handler);
+                node.attach_widget(&item_widget);
             },
             Err(msg) => {
-                expander_wrapper.set_connectors("".to_string());
-                expander_wrapper.set_text(format!("Error: {msg}"));
+                item_widget.set_connectors("".to_string());
+                item_widget.set_text(format!("Error: {msg}"));
                 expander.set_visible(false);
             }
         };
@@ -638,18 +638,18 @@ fn create_view<Item, Model, RowData>(
             .downcast::<RowData>()
             .or_else(|_| bail!("Item is not RowData"))?;
 
-        let expander_wrapper = list_item
+        let item_widget = list_item
             .child()
             .context("ListItem has no child widget")?
-            .downcast::<ExpanderWrapper>()
-            .or_else(|_| bail!("Child widget is not an ExpanderWrapper"))?;
+            .downcast::<ItemWidget>()
+            .or_else(|_| bail!("Child widget is not an ItemWidget"))?;
 
         if let Ok(node_ref) = row.node() {
-            node_ref.borrow().remove_widget(&expander_wrapper);
+            node_ref.borrow().remove_widget(&item_widget);
         }
 
-        let expander = expander_wrapper.expander();
-        if let Some(handler) = expander_wrapper.take_handler() {
+        let expander = item_widget.expander();
+        if let Some(handler) = item_widget.take_handler() {
             expander.disconnect(handler);
         }