add help message for station

Author: pythops

src/adapter.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{fmt::format, sync::Arc};
 
 use anyhow::Context;
 
@@ -7,13 +7,14 @@ use ratatui::{
     Frame,
     layout::{Alignment, Constraint, Direction, Flex, Layout},
     style::{Color, Style, Stylize},
-    text::Line,
+    text::{Line, Text},
     widgets::{Block, BorderType, Borders, Cell, Clear, List, Padding, Row, Table, TableState},
 };
 use tokio::sync::mpsc::UnboundedSender;
 
 use crate::{
     app::{AppResult, ColorMode, FocusedBlock},
+    config::Config,
     device::Device,
     event::Event,
 };
@@ -27,10 +28,15 @@ pub struct Adapter {
     pub vendor: Option<String>,
     pub supported_modes: Vec<String>,
     pub device: Device,
+    pub config: Arc<Config>,
 }
 
 impl Adapter {
-    pub async fn new(session: Arc<Session>, sender: UnboundedSender<Event>) -> AppResult<Self> {
+    pub async fn new(
+        session: Arc<Session>,
+        sender: UnboundedSender<Event>,
+        config: Arc<Config>,
+    ) -> AppResult<Self> {
         let adapter = session.adapter().context("No adapter found")?;
 
         let is_powered = adapter.is_powered().await?;
@@ -48,6 +54,7 @@ impl Adapter {
             vendor,
             supported_modes,
             device,
+            config,
         })
     }
 
@@ -431,18 +438,19 @@ impl Adapter {
         color_mode: ColorMode,
         focused_block: FocusedBlock,
     ) {
-        let (device_block, station_block, known_networks_block, new_networks_block) = {
+        let (device_block, station_block, known_networks_block, new_networks_block, help_block) = {
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
                 .constraints([
                     Constraint::Length(5),
                     Constraint::Length(5),
                     Constraint::Min(5),
                     Constraint::Min(5),
+                    Constraint::Length(3),
                 ])
                 .margin(1)
                 .split(frame.area());
-            (chunks[0], chunks[1], chunks[2], chunks[3])
+            (chunks[0], chunks[1], chunks[2], chunks[3], chunks[4])
         };
 
         // Device
@@ -984,6 +992,39 @@ impl Adapter {
             new_networks_block,
             &mut new_networks_state,
         );
+
+        let help_message = match focused_block {
+            FocusedBlock::Device => {
+                format!(
+                    "⇄: Nav | {}: Scan | {}: Show information | {}: Toggle power",
+                    self.config.station.start_scanning,
+                    self.config.device.infos,
+                    self.config.device.toggle_power
+                )
+            }
+            FocusedBlock::Station => format!(
+                "⇄: Nav | {}: Start Scanning",
+                self.config.station.start_scanning
+            ),
+            FocusedBlock::KnownNetworks => format!(
+                "k,↑: Up | j,↓: Down | ⇄: Nav | {}: Connect/Disconnect | {}: Remove | {}: Toggle autoconnect",
+                if self.config.station.toggle_connect == ' ' {
+                    "Space"
+                } else {
+                    &self.config.station.toggle_connect.to_string()
+                },
+                self.config.station.known_network.remove,
+                self.config.station.known_network.toggle_autoconnect
+            ),
+            FocusedBlock::NewNetworks => {
+                "k,↑: Up | j,↓: Down | ⇄: Nav | Space: Connect".to_string()
+            }
+            _ => "".to_string(),
+        };
+
+        let help_message = Text::from(help_message).centered().bold().blue();
+
+        frame.render_widget(help_message, help_block);
     }
 
     pub fn render_adapter(&self, frame: &mut Frame, color_mode: ColorMode) {

src/app.rs

@@ -18,7 +18,7 @@ use async_channel::{Receiver, Sender};
 use futures::FutureExt;
 use iwdrs::{agent::Agent, modes::Mode, session::Session};
 
-use crate::{adapter::Adapter, event::Event, notification::Notification};
+use crate::{adapter::Adapter, config::Config, event::Event, notification::Notification};
 
 pub type AppResult<T> = std::result::Result<T, Box<dyn Error>>;
 
@@ -89,7 +89,11 @@ pub async fn request_confirmation(
 }
 
 impl App {
-    pub async fn new(mode: Mode, sender: UnboundedSender<Event>) -> AppResult<Self> {
+    pub async fn new(
+        config: Arc<Config>,
+        mode: Mode,
+        sender: UnboundedSender<Event>,
+    ) -> AppResult<Self> {
         let session = {
             match iwdrs::session::Session::new().await {
                 Ok(session) => Arc::new(session),
@@ -100,7 +104,7 @@ impl App {
             }
         };
 
-        let adapter = match Adapter::new(session.clone(), sender).await {
+        let adapter = match Adapter::new(session.clone(), sender, config).await {
             Ok(v) => v,
             Err(e) => {
                 eprintln!("{e}");
@@ -159,15 +163,19 @@ impl App {
         })
     }
 
-    pub async fn reset(mode: Mode, sender: UnboundedSender<Event>) -> AppResult<()> {
+    pub async fn reset(
+        mode: Mode,
+        sender: UnboundedSender<Event>,
+        config: Arc<Config>,
+    ) -> AppResult<()> {
         let session = {
             match iwdrs::session::Session::new().await {
                 Ok(session) => Arc::new(session),
                 Err(e) => return Err(anyhow!("Can not access the iwd service: {}", e).into()),
             }
         };
 
-        let adapter = match Adapter::new(session.clone(), sender).await {
+        let adapter = match Adapter::new(session.clone(), sender, config).await {
             Ok(v) => v,
             Err(e) => {
                 eprintln!("{e}");

src/main.rs

@@ -29,14 +29,14 @@ async fn main() -> AppResult<()> {
 
     let mode = Mode::try_from(mode.as_str())?;
 
-    if App::reset(mode.clone(), tui.events.sender.clone())
+    if App::reset(mode.clone(), tui.events.sender.clone(), config.clone())
         .await
         .is_err()
     {
         tui.exit()?;
     }
 
-    let mut app = App::new(mode, tui.events.sender.clone()).await?;
+    let mut app = App::new(config.clone(), mode, tui.events.sender.clone()).await?;
 
     while app.running {
         tui.draw(&mut app)?;
@@ -55,13 +55,13 @@ async fn main() -> AppResult<()> {
                 app.notifications.push(notification);
             }
             Event::Reset(mode) => {
-                if App::reset(mode.clone(), tui.events.sender.clone())
+                if App::reset(mode.clone(), tui.events.sender.clone(), config.clone())
                     .await
                     .is_err()
                 {
                     tui.exit()?;
                 }
-                app = App::new(mode, tui.events.sender.clone()).await?;
+                app = App::new(config.clone(), mode, tui.events.sender.clone()).await?;
             }
             _ => {}
         }