Refactor modals

Now modals receive a lambda that returns an Action. This makes modals
infinitely more reusable than the previous ones. To illustrate, this is
now possible:

```rust
let add_modal = Box::new(
    InputModal::new()
        .style(Style::default().fg(Color::BrightRed))
        .on_commit(|input| Action::AddSong(input))
);

let rename_modal = Box::new(
    InputModal::new()
        .style(Style::default().fg(Color::Blue))
        .on_commit(|input| Action::RenameSongTo(input))
);
```

No special case handling for each type of modal!

Also, modals now send Action::CloseModal when appropriate, which closes
any open modal. Previously each modal had its own match case to close
itself...

tori/src/app/modal/confirmation_modal.rs

@@ -1,4 +1,4 @@
-use super::{get_modal_chunk, Message, Modal};
+use super::{get_modal_chunk, Modal};
 
 use crossterm::event::{Event, KeyCode};
 use tui::{
@@ -8,39 +8,67 @@ use tui::{
     widgets::{Block, BorderType, Borders, Clear, Paragraph, Widget},
 };
 
-use crate::error::Result;
+use crate::{
+    error::Result,
+    events::{channel::Tx, Action},
+};
 
 /// A confirmation modal box that asks for user yes/no input
 #[derive(Debug, Default)]
-pub struct ConfirmationModal {
+pub struct ConfirmationModal<C, N> {
     title: String,
     style: Style,
+    on_yes: Option<C>,
+    on_no: Option<N>,
 }
 
-impl ConfirmationModal {
+impl<C, N> ConfirmationModal<C, N> {
     pub fn new(title: &str) -> Self {
         Self {
             title: format!("\n{} (y/n)", title),
             style: Style::default().fg(Color::LightBlue),
+            on_yes: None,
+            on_no: None,
         }
     }
-}
 
-impl Modal for ConfirmationModal {
-    fn apply_style(&mut self, style: Style) {
+    pub fn style(mut self, style: Style) -> Self {
         self.style = style;
+        self
+    }
+
+    pub fn on_yes(mut self, action: C) -> Self {
+        self.on_yes = Some(action);
+        self
     }
 
-    fn handle_event(&mut self, event: Event) -> Result<Message> {
+    pub fn on_no(mut self, action: N) -> Self {
+        self.on_no = Some(action);
+        self
+    }
+}
+
+impl<C, N> Modal for ConfirmationModal<C, N>
+where
+    C: Fn() -> Action + Send + Sync,
+    N: Fn() -> Action + Send + Sync,
+{
+    fn handle_event(&mut self, tx: Tx, event: Event) -> Result<Option<Action>> {
         use KeyCode::*;
         if let Event::Key(event) = event {
-            return match event.code {
-                Backspace | Esc | Char('q') | Char('n') | Char('N') => Ok(Message::Quit),
-                Enter | Char('y') | Char('Y') => Ok(Message::Commit("y".into())),
-                _ => Ok(Message::Nothing),
-            };
+            return Ok(match event.code {
+                Backspace | Esc | Char('q') | Char('n') | Char('N') => {
+                    tx.send(Action::CloseModal);
+                    self.on_no.as_ref().map(|f| f())
+                }
+                Enter | Char('y') | Char('Y') => {
+                    tx.send(Action::CloseModal);
+                    self.on_yes.as_ref().map(|f| f())
+                }
+                _ => None,
+            });
         }
-        Ok(Message::Nothing)
+        Ok(None)
     }
 
     fn render(&self, area: Rect, buf: &mut Buffer) {

tori/src/app/modal/help_modal.rs

@@ -1,19 +1,19 @@
-use super::{get_modal_chunk, Message, Modal};
+use super::Modal;
 
 use crossterm::event::Event;
 use tui::{
     layout::{Alignment, Constraint},
+    prelude::*,
     style::{Color, Style},
     text::{Line, Span},
     widgets::{Block, BorderType, Borders, Clear, Paragraph, Row, Table, Widget},
-    prelude::*,
 };
 use unicode_width::UnicodeWidthStr;
 
 use crate::{
     config::{shortcuts::InputStr, Config},
     error::Result,
-    events::Command,
+    events::{channel::Tx, Action, Command},
 };
 
 /// A modal box that asks for user input
@@ -60,19 +60,21 @@ impl HelpModal {
 }
 
 impl Modal for HelpModal {
-    fn apply_style(&mut self, _style: Style) {}
-
-    fn handle_event(&mut self, event: Event) -> Result<Message> {
+    fn handle_event(&mut self, tx: Tx, event: Event) -> Result<Option<Action>> {
         if let Event::Key(_) = event {
-            return Ok(Message::Quit);
+            return Ok(Some(Action::CloseModal));
         }
-        Ok(Message::Nothing)
+        Ok(None)
     }
 
     fn render(&self, area: Rect, buf: &mut Buffer) {
-        let mut chunk = get_modal_chunk(area);
-        chunk.y = 3;
-        chunk.height = area.height.saturating_sub(6);
+        let width = (area.width / 2).max(70).min(area.width);
+        let mut chunk = Rect {
+            x: area.width.saturating_sub(width) / 2,
+            width,
+            y: 3,
+            height: area.height.saturating_sub(6),
+        };
 
         let block = Block::default()
             .title(" Help ")

tori/src/app/modal/hotkey_modal.rs

@@ -1,37 +1,33 @@
 use crate::{
     config::shortcuts::InputStr,
     error::Result,
+    events::{channel::Tx, Action},
 };
-use crossterm::event::Event as CrosstermEvent;
+use crossterm::event::{Event, KeyCode};
 use tui::{
     layout::Alignment,
+    prelude::*,
     style::{Color, Style},
     widgets::{Block, BorderType, Borders, Clear, Paragraph, Widget},
-    prelude::*,
 };
 
 use super::Modal;
 
-///////////////////////////////
-//        HotkeyModal        //
-///////////////////////////////
 /// Shows what keys the user is pressing
 #[derive(Debug, Default)]
 pub struct HotkeyModal {
     text: String,
 }
 
 impl Modal for HotkeyModal {
-    fn apply_style(&mut self, _style: Style) {}
-
-    fn handle_event(&mut self, event: CrosstermEvent) -> Result<super::Message> {
-        if let CrosstermEvent::Key(key) = event {
-            if let crossterm::event::KeyCode::Esc = key.code {
-                return Ok(super::Message::Quit);
+    fn handle_event(&mut self, tx: Tx, event: Event) -> Result<Option<Action>> {
+        if let Event::Key(key) = event {
+            if let KeyCode::Esc = key.code {
+                return Ok(Some(Action::CloseModal));
             }
             self.text = InputStr::from(key).0;
         }
-        Ok(super::Message::Nothing)
+        Ok(None)
     }
 
     fn render(&self, area: Rect, buf: &mut Buffer) {