refactor: remove trait usage in component drawing

When I was newer to Rust, I got the weird impression that you couldn't
add functionality to a struct outside of the defining file without using
a trait.

That's obviously not true, so it's high time I got rid of it and just
made it part of the impl of the class itself, rather than declaring a
trait and then exporting/importing it.

src/canvas.rs

@@ -9,12 +9,7 @@ use tui::{
     Frame, Terminal,
 };
 
-// use ordered_float::OrderedFloat;
-
 use canvas_colours::*;
-use dialogs::*;
-use screens::*;
-use widgets::*;
 
 use crate::{
     app::{

src/canvas/dialogs.rs

@@ -1,5 +1,2 @@
 pub mod dd_dialog;
 pub mod help_dialog;
-
-pub use dd_dialog::KillDialog;
-pub use help_dialog::HelpDialog;

src/canvas/dialogs/dd_dialog.rs

@@ -16,20 +16,8 @@ use crate::{
 const DD_BASE: &str = " Confirm Kill Process ── Esc to close ";
 const DD_ERROR_BASE: &str = " Error ── Esc to close ";
 
-pub trait KillDialog {
-    fn get_dd_spans(&self, app_state: &App) -> Option<Text<'_>>;
-
-    fn draw_dd_confirm_buttons<B: Backend>(
-        &self, f: &mut Frame<'_, B>, button_draw_loc: &Rect, app_state: &mut App,
-    );
-
-    fn draw_dd_dialog<B: Backend>(
-        &self, f: &mut Frame<'_, B>, dd_text: Option<Text<'_>>, app_state: &mut App, draw_loc: Rect,
-    ) -> bool;
-}
-
-impl KillDialog for Painter {
-    fn get_dd_spans(&self, app_state: &App) -> Option<Text<'_>> {
+impl Painter {
+    pub fn get_dd_spans(&self, app_state: &App) -> Option<Text<'_>> {
         if let Some(dd_err) = &app_state.dd_err {
             return Some(Text::from(vec![
                 Spans::default(),
@@ -317,7 +305,7 @@ impl KillDialog for Painter {
         }
     }
 
-    fn draw_dd_dialog<B: Backend>(
+    pub fn draw_dd_dialog<B: Backend>(
         &self, f: &mut Frame<'_, B>, dd_text: Option<Text<'_>>, app_state: &mut App, draw_loc: Rect,
     ) -> bool {
         if let Some(dd_text) = dd_text {

src/canvas/dialogs/help_dialog.rs

@@ -12,15 +12,9 @@ use tui::{
 
 const HELP_BASE: &str = " Help ── Esc to close ";
 
-pub trait HelpDialog {
-    fn draw_help_dialog<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect,
-    );
-}
-
 // TODO: [REFACTOR] Make generic dialog boxes to build off of instead?
-impl HelpDialog for Painter {
-    fn draw_help_dialog<B: Backend>(
+impl Painter {
+    pub fn draw_help_dialog<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect,
     ) {
         let help_title = Spans::from(vec![

src/canvas/screens/config_screen.rs

@@ -12,14 +12,8 @@ use tui::{
     widgets::{Block, Borders, Paragraph},
 };
 
-pub trait ConfigScreen {
-    fn draw_config_screen<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect,
-    );
-}
-
-impl ConfigScreen for Painter {
-    fn draw_config_screen<B: Backend>(
+impl Painter {
+    pub fn draw_config_screen<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect,
     ) {
         let config_block = Block::default()

src/canvas/widgets.rs

@@ -9,15 +9,3 @@ pub mod network_basic;
 pub mod network_graph;
 pub mod process_table;
 pub mod temp_table;
-
-pub use basic_table_arrows::BasicTableArrows;
-pub use battery_display::BatteryDisplayWidget;
-pub use cpu_basic::CpuBasicWidget;
-pub use cpu_graph::CpuGraphWidget;
-pub use disk_table::DiskTableWidget;
-pub use mem_basic::MemBasicWidget;
-pub use mem_graph::MemGraphWidget;
-pub use network_basic::NetworkBasicWidget;
-pub use network_graph::NetworkGraphWidget;
-pub use process_table::ProcessTableWidget;
-pub use temp_table::TempTableWidget;

src/canvas/widgets/basic_table_arrows.rs

@@ -12,14 +12,8 @@ use tui::{
     widgets::{Block, Paragraph},
 };
 
-pub trait BasicTableArrows {
-    fn draw_basic_table_arrows<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
-    );
-}
-
-impl BasicTableArrows for Painter {
-    fn draw_basic_table_arrows<B: Backend>(
+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,
     ) {
         if let Some(current_table) = app_state.widget_map.get(&widget_id) {

src/canvas/widgets/battery_display.rs

@@ -13,15 +13,8 @@ use tui::{
 };
 use unicode_segmentation::UnicodeSegmentation;
 
-pub trait BatteryDisplayWidget {
-    fn draw_battery_display<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
-        widget_id: u64,
-    );
-}
-
-impl BatteryDisplayWidget for Painter {
-    fn draw_battery_display<B: Backend>(
+impl Painter {
+    pub fn draw_battery_display<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
         widget_id: u64,
     ) {

src/canvas/widgets/cpu_basic.rs

@@ -15,14 +15,8 @@ use tui::{
     widgets::{Block, Paragraph},
 };
 
-pub trait CpuBasicWidget {
-    fn draw_basic_cpu<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
-    );
-}
-
-impl CpuBasicWidget for Painter {
-    fn draw_basic_cpu<B: Backend>(
+impl Painter {
+    pub fn draw_basic_cpu<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         // Skip the first element, it's the "all" element

src/canvas/widgets/cpu_graph.rs

@@ -32,20 +32,8 @@ static CPU_LEGEND_HEADER_LENS: Lazy<Vec<u16>> = Lazy::new(|| {
         .collect::<Vec<_>>()
 });
 
-pub trait CpuGraphWidget {
-    fn draw_cpu<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
-    );
-    fn draw_cpu_graph<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
-    );
-    fn draw_cpu_legend<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
-    );
-}
-
-impl CpuGraphWidget for Painter {
-    fn draw_cpu<B: Backend>(
+impl Painter {
+    pub fn draw_cpu<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         if draw_loc.width as f64 * 0.15 <= 6.0 {

src/canvas/widgets/disk_table.rs

@@ -27,15 +27,8 @@ static DISK_HEADERS_LENS: Lazy<Vec<u16>> = Lazy::new(|| {
         .collect::<Vec<_>>()
 });
 
-pub trait DiskTableWidget {
-    fn draw_disk_table<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut app::App, draw_loc: Rect, draw_border: bool,
-        widget_id: u64,
-    );
-}
-
-impl DiskTableWidget for Painter {
-    fn draw_disk_table<B: Backend>(
+impl Painter {
+    pub fn draw_disk_table<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut app::App, draw_loc: Rect, draw_border: bool,
         widget_id: u64,
     ) {

src/canvas/widgets/mem_basic.rs

@@ -13,14 +13,8 @@ use tui::{
     widgets::{Block, Paragraph},
 };
 
-pub trait MemBasicWidget {
-    fn draw_basic_memory<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
-    );
-}
-
-impl MemBasicWidget for Painter {
-    fn draw_basic_memory<B: Backend>(
+impl Painter {
+    pub fn draw_basic_memory<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         let mem_data: &[(f64, f64)] = &app_state.canvas_data.mem_data;

src/canvas/widgets/mem_graph.rs

@@ -15,14 +15,8 @@ use tui::{
 };
 use unicode_segmentation::UnicodeSegmentation;
 
-pub trait MemGraphWidget {
-    fn draw_memory_graph<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
-    );
-}
-
-impl MemGraphWidget for Painter {
-    fn draw_memory_graph<B: Backend>(
+impl Painter {
+    pub fn draw_memory_graph<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         if let Some(mem_widget_state) = app_state.mem_state.widget_states.get_mut(&widget_id) {

src/canvas/widgets/network_basic.rs

@@ -8,14 +8,8 @@ use tui::{
     widgets::{Block, Paragraph},
 };
 
-pub trait NetworkBasicWidget {
-    fn draw_basic_network<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
-    );
-}
-
-impl NetworkBasicWidget for Painter {
-    fn draw_basic_network<B: Backend>(
+impl Painter {
+    pub fn draw_basic_network<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         let divided_loc = Layout::default()

src/canvas/widgets/network_graph.rs

@@ -32,23 +32,8 @@ static NETWORK_HEADERS_LENS: Lazy<Vec<u16>> = Lazy::new(|| {
         .collect::<Vec<_>>()
 });
 
-pub trait NetworkGraphWidget {
-    fn draw_network<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
-    );
-
-    fn draw_network_graph<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
-        hide_legend: bool,
-    );
-
-    fn draw_network_labels<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
-    );
-}
-
-impl NetworkGraphWidget for Painter {
-    fn draw_network<B: Backend>(
+impl Painter {
+    pub fn draw_network<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
     ) {
         if app_state.app_config_fields.use_old_network_legend {
@@ -79,7 +64,7 @@ impl NetworkGraphWidget for Painter {
         }
     }
 
-    fn draw_network_graph<B: Backend>(
+    pub fn draw_network_graph<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, widget_id: u64,
         hide_legend: bool,
     ) {

src/canvas/widgets/process_table.rs

@@ -87,46 +87,10 @@ const PROCESS_HEADERS_SOFT_WIDTH_MAX_NO_GROUP_ELSE: &[Option<f64>] = &[
     Some(0.2),
 ];
 
-pub trait ProcessTableWidget {
+impl Painter {
     /// Draws and handles all process-related drawing.  Use this.
     /// - `widget_id` here represents the widget ID of the process widget itself!
-    fn draw_process_features<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
-        widget_id: u64,
-    );
-
-    /// Draws the process sort box.
-    /// - `widget_id` represents the widget ID of the process widget itself.
-    ///
-    /// This should not be directly called.
-    fn draw_processes_table<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
-        widget_id: u64,
-    );
-
-    /// Draws the process search field.
-    /// - `widget_id` represents the widget ID of the search box itself --- NOT the process widget
-    /// state that is stored.
-    ///
-    /// This should not be directly called.
-    fn draw_search_field<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
-        widget_id: u64,
-    );
-
-    /// Draws the process sort box.
-    /// - `widget_id` represents the widget ID of the sort box itself --- NOT the process widget
-    /// state that is stored.
-    ///
-    /// This should not be directly called.
-    fn draw_process_sort<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
-        widget_id: u64,
-    );
-}
-
-impl ProcessTableWidget for Painter {
-    fn draw_process_features<B: Backend>(
+    pub fn draw_process_features<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
         widget_id: u64,
     ) {
@@ -172,6 +136,10 @@ impl ProcessTableWidget for Painter {
         }
     }
 
+    /// Draws the process sort box.
+    /// - `widget_id` represents the widget ID of the process widget itself.
+    ///
+    /// This should not be directly called.
     fn draw_processes_table<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
         widget_id: u64,
@@ -554,6 +522,11 @@ impl ProcessTableWidget for 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.
+    ///
+    /// This should not be directly called.
     fn draw_search_field<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
         widget_id: u64,
@@ -773,6 +746,11 @@ impl ProcessTableWidget for 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.
+    ///
+    /// This should not be directly called.
     fn draw_process_sort<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut App, draw_loc: Rect, draw_border: bool,
         widget_id: u64,

src/canvas/widgets/temp_table.rs

@@ -27,15 +27,8 @@ static TEMP_HEADERS_LENS: Lazy<Vec<u16>> = Lazy::new(|| {
         .collect::<Vec<_>>()
 });
 
-pub trait TempTableWidget {
-    fn draw_temp_table<B: Backend>(
-        &self, f: &mut Frame<'_, B>, app_state: &mut app::App, draw_loc: Rect, draw_border: bool,
-        widget_id: u64,
-    );
-}
-
-impl TempTableWidget for Painter {
-    fn draw_temp_table<B: Backend>(
+impl Painter {
+    pub fn draw_temp_table<B: Backend>(
         &self, f: &mut Frame<'_, B>, app_state: &mut app::App, draw_loc: Rect, draw_border: bool,
         widget_id: u64,
     ) {