src/app/mod.rs

@@ -102,66 +102,51 @@ impl App {
         Ok(())
     }
 
-    async fn handle_key_event(&mut self, key_event: KeyEvent, event: crossterm::event::Event) {
+    pub async fn handle_key_event(&mut self, key_event: KeyEvent, event: crossterm::event::Event) {
-        let code = key_event.code;
+        match self.screen.last_mut().unwrap() {
-        let mode = self.screen.last_mut().unwrap();
+            CurrentScreen::Logging => match key_event.code {
-        match mode {
-            CurrentScreen::Main
-            | CurrentScreen::Logging
-            | CurrentScreen::Receiving
-            | CurrentScreen::Sending(SendingScreen::Files)
-            | CurrentScreen::Sending(SendingScreen::Peers) => match code {
                 KeyCode::Esc => self.pop(),
-                KeyCode::Char('q') => self.exit(),
-                KeyCode::Char('s') => self.send(),
-                KeyCode::Char('r') => self.recv(),
-                KeyCode::Char('l') => self.logs(),
-                _ => match mode {
-                    CurrentScreen::Logging => match code {
                 KeyCode::Left => change_log_level(-1),
                 KeyCode::Right => change_log_level(1),
+                KeyCode::Char('q') => self.exit(),
                 _ => {}
             },
-                    CurrentScreen::Receiving => match code {
+            CurrentScreen::Receiving => match key_event.code {
                 KeyCode::Up => self.receiving_state.select_previous(),
                 KeyCode::Down => self.receiving_state.select_next(),
                 KeyCode::Char('a') => self.accept(),
                 KeyCode::Char('d') => self.deny(),
+                KeyCode::Esc => self.pop(),
+                KeyCode::Char('q') => self.exit(),
                 _ => {}
             },
-                    CurrentScreen::Sending(sending_screen) => match sending_screen {
+            CurrentScreen::Sending(s) => match s {
-                        SendingScreen::Files => match code {
+                SendingScreen::Files => match key_event.code {
-                            KeyCode::Char('t') => *sending_screen = SendingScreen::Text,
+                    KeyCode::Esc => self.pop(),
-                            KeyCode::Tab => *sending_screen = SendingScreen::Peers,
+                    KeyCode::Char('q') => self.exit(),
-                            KeyCode::Enter => self.chdir_or_send_file().await,
+                    KeyCode::Tab => *s = SendingScreen::Peers,
+                    KeyCode::Enter => self.send_content().await,
                     _ => self.file_picker.handle(&event).unwrap_or_default(),
                 },
-                        SendingScreen::Peers => match code {
+                SendingScreen::Peers => match key_event.code {
-                            KeyCode::Tab => *sending_screen = SendingScreen::Files,
+                    KeyCode::Esc => self.pop(),
+                    KeyCode::Char('q') => self.exit(),
+                    KeyCode::Tab => *s = SendingScreen::Files,
                     KeyCode::Enter => self.send_content().await,
                     KeyCode::Up => self.peer_state.select_previous(),
                     KeyCode::Down => self.peer_state.select_next(),
                     _ => {}
                 },
-                        _ => unreachable!(),
+                SendingScreen::Text => {}
             },
+            _ => match key_event.code {
+                KeyCode::Char('q') => self.exit(),
+                KeyCode::Char('s') => self.send(),
+                KeyCode::Char('r') => self.recv(),
+                KeyCode::Char('l') => self.logs(),
+                KeyCode::Esc => self.pop(),
                 _ => {}
             },
-            },
-            CurrentScreen::Sending(sending_screen) => match sending_screen {
-                SendingScreen::Text => match code {
-                    KeyCode::Tab => *sending_screen = SendingScreen::Peers,
-                    KeyCode::Enter => self.send_text().await,
-                    KeyCode::Esc => {
-                        self.text = None;
-                        *sending_screen = SendingScreen::Files;
-                    }
-                    _ => { /* todo: add input widget to handle key input here */ }
-                },
-                _ => unreachable!(),
-            },
-
-            CurrentScreen::Stopping => {}
         }
     }
 
@@ -245,14 +230,9 @@ impl App {
         self.receive_requests.remove(key);
     }
 
-    async fn chdir_or_send_file(&mut self) {
+    // send content to selected peer, or change directories in the file explorer
-        let file = self.file_picker.current().path().clone();
+    async fn send_content(&mut self) {
-        if file.is_dir()
+        debug!("sending content");
-            && let Err(e) = self.file_picker.set_cwd(&file)
-        {
-            error!("could not list directory {file:?}: {e}");
-            return;
-        }
 
         let Some(peer_idx) = self.peer_state.selected() else {
             warn!("no peer selected to send to");
@@ -263,42 +243,29 @@ impl App {
             return;
         };
 
-        if file.is_file() {
+        if let Some(ref text) = self.text {
-            debug!("sending {file:?}");
-            if let Err(e) = self.service.send_file(&peer.fingerprint, file).await {
-                error!("got error sending content: {e:?}");
-            }
-        }
-    }
-
-    // send content to selected peer, or change directories in the file explorer
-    async fn send_text(&mut self) {
-        debug!("sending text");
-
-        let Some(peer_idx) = self.peer_state.selected() else {
-            debug!("no peer selected to send to");
-            return;
-        };
-        let Some(peer) = self.peers.get(peer_idx) else {
-            warn!("invalid peer index {peer_idx}");
-            return;
-        };
-
-        let Some(text) = &self.text else {
-            debug!("no text to send");
-            return;
-        };
-
             if let Err(e) = self.service.send_text(&peer.fingerprint, text).await {
                 error!("got error sending \"{text}\" to {}: {e:?}", peer.alias);
             }
+        } else {
+            let file = self.file_picker.current().path().clone();
+            if file.is_dir()
+                && let Err(e) = self.file_picker.set_cwd(&file)
+            {
+                error!("could not list directory {file:?}: {e}");
+                return;
             }
 
-    async fn send_content(&mut self) {
+            if file.is_file() {
-        if self.text.is_some() {
+                debug!("sending {file:?}");
-            self.send_text().await;
+                if let Err(e) = self
-        } else {
+                    .service
-            self.chdir_or_send_file().await;
+                    .send_file(&peer.fingerprint, file.clone())
+                    .await
+                {
+                    error!("got error sending content: {e:?}");
+                }
+            }
         }
     }
 }

src/app/widgets.rs

@@ -128,11 +128,12 @@ impl Widget for &mut App {
                 let rx_reqs: Vec<_> = self.receive_requests.values().collect();
                 outer_frame(*current_screen, &MAIN_MENU, area, buf);
                 logger(header_right.inner(header_margin), buf);
-                peers(
+                let peers = PeersWidget { peers: &self.peers };
-                    &self.peers,
+                ratatui::widgets::StatefulWidget::render(
-                    &mut self.peer_state,
+                    peers,
                     footer_right.inner(footer_margin),
                     buf,
+                    &mut self.peer_state,
                 );
                 NetworkInfoWidget.render(footer_left.inner(footer_margin), buf);
                 receive_requests(
@@ -168,16 +169,18 @@ impl Widget for &mut App {
                     SendingScreen::Text => {}
                 }
 
+                let peers = PeersWidget { peers: &self.peers };
+
                 self.file_picker
                     .widget()
                     .render(header_left.inner(header_margin), buf);
                 logger(header_right.inner(header_margin), buf);
 
-                peers(
+                ratatui::widgets::StatefulWidget::render(
-                    &self.peers,
+                    peers,
-                    &mut self.peer_state,
                     bottom.inner(subscreen_margin),
                     buf,
+                    &mut self.peer_state,
                 );
             }
             _ => {
@@ -269,20 +272,31 @@ fn receive_requests(
     ratatui::widgets::StatefulWidget::render(table, area, buf, state);
 }
 
-fn peers(peers: &[Peer], state: &mut ListState, area: Rect, buf: &mut Buffer) {
+#[derive(Debug, Clone)]
-    if peers.is_empty() {
+pub struct PeersWidget<'p> {
+    pub peers: &'p [Peer],
+}
+
+impl<'p> ratatui::widgets::StatefulWidget for PeersWidget<'p> {
+    type State = ListState;
+
+    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State)
+    where
+        Self: Sized,
+    {
+        if self.peers.is_empty() {
             state.select(None);
         }
         if state.selected().is_none() {
             state.select(Some(0));
         }
 
-    let mut items = Vec::with_capacity(peers.len());
+        let mut items = Vec::with_capacity(self.peers.len());
         for Peer {
             addr,
             alias,
             fingerprint,
-    } in peers
+        } in self.peers.iter()
         {
             let item = format!("{:?}: {} ({})", addr, alias, fingerprint);
             let s = Line::from(item.yellow());
@@ -299,6 +313,7 @@ fn peers(peers: &[Peer], state: &mut ListState, area: Rect, buf: &mut Buffer) {
             .highlight_style(Style::new().bg(Color::Rgb(99, 99, 99)));
         ratatui::widgets::StatefulWidget::render(list, area, buf, state);
     }
+}
 
 #[derive(Debug, Clone)]
 pub struct NetworkInfoWidget;
@@ -349,7 +364,7 @@ impl Widget for NetworkInfoWidget {
 }
 
 // helpers
-fn _centered_rect(area: Rect, width_pct: u16, height_pct: u16) -> Rect {
+fn centered_rect(area: Rect, width_pct: u16, height_pct: u16) -> Rect {
     let horizontal = Layout::horizontal([Constraint::Percentage(width_pct)]).flex(Flex::Center);
     let vertical = Layout::vertical([Constraint::Percentage(height_pct)]).flex(Flex::Center);
     let [area] = vertical.areas(area);