refactor(ui): all table search and filter functionality is now available directly through the ManagarrTable widget to make life easier moving forward

src/ui/widgets/input_box.rs

@@ -2,7 +2,7 @@ use ratatui::buffer::Buffer;
 use ratatui::layout::{Constraint, Layout, Position, Rect};
 use ratatui::prelude::Text;
 use ratatui::style::{Style, Styled, Stylize};
-use ratatui::widgets::{Block, Paragraph, Widget};
+use ratatui::widgets::{Block, Paragraph, Widget, WidgetRef};
 use ratatui::Frame;
 
 use crate::ui::styles::ManagarrStyle;
@@ -12,6 +12,8 @@ use crate::ui::utils::{borderless_block, layout_block};
 #[path = "input_box_tests.rs"]
 mod input_box_tests;
 
+#[derive(Default)]
+#[cfg_attr(test, derive(Debug, PartialEq))]
 pub struct InputBox<'a> {
   content: &'a str,
   offset: usize,
@@ -96,7 +98,7 @@ impl<'a> InputBox<'a> {
     }
   }
 
-  fn render_input_box(self, area: Rect, buf: &mut Buffer) {
+  fn render_input_box(&self, area: Rect, buf: &mut Buffer) {
     let style =
       if matches!(self.is_highlighted, Some(true)) && matches!(self.is_selected, Some(false)) {
         Style::new().system_function().bold()
@@ -106,7 +108,7 @@ impl<'a> InputBox<'a> {
 
     let input_box_paragraph = Paragraph::new(Text::from(self.content))
       .style(style)
-      .block(self.block);
+      .block(self.block.clone());
 
     if let Some(label) = self.label {
       let [label_area, text_box_area] =
@@ -133,6 +135,12 @@ impl<'a> Widget for InputBox<'a> {
   }
 }
 
+impl<'a> WidgetRef for InputBox<'a> {
+  fn render_ref(&self, area: Rect, buf: &mut Buffer) {
+    self.render_input_box(area, buf);
+  }
+}
+
 impl<'a> Styled for InputBox<'a> {
   type Item = InputBox<'a>;
 

src/ui/widgets/input_box_popup.rs

@@ -0,0 +1,60 @@
+use crate::ui::styles::ManagarrStyle;
+use crate::ui::utils::{background_block, borderless_block, centered_rect};
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Constraint, Layout, Rect};
+use ratatui::widgets::{Block, Clear, Paragraph, Widget, WidgetRef};
+
+use super::input_box::InputBox;
+
+#[cfg(test)]
+#[path = "input_box_popup_tests.rs"]
+mod input_box_popup_tests;
+
+pub struct InputBoxPopup<'a> {
+  input_box: InputBox<'a>,
+}
+
+impl<'a> InputBoxPopup<'a> {
+  pub fn new(content: &'a str) -> Self {
+    Self {
+      input_box: InputBox::new(content),
+    }
+  }
+
+  pub fn block(mut self, block: Block<'a>) -> InputBoxPopup<'a> {
+    self.input_box = self.input_box.block(block);
+    self
+  }
+
+  pub fn offset(mut self, offset: usize) -> InputBoxPopup<'a> {
+    self.input_box = self.input_box.offset(offset);
+    self
+  }
+
+  fn render_popup(&self, area: Rect, buf: &mut Buffer) {
+    let popup_area = Rect {
+      height: 6,
+      ..centered_rect(30, 20, area)
+    };
+    Clear.render(popup_area, buf);
+    background_block().render(popup_area, buf);
+
+    let [text_box_area, help_area] =
+      Layout::vertical([Constraint::Length(3), Constraint::Length(1)])
+        .margin(1)
+        .areas(popup_area);
+    self.input_box.render_ref(text_box_area, buf);
+
+    let help = Paragraph::new("<esc> cancel")
+      .help()
+      .centered()
+      .block(borderless_block());
+    help.render(help_area, buf);
+  }
+}
+
+impl<'a> WidgetRef for InputBoxPopup<'a> {
+  fn render_ref(&self, area: Rect, buf: &mut Buffer) {
+    self.render_popup(area, buf);
+  }
+}

src/ui/widgets/input_box_popup_tests.rs

@@ -0,0 +1,34 @@
+#[cfg(test)]
+mod tests {
+  use crate::ui::utils::layout_block;
+  use crate::ui::widgets::input_box::InputBox;
+  use crate::ui::widgets::input_box_popup::InputBoxPopup;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_input_box_popup_new() {
+    let expected_input_box = InputBox::new("test");
+
+    let input_box_popup = InputBoxPopup::new("test");
+
+    assert_eq!(input_box_popup.input_box, expected_input_box);
+  }
+
+  #[test]
+  fn test_input_box_popup_block() {
+    let expected_input_box = InputBox::new("test").block(layout_block().title("title"));
+
+    let input_box_popup = InputBoxPopup::new("test").block(layout_block().title("title"));
+
+    assert_eq!(input_box_popup.input_box, expected_input_box);
+  }
+
+  #[test]
+  fn test_input_box_popup_offset() {
+    let expected_input_box = InputBox::new("test").offset(5);
+
+    let input_box_popup = InputBoxPopup::new("test").offset(5);
+
+    assert_eq!(input_box_popup.input_box, expected_input_box);
+  }
+}

src/ui/widgets/managarr_table.rs

@@ -1,15 +1,21 @@
 use crate::models::stateful_table::StatefulTable;
 use crate::ui::styles::ManagarrStyle;
-use crate::ui::utils::layout_block_top_border;
+use crate::ui::utils::{centered_rect, layout_block_top_border, title_block_centered};
 use crate::ui::widgets::loading_block::LoadingBlock;
 use crate::ui::widgets::popup::Popup;
 use crate::ui::widgets::selectable_list::SelectableList;
 use crate::ui::HIGHLIGHT_SYMBOL;
 use ratatui::buffer::Buffer;
-use ratatui::layout::{Alignment, Constraint, Layout, Rect};
+use ratatui::layout::{Alignment, Constraint, Layout, Position, Rect};
 use ratatui::prelude::{Style, Stylize, Text};
-use ratatui::widgets::{Block, ListItem, Paragraph, Row, StatefulWidget, Table, Widget};
+use ratatui::widgets::{Block, ListItem, Paragraph, Row, StatefulWidget, Table, Widget, WidgetRef};
+use ratatui::Frame;
 use std::fmt::Debug;
+use std::sync::atomic::Ordering;
+
+use super::input_box_popup::InputBoxPopup;
+use super::message::Message;
+use super::popup::Size;
 
 #[cfg(test)]
 #[path = "managarr_table_tests.rs"]
@@ -31,6 +37,14 @@ where
   is_loading: bool,
   highlight_rows: bool,
   is_sorting: bool,
+  is_searching: bool,
+  search_produced_empty_results: bool,
+  is_filtering: bool,
+  filter_produced_empty_results: bool,
+  search_box_content_length: usize,
+  search_box_offset: usize,
+  filter_box_content_length: usize,
+  filter_box_offset: usize,
 }
 
 impl<'a, T, F> ManagarrTable<'a, T, F>
@@ -39,8 +53,8 @@ where
   T: Clone + PartialEq + Eq + Debug,
 {
   pub fn new(content: Option<&'a mut StatefulTable<T>>, row_mapper: F) -> Self {
-    Self {
-      content,
+    let mut managarr_table = Self {
+      content: None,
       table_headers: Vec::new(),
       constraints: Vec::new(),
       row_mapper,
@@ -51,7 +65,28 @@ where
       is_loading: false,
       highlight_rows: true,
       is_sorting: false,
+      is_searching: false,
+      search_produced_empty_results: false,
+      is_filtering: false,
+      filter_produced_empty_results: false,
+      search_box_content_length: 0,
+      search_box_offset: 0,
+      filter_box_content_length: 0,
+      filter_box_offset: 0,
+    };
+
+    if let Some(content) = content.as_ref() {
+      if let Some(search) = content.search.as_ref() {
+        managarr_table.search_box_content_length = search.text.len();
+        managarr_table.search_box_offset = search.offset.load(Ordering::SeqCst);
+      } else if let Some(filter) = content.filter.as_ref() {
+        managarr_table.filter_box_content_length = filter.text.len();
+        managarr_table.filter_box_offset = filter.offset.load(Ordering::SeqCst);
+      }
     }
+
+    managarr_table.content = content;
+    managarr_table
   }
 
   pub fn headers<I>(mut self, headers: I) -> Self
@@ -107,6 +142,26 @@ where
     self
   }
 
+  pub fn searching(mut self, is_searching: bool) -> Self {
+    self.is_searching = is_searching;
+    self
+  }
+
+  pub fn search_produced_empty_results(mut self, no_search_results: bool) -> Self {
+    self.search_produced_empty_results = no_search_results;
+    self
+  }
+
+  pub fn filtering(mut self, is_filtering: bool) -> Self {
+    self.is_filtering = is_filtering;
+    self
+  }
+
+  pub fn filter_produced_empty_results(mut self, no_filter_results: bool) -> Self {
+    self.filter_produced_empty_results = no_filter_results;
+    self
+  }
+
   fn render_table(self, area: Rect, buf: &mut Buffer) {
     let table_headers = self.parse_headers();
     let table_area = if let Some(ref footer) = self.footer {
@@ -160,6 +215,34 @@ where
             .dimensions(20, 50)
             .render(table_area, buf);
         }
+
+        if self.is_searching {
+          let box_content = &content.search.as_ref().unwrap();
+          InputBoxPopup::new(&box_content.text)
+            .offset(box_content.offset.load(Ordering::SeqCst))
+            .block(title_block_centered("Search"))
+            .render_ref(table_area, buf);
+        }
+
+        if self.is_filtering {
+          let box_content = &content.filter.as_ref().unwrap();
+          InputBoxPopup::new(&box_content.text)
+            .offset(box_content.offset.load(Ordering::SeqCst))
+            .block(title_block_centered("Filter"))
+            .render_ref(table_area, buf);
+        }
+
+        if self.search_produced_empty_results {
+          Popup::new(Message::new("No items found matching search"))
+            .size(Size::Message)
+            .render(table_area, buf);
+        }
+
+        if self.filter_produced_empty_results {
+          Popup::new(Message::new("The given filter produced empty results"))
+            .size(Size::Message)
+            .render(table_area, buf);
+        }
       } else {
         loading_block.render(table_area, buf);
       }
@@ -189,6 +272,36 @@ where
       .map(Text::from)
       .collect()
   }
+
+  pub fn show_cursor(&self, f: &mut Frame<'_>, area: Rect) {
+    let mut draw_cursor = |length: usize, offset: usize| {
+      let table_area = if self.footer.is_some() {
+        let [content_area, _] = Layout::vertical([Constraint::Fill(0), Constraint::Length(2)])
+          .margin(self.margin)
+          .areas(area);
+        content_area
+      } else {
+        area
+      };
+      let popup_area = Rect {
+        height: 7,
+        ..centered_rect(30, 20, table_area)
+      };
+      let [text_box_area, _] = Layout::vertical([Constraint::Length(3), Constraint::Length(1)])
+        .margin(1)
+        .areas(popup_area);
+      f.set_cursor_position(Position {
+        x: text_box_area.x + (length - offset) as u16 + 1,
+        y: text_box_area.y + 1,
+      });
+    };
+
+    if self.is_searching {
+      draw_cursor(self.search_box_content_length, self.search_box_offset);
+    } else if self.is_filtering {
+      draw_cursor(self.filter_box_content_length, self.filter_box_offset);
+    }
+  }
 }
 
 impl<'a, T, F> Widget for ManagarrTable<'a, T, F>

src/ui/widgets/managarr_table_tests.rs

@@ -2,13 +2,14 @@
 mod tests {
   use crate::models::stateful_list::StatefulList;
   use crate::models::stateful_table::{SortOption, StatefulTable};
-  use crate::models::Scrollable;
+  use crate::models::{HorizontallyScrollableText, Scrollable};
   use crate::ui::utils::layout_block;
   use crate::ui::widgets::managarr_table::ManagarrTable;
   use pretty_assertions::assert_eq;
   use ratatui::layout::{Alignment, Constraint};
   use ratatui::text::Text;
   use ratatui::widgets::{Block, Cell, Row};
+  use std::sync::atomic::AtomicUsize;
 
   #[test]
   fn test_managarr_table_new() {
@@ -31,6 +32,86 @@ mod tests {
     assert!(!managarr_table.is_loading);
     assert!(managarr_table.highlight_rows);
     assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
+  }
+
+  #[test]
+  fn test_managarr_table_new_search_box_populated() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+    let horizontally_scrollable_test = HorizontallyScrollableText {
+      text: "test".to_owned(),
+      offset: AtomicUsize::new(3),
+    };
+    stateful_table.search = Some(horizontally_scrollable_test);
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]));
+
+    let row_mapper = managarr_table.row_mapper;
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 4);
+    assert_eq!(managarr_table.search_box_offset, 3);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
+  }
+
+  #[test]
+  fn test_managarr_table_new_filter_box_populated() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+    let horizontally_scrollable_test = HorizontallyScrollableText {
+      text: "test".to_owned(),
+      offset: AtomicUsize::new(3),
+    };
+    stateful_table.filter = Some(horizontally_scrollable_test);
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]));
+
+    let row_mapper = managarr_table.row_mapper;
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 4);
+    assert_eq!(managarr_table.filter_box_offset, 3);
   }
 
   #[test]
@@ -56,6 +137,14 @@ mod tests {
     assert!(!managarr_table.is_loading);
     assert!(managarr_table.highlight_rows);
     assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
   }
 
   #[test]
@@ -81,6 +170,14 @@ mod tests {
     assert!(!managarr_table.is_loading);
     assert!(managarr_table.highlight_rows);
     assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
   }
 
   #[test]
@@ -106,6 +203,14 @@ mod tests {
     assert!(!managarr_table.is_loading);
     assert!(managarr_table.highlight_rows);
     assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
   }
 
   #[test]
@@ -130,6 +235,14 @@ mod tests {
     assert!(!managarr_table.is_loading);
     assert!(managarr_table.highlight_rows);
     assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
   }
 
   #[test]
@@ -154,6 +267,14 @@ mod tests {
     assert!(!managarr_table.is_loading);
     assert!(managarr_table.highlight_rows);
     assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
   }
 
   #[test]
@@ -177,6 +298,14 @@ mod tests {
     assert!(!managarr_table.is_loading);
     assert!(managarr_table.highlight_rows);
     assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
   }
 
   #[test]
@@ -201,6 +330,14 @@ mod tests {
     assert_eq!(managarr_table.margin, 0);
     assert!(managarr_table.highlight_rows);
     assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
   }
 
   #[test]
@@ -225,6 +362,14 @@ mod tests {
     assert_eq!(managarr_table.margin, 0);
     assert!(!managarr_table.is_loading);
     assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
   }
 
   #[test]
@@ -249,6 +394,142 @@ mod tests {
     assert_eq!(managarr_table.margin, 0);
     assert!(!managarr_table.is_loading);
     assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
+  }
+
+  #[test]
+  fn test_managarr_table_is_searching() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .searching(true);
+
+    let row_mapper = managarr_table.row_mapper;
+    assert!(managarr_table.is_searching);
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
+  }
+
+  #[test]
+  fn test_managarr_table_search_produced_empty_results() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .search_produced_empty_results(true);
+
+    let row_mapper = managarr_table.row_mapper;
+    assert!(managarr_table.search_produced_empty_results);
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.is_filtering);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
+  }
+
+  #[test]
+  fn test_managarr_table_is_filtering() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .filtering(true);
+
+    let row_mapper = managarr_table.row_mapper;
+    assert!(managarr_table.is_filtering);
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
+  }
+
+  #[test]
+  fn test_managarr_table_filter_produced_empty_results() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .filter_produced_empty_results(true);
+
+    let row_mapper = managarr_table.row_mapper;
+    assert!(managarr_table.filter_produced_empty_results);
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+    assert!(!managarr_table.is_searching);
+    assert!(!managarr_table.search_produced_empty_results);
+    assert!(!managarr_table.is_filtering);
+    assert_eq!(managarr_table.search_box_content_length, 0);
+    assert_eq!(managarr_table.search_box_offset, 0);
+    assert_eq!(managarr_table.filter_box_content_length, 0);
+    assert_eq!(managarr_table.filter_box_offset, 0);
   }
 
   #[test]

src/ui/widgets/mod.rs

@@ -7,3 +7,4 @@ pub(super) mod managarr_table;
 pub(super) mod message;
 pub(super) mod popup;
 pub(super) mod selectable_list;
+mod input_box_popup;

src/ui/widgets/popup.rs

@@ -22,6 +22,7 @@ pub enum Size {
   Small,
   Medium,
   Large,
+  XXLarge,
   Long,
 }
 
@@ -40,6 +41,7 @@ impl Size {
       Size::Small => (40, 40),
       Size::Medium => (60, 60),
       Size::Large => (75, 75),
+      Size::XXLarge => (90, 90),
       Size::Long => (65, 75),
     }
   }
@@ -118,6 +120,6 @@ impl<'a, T: Widget> Popup<'a, T> {
 
 impl<'a, T: Widget> Widget for Popup<'a, T> {
   fn render(self, area: Rect, buf: &mut Buffer) {
-    self.render_popup(area, buf);
+      self.render_popup(area, buf);
   }
 }

src/ui/widgets/popup_tests.rs

@@ -18,6 +18,7 @@ mod tests {
     assert_eq!(Size::Small.to_percent(), (40, 40));
     assert_eq!(Size::Medium.to_percent(), (60, 60));
     assert_eq!(Size::Large.to_percent(), (75, 75));
+    assert_eq!(Size::XXLarge.to_percent(), (90, 90));
     assert_eq!(Size::Long.to_percent(), (65, 75));
   }