deps: update ratatui version (#1362)

* cargo update ratatui

* replace convert_arc_labels with convert_mem_labels

* remove redundant generic

---------

Co-authored-by: Clement Tsang <34804052+ClementTsang@users.noreply.github.com>

19 files changed, 99 insertions, 140 deletions

diff --git a/src/bin/main.rs b/src/bin/main.rs
index f75b1505..5fc02bfe 100644
--- a/src/bin/main.rs
+++ b/src/bin/main.rs
@@ -287,7 +287,8 @@ fn main() -> Result<()> {
 
                             #[cfg(feature = "zfs")]
                             {
-                                let arc_labels = convert_arc_labels(&app.data_collection);
+                                let arc_labels =
+                                    convert_mem_label(&app.data_collection.arc_harvest);
                                 app.converted_data.arc_labels = arc_labels;
                             }
                         }
diff --git a/src/canvas.rs b/src/canvas.rs
index 72890477..44a74cea 100644
--- a/src/canvas.rs
+++ b/src/canvas.rs
@@ -211,7 +211,7 @@ impl Painter {
         self.styled_help_text = styled_help_spans.into_iter().map(Line::from).collect();
     }
 
-    fn draw_frozen_indicator<B: Backend>(&self, f: &mut Frame<'_, B>, draw_loc: Rect) {
+    fn draw_frozen_indicator(&self, f: &mut Frame<'_>, draw_loc: Rect) {
         f.render_widget(
             Paragraph::new(Span::styled(
                 "Frozen, press 'f' to unfreeze",
@@ -767,8 +767,8 @@ impl Painter {
         Ok(())
     }
 
-    fn draw_widgets_with_constraints<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, widgets: &BottomColRow,
+    fn draw_widgets_with_constraints(
+        &self, f: &mut Frame<'_>, app_state: &mut App, widgets: &BottomColRow,
         widget_draw_locs: &[Rect],
     ) {
         use BottomWidgetType::*;
diff --git a/src/canvas/dialogs/dd_dialog.rs b/src/canvas/dialogs/dd_dialog.rs
index 35a0c067..876552bf 100644
--- a/src/canvas/dialogs/dd_dialog.rs
+++ b/src/canvas/dialogs/dd_dialog.rs
@@ -2,7 +2,6 @@
 use std::cmp::min;
 
 use tui::{
-    backend::Backend,
     layout::{Alignment, Constraint, Direction, Layout, Rect},
     terminal::Frame,
     text::{Line, Span, Text},
@@ -206,8 +205,8 @@ impl Painter {
         None
     }
 
-    fn draw_dd_confirm_buttons<B: Backend>(
-        &self, f: &mut Frame<'_, B>, button_draw_loc: &Rect, app_state: &mut App,
+    fn draw_dd_confirm_buttons(
+        &self, f: &mut Frame<'_>, button_draw_loc: &Rect, app_state: &mut App,
     ) {
         if MAX_PROCESS_SIGNAL == 1 || !app_state.app_config_fields.is_advanced_kill {
             let (yes_button, no_button) = match app_state.delete_dialog_state.selected_signal {
@@ -351,8 +350,8 @@ impl Painter {
         }
     }
 
-    pub fn draw_dd_dialog<B: Backend>(
-        &self, f: &mut Frame<'_, B>, dd_text: Option<Text<'_>>, app_state: &mut App, draw_loc: Rect,
+    pub fn draw_dd_dialog(
+        &self, f: &mut Frame<'_>, dd_text: Option<Text<'_>>, app_state: &mut App, draw_loc: Rect,
     ) -> bool {
         if let Some(dd_text) = dd_text {
             let dd_title = if app_state.dd_err.is_some() {
diff --git a/src/canvas/dialogs/help_dialog.rs b/src/canvas/dialogs/help_dialog.rs
index 061405d0..39bf2575 100644
--- a/src/canvas/dialogs/help_dialog.rs
+++ b/src/canvas/dialogs/help_dialog.rs
@@ -1,7 +1,6 @@
 use std::cmp::{max, min};
 
 use tui::{
-    backend::Backend,
     layout::{Alignment, Rect},
     terminal::Frame,
     text::Line,
@@ -16,9 +15,7 @@ const HELP_BASE: &str = " Help ── Esc to close ";
 
 // TODO: [REFACTOR] Make generic dialog boxes to build off of instead?
 impl Painter {
-    pub fn draw_help_dialog<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect,
-    ) {
+    pub fn draw_help_dialog(&self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect) {
         let help_title = Line::from(vec![
             Span::styled(" Help ", self.colours.widget_title_style),
             Span::styled(
diff --git a/src/canvas/widgets/basic_table_arrows.rs b/src/canvas/widgets/basic_table_arrows.rs
index addd5207..352c7f1e 100644
--- a/src/canvas/widgets/basic_table_arrows.rs
+++ b/src/canvas/widgets/basic_table_arrows.rs
@@ -1,5 +1,4 @@
 use tui::{
-    backend::Backend,
     layout::{Alignment, Constraint, Direction, Layout, Rect},
     terminal::Frame,
     text::Line,
@@ -13,8 +12,8 @@ use crate::{
 };
 
 impl Painter {
-    pub fn draw_basic_table_arrows<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
+    pub fn draw_basic_table_arrows(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         if let Some(current_table) = app_state.widget_map.get(&widget_id) {
             let current_table = if let BottomWidgetType::ProcSort = current_table.widget_type {
diff --git a/src/canvas/widgets/battery_display.rs b/src/canvas/widgets/battery_display.rs
index 611859a6..4cd5c23b 100644
--- a/src/canvas/widgets/battery_display.rs
+++ b/src/canvas/widgets/battery_display.rs
@@ -1,5 +1,4 @@
 use tui::{
-    backend::Backend,
     layout::{Constraint, Direction, Layout, Rect},
     terminal::Frame,
     text::{Line, Span},
@@ -16,8 +15,8 @@ use crate::{
 };
 
 impl Painter {
-    pub fn draw_battery_display<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
+    pub fn draw_battery_display(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
         widget_id: u64,
     ) {
         let should_get_widget_bounds = app_state.should_get_widget_bounds();
@@ -249,19 +248,20 @@ impl Painter {
 
                 // Draw bar
                 f.render_widget(
-                    Table::new(battery_charge_rows)
+                    Table::new(battery_charge_rows, [Constraint::Percentage(100)])
                         .block(battery_block.clone())
-                        .header(header.clone())
-                        .widths(&[Constraint::Percentage(100)]),
+                        .header(header.clone()),
                     margined_draw_loc,
                 );
 
                 // Draw info
                 f.render_widget(
-                    Table::new(battery_rows)
-                        .block(battery_block)
-                        .header(header)
-                        .widths(&[Constraint::Percentage(50), Constraint::Percentage(50)]),
+                    Table::new(
+                        battery_rows,
+                        [Constraint::Percentage(50), Constraint::Percentage(50)],
+                    )
+                    .block(battery_block)
+                    .header(header),
                     margined_draw_loc,
                 );
             } else {
diff --git a/src/canvas/widgets/cpu_basic.rs b/src/canvas/widgets/cpu_basic.rs
index 1ebf7cc6..da502d69 100644
--- a/src/canvas/widgets/cpu_basic.rs
+++ b/src/canvas/widgets/cpu_basic.rs
@@ -1,7 +1,6 @@
 use std::cmp::min;
 
 use tui::{
-    backend::Backend,
     layout::{Constraint, Direction, Layout, Rect},
     terminal::Frame,
     widgets::Block,
@@ -17,8 +16,8 @@ use crate::{
 
 impl Painter {
     /// Inspired by htop.
-    pub fn draw_basic_cpu<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
+    pub fn draw_basic_cpu(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         // Skip the first element, it's the "all" element
         if app_state.converted_data.cpu_data.len() > 1 {
diff --git a/src/canvas/widgets/cpu_graph.rs b/src/canvas/widgets/cpu_graph.rs
index e6957ff6..9e9dab2f 100644
--- a/src/canvas/widgets/cpu_graph.rs
+++ b/src/canvas/widgets/cpu_graph.rs
@@ -1,7 +1,6 @@
 use std::borrow::Cow;
 
 use tui::{
-    backend::Backend,
     layout::{Constraint, Direction, Layout, Rect},
     symbols::Marker,
     terminal::Frame,
@@ -22,9 +21,7 @@ const AVG_POSITION: usize = 1;
 const ALL_POSITION: usize = 0;
 
 impl Painter {
-    pub fn draw_cpu<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
-    ) {
+    pub fn draw_cpu(&self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64) {
         let legend_width = (draw_loc.width as f64 * 0.15) as u16;
 
         if legend_width < 6 {
@@ -175,8 +172,8 @@ impl Painter {
         }
     }
 
-    fn draw_cpu_graph<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
+    fn draw_cpu_graph(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         const Y_BOUNDS: [f64; 2] = [0.0, 100.5];
         const Y_LABELS: [Cow<'static, str>; 2] = [Cow::Borrowed("  0%"), Cow::Borrowed("100%")];
@@ -240,8 +237,8 @@ impl Painter {
         }
     }
 
-    fn draw_cpu_legend<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
+    fn draw_cpu_legend(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         let recalculate_column_widths = app_state.should_get_widget_bounds();
         if let Some(cpu_widget_state) = app_state
diff --git a/src/canvas/widgets/disk_table.rs b/src/canvas/widgets/disk_table.rs
index b3c2ac6c..cfea61b6 100644
--- a/src/canvas/widgets/disk_table.rs
+++ b/src/canvas/widgets/disk_table.rs
@@ -1,4 +1,4 @@
-use tui::{backend::Backend, layout::Rect, terminal::Frame};
+use tui::{layout::Rect, terminal::Frame};
 
 use crate::{
     app::{self},
@@ -7,8 +7,8 @@ use crate::{
 };
 
 impl Painter {
-    pub fn draw_disk_table<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut app::App, draw_loc: Rect, widget_id: u64,
+    pub fn draw_disk_table(
+        &self, f: &mut Frame<'_>, app_state: &mut app::App, draw_loc: Rect, widget_id: u64,
     ) {
         let recalculate_column_widths = app_state.should_get_widget_bounds();
         if let Some(disk_widget_state) = app_state
diff --git a/src/canvas/widgets/mem_basic.rs b/src/canvas/widgets/mem_basic.rs
index 2a35590e..d24ae22e 100644
--- a/src/canvas/widgets/mem_basic.rs
+++ b/src/canvas/widgets/mem_basic.rs
@@ -1,5 +1,4 @@
 use tui::{
-    backend::Backend,
     layout::{Constraint, Direction, Layout, Rect},
     terminal::Frame,
     widgets::Block,
@@ -10,8 +9,8 @@ use crate::{
 };
 
 impl Painter {
-    pub fn draw_basic_memory<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
+    pub fn draw_basic_memory(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         let mem_data = &app_state.converted_data.mem_data;
         let mut draw_widgets: Vec<PipeGauge<'_>> = Vec::new();
diff --git a/src/canvas/widgets/mem_graph.rs b/src/canvas/widgets/mem_graph.rs
index 16f5c41d..42e05e02 100644
--- a/src/canvas/widgets/mem_graph.rs
+++ b/src/canvas/widgets/mem_graph.rs
@@ -1,7 +1,6 @@
 use std::borrow::Cow;
 
 use tui::{
-    backend::Backend,
     layout::{Constraint, Rect},
     symbols::Marker,
     terminal::Frame,
@@ -14,8 +13,8 @@ use crate::{
 };
 
 impl Painter {
-    pub fn draw_memory_graph<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
+    pub fn draw_memory_graph(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         const Y_BOUNDS: [f64; 2] = [0.0, 100.5];
         const Y_LABELS: [Cow<'static, str>; 2] = [Cow::Borrowed("  0%"), Cow::Borrowed("100%")];
diff --git a/src/canvas/widgets/network_basic.rs b/src/canvas/widgets/network_basic.rs
index b877396f..63e0e52f 100644
--- a/src/canvas/widgets/network_basic.rs
+++ b/src/canvas/widgets/network_basic.rs
@@ -1,5 +1,4 @@
 use tui::{
-    backend::Backend,
     layout::{Constraint, Direction, Layout, Rect},
     terminal::Frame,
     text::{Line, Span},
@@ -9,8 +8,8 @@ use tui::{
 use crate::{app::App, canvas::Painter, constants::*};
 
 impl Painter {
-    pub fn draw_basic_network<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
+    pub fn draw_basic_network(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         let divided_loc = Layout::default()
             .direction(Direction::Horizontal)
diff --git a/src/canvas/widgets/network_graph.rs b/src/canvas/widgets/network_graph.rs
index d21a4698..8f0885fa 100644
--- a/src/canvas/widgets/network_graph.rs
+++ b/src/canvas/widgets/network_graph.rs
@@ -1,5 +1,4 @@
 use tui::{
-    backend::Backend,
     layout::{Constraint, Direction, Layout, Rect},
     symbols::Marker,
     terminal::Frame,
@@ -18,8 +17,8 @@ use crate::{
 };
 
 impl Painter {
-    pub fn draw_network<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
+    pub fn draw_network(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         if app_state.app_config_fields.use_old_network_legend {
             const LEGEND_HEIGHT: u16 = 4;
@@ -50,8 +49,8 @@ impl Painter {
         }
     }
 
-    pub fn draw_network_graph<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
+    pub fn draw_network_graph(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
         hide_legend: bool,
     ) {
         if let Some(network_widget_state) =
@@ -167,8 +166,8 @@ impl Painter {
         }
     }
 
-    fn draw_network_labels<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
+    fn draw_network_labels(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         const NETWORK_HEADERS: [&str; 4] = ["RX", "TX", "Total RX", "Total TX"];
 
@@ -187,22 +186,22 @@ impl Painter {
 
         // Draw
         f.render_widget(
-            Table::new(total_network)
-                .header(Row::new(NETWORK_HEADERS).style(self.colours.table_header_style))
-                .block(Block::default().borders(Borders::ALL).border_style(
-                    if app_state.current_widget.widget_id == widget_id {
-                        self.colours.highlighted_border_style
-                    } else {
-                        self.colours.border_style
-                    },
-                ))
-                .style(self.colours.text_style)
-                .widths(
-                    &((std::iter::repeat(draw_loc.width.saturating_sub(2) / 4))
-                        .take(4)
-                        .map(Constraint::Length)
-                        .collect::<Vec<_>>()),
-                ),
+            Table::new(
+                total_network,
+                &((std::iter::repeat(draw_loc.width.saturating_sub(2) / 4))
+                    .take(4)
+                    .map(Constraint::Length)
+                    .collect::<Vec<_>>()),
+            )
+            .header(Row::new(NETWORK_HEADERS).style(self.colours.table_header_style))
+            .block(Block::default().borders(Borders::ALL).border_style(
+                if app_state.current_widget.widget_id == widget_id {
+                    self.colours.highlighted_border_style
+                } else {
+                    self.colours.border_style
+                },
+            ))
+            .style(self.colours.text_style),
             draw_loc,
         );
     }
diff --git a/src/canvas/widgets/process_table.rs b/src/canvas/widgets/process_table.rs
index 534809be..8aef6bea 100644
--- a/src/canvas/widgets/process_table.rs
+++ b/src/canvas/widgets/process_table.rs
@@ -1,5 +1,4 @@
 use tui::{
-    backend::Backend,
     layout::{Alignment, Constraint, Direction, Layout, Rect},
     style::Style,
     terminal::Frame,
@@ -20,8 +19,8 @@ const SORT_MENU_WIDTH: u16 = 7;
 impl Painter {
     /// Draws and handles all process-related drawing.  Use this.
     /// - `widget_id` here represents the widget ID of the process widget itself!
-    pub fn draw_process_widget<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
+    pub fn draw_process_widget(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
         widget_id: u64,
     ) {
         if let Some(proc_widget_state) = app_state.states.proc_state.widget_states.get(&widget_id) {
@@ -73,8 +72,8 @@ impl Painter {
 
     /// Draws the process sort box.
     /// - `widget_id` represents the widget ID of the process widget itself.an
-    fn draw_processes_table<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
+    fn draw_processes_table(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         let should_get_widget_bounds = app_state.should_get_widget_bounds();
         if let Some(proc_widget_state) = app_state
@@ -107,8 +106,8 @@ impl Painter {
     /// Draws the process search field.
     /// - `widget_id` represents the widget ID of the search box itself --- NOT the process widget
     /// state that is stored.
-    fn draw_search_field<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
+    fn draw_search_field(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
         widget_id: u64,
     ) {
         fn build_query_span(
@@ -311,8 +310,8 @@ impl Painter {
     /// Draws the process sort box.
     /// - `widget_id` represents the widget ID of the sort box itself --- NOT the process widget
     /// state that is stored.
-    fn draw_sort_table<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
+    fn draw_sort_table(
+        &self, f: &mut Frame<'_>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         let should_get_widget_bounds = app_state.should_get_widget_bounds();
         if let Some(pws) = app_state
diff --git a/src/canvas/widgets/temperature_table.rs b/src/canvas/widgets/temperature_table.rs
index 820b0069..6c0475a4 100644
--- a/src/canvas/widgets/temperature_table.rs
+++ b/src/canvas/widgets/temperature_table.rs
@@ -1,4 +1,4 @@
-use tui::{backend::Backend, layout::Rect, terminal::Frame};
+use tui::{layout::Rect, terminal::Frame};
 
 use crate::{
     app,
@@ -7,8 +7,8 @@ use crate::{
 };
 
 impl Painter {
-    pub fn draw_temp_table<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut app::App, draw_loc: Rect, widget_id: u64,
+    pub fn draw_temp_table(
+        &self, f: &mut Frame<'_>, app_state: &mut app::App, draw_loc: Rect, widget_id: u64,
     ) {
         let recalculate_column_widths = app_state.should_get_widget_bounds();
         if let Some(temp_widget_state) = app_state
diff --git a/src/components/data_table/draw.rs b/src/components/data_table/draw.rs
index 91fef6ba..15faae22 100644
--- a/src/components/data_table/draw.rs
+++ b/src/components/data_table/draw.rs
@@ -5,7 +5,6 @@ use std::{
 
 use concat_string::concat_string;
 use tui::{
-    backend::Backend,
     layout::{Constraint, Direction, Layout, Rect},
     text::{Line, Span, Text},
     widgets::{Block, Borders, Row, Table},
@@ -139,8 +138,8 @@ where
         })
     }
 
-    pub fn draw<B: Backend>(
-        &mut self, f: &mut Frame<'_, B>, draw_info: &DrawInfo, widget: Option<&mut BottomWidget>,
+    pub fn draw(
+        &mut self, f: &mut Frame<'_>, draw_info: &DrawInfo, widget: Option<&mut BottomWidget>,
         painter: &Painter,
     ) {
         let draw_horizontal = !self.props.is_basic || draw_info.is_on_widget();
@@ -248,21 +247,8 @@ where
                     } else {
                         self.styling.text_style
                     };
-                    let mut table = Table::new(rows)
-                        .block(block)
-                        .highlight_style(highlight_style)
-                        .style(self.styling.text_style);
-
-                    if show_header {
-                        table = table.header(headers);
-                    }
-
-                    table
-                };
-
-                let table_state = &mut self.state.table_state;
-                f.render_stateful_widget(
-                    widget.widths(
+                    let mut table = Table::new(
+                        rows,
                         &(self
                             .state
                             .calculated_widths
@@ -275,15 +261,27 @@ where
                                 }
                             })
                             .collect::<Vec<_>>()),
-                    ),
-                    margined_draw_loc,
-                    table_state,
-                );
-            } else {
-                let table = Table::new(once(Row::new(Text::raw("No data"))))
+                    )
                     .block(block)
-                    .style(self.styling.text_style)
-                    .widths(&[Constraint::Percentage(100)]);
+                    .highlight_style(highlight_style)
+                    .style(self.styling.text_style);
+
+                    if show_header {
+                        table = table.header(headers);
+                    }
+
+                    table
+                };
+
+                let table_state = &mut self.state.table_state;
+                f.render_stateful_widget(widget, margined_draw_loc, table_state);
+            } else {
+                let table = Table::new(
+                    once(Row::new(Text::raw("No data"))),
+                    [Constraint::Percentage(100)],
+                )
+                .block(block)
+                .style(self.styling.text_style);
                 f.render_widget(table, margined_draw_loc);
             }
         }
diff --git a/src/components/time_graph.rs b/src/components/time_graph.rs
index 94192bb4..63d7330b 100644
--- a/src/components/time_graph.rs
+++ b/src/components/time_graph.rs
@@ -2,7 +2,6 @@ use std::borrow::Cow;
 
 use concat_string::concat_string;
 use tui::{
-    backend::Backend,
     layout::{Constraint, Rect},
     style::Style,
     symbols::Marker,
@@ -124,9 +123,7 @@ impl<'a> TimeGraph<'a> {
     /// - Draws with the higher time value on the left, and lower on the right.
     /// - Expects a [`TimeGraph`] to be passed in, which details how to draw the graph.
     /// - Expects `graph_data`, which represents *what* data to draw, and various details like style and optional legends.
-    pub fn draw_time_graph<B: Backend>(
-        &self, f: &mut Frame<'_, B>, draw_loc: Rect, graph_data: &[GraphData<'_>],
-    ) {
+    pub fn draw_time_graph(&self, f: &mut Frame<'_>, draw_loc: Rect, graph_data: &[GraphData<'_>]) {
         let x_axis = self.generate_x_axis();
         let y_axis = self.generate_y_axis();
 
diff --git a/src/components/tui_widget/time_chart/canvas.rs b/src/components/tui_widget/time_chart/canvas.rs
index f1d98825..b6cc41c1 100644
--- a/src/components/tui_widget/time_chart/canvas.rs
+++ b/src/components/tui_widget/time_chart/canvas.rs
@@ -363,9 +363,10 @@ impl<'a> Context<'a> {
     ) -> Context<'a> {
         let grid: Box<dyn Grid> = match marker {
             symbols::Marker::Dot => Box::new(CharGrid::new(width, height, '•')),
-            symbols::Marker::Block => Box::new(CharGrid::new(width, height, '▄')),
-            symbols::Marker::Braille => Box::new(BrailleGrid::new(width, height)),
+            symbols::Marker::Block => Box::new(CharGrid::new(width, height, '█')),
             symbols::Marker::Bar => Box::new(CharGrid::new(width, height, '▄')),
+            symbols::Marker::Braille => Box::new(BrailleGrid::new(width, height)),
+            symbols::Marker::HalfBlock => Box::new(CharGrid::new(width, height, '▀')),
         };
         Context {
             x_bounds,
diff --git a/src/data_conversion.rs b/src/data_conversion.rs
index f7f62eac..e1f5e08f 100644
--- a/src/data_conversion.rs
+++ b/src/data_conversion.rs
@@ -547,30 +547,6 @@ pub fn convert_battery_harvest(current_data: &DataCollection) -> Vec<ConvertedBa
 }
 
 #[cfg(feature = "zfs")]
-pub fn convert_arc_labels(current_data: &DataCollection) -> Option<(String, String)> {
-    if current_data.arc_harvest.total_bytes > 0 {
-        Some((
-            format!(
-                "{:3.0}%",
-                current_data.arc_harvest.use_percent.unwrap_or(0.0)
-            ),
-            {
-                let (unit, denominator) =
-                    get_mem_binary_unit_and_denominator(current_data.arc_harvest.total_bytes);
-
-                format!(
-                    "   {:.1}{unit}/{:.1}{unit}",
-                    current_data.arc_harvest.used_bytes as f64 / denominator,
-                    (current_data.arc_harvest.total_bytes as f64 / denominator),
-                )
-            },
-        ))
-    } else {
-        None
-    }
-}
-
-#[cfg(feature = "zfs")]
 pub fn convert_arc_data_points(current_data: &DataCollection) -> Vec<Point> {
     let mut result: Vec<Point> = Vec::new();
     let current_time = current_data.current_instant;