Refine Wi-Fi UI to impala-style layout

Author: skibidiandulka

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "nettui"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2024"
 description = "Unified TUI for Wi-Fi and Ethernet"
 license = "GPL-3.0-only"

Cargo.toml

@@ -283,6 +283,7 @@ impl App {
             .cloned()
             .ok_or_else(|| std::io::Error::other("no wifi adapter found"))?;
         self.wifi_backend.scan(&iface).await?;
+        tokio::time::sleep(Duration::from_millis(1200)).await;
         self.last_action = Some(format!("Wi-Fi scan requested on {iface}"));
         self.set_toast(ToastKind::Info, format!("Wi-Fi scan requested on {iface}"));
         self.notify("Wi-Fi", &format!("Scan requested on {iface}"))
@@ -529,6 +530,7 @@ mod tests {
             connected_ssid: Some("Home".to_string()),
             known_networks: vec![],
             new_networks: vec![],
+            device: None,
         };
         let ethernet = EthernetState {
             ifaces: vec![EthernetIface {
@@ -557,6 +559,7 @@ mod tests {
             connected_ssid: None,
             known_networks: vec![],
             new_networks: vec![],
+            device: None,
         };
         let ethernet = EthernetState { ifaces: vec![] };
 

src/app.rs

@@ -1,6 +1,6 @@
 use crate::{
     backend::traits::WifiBackend,
-    domain::wifi::{WifiNetwork, WifiState},
+    domain::wifi::{WifiDeviceInfo, WifiNetwork, WifiState},
 };
 use anyhow::Result;
 use std::collections::HashSet;
@@ -38,6 +38,7 @@ impl WifiBackend for IwdBackend {
         let connected_ssid = parse_connected_network(&iface);
         let mut known_networks = parse_known_networks();
         let mut new_networks = parse_networks(&iface);
+        let station_info = parse_station_info(&iface);
 
         if let Some(conn) = &connected_ssid {
             for n in &mut known_networks {
@@ -56,11 +57,25 @@ impl WifiBackend for IwdBackend {
         let known_ssids: HashSet<&str> = known_networks.iter().map(|n| n.ssid.as_str()).collect();
         new_networks.retain(|n| !known_ssids.contains(n.ssid.as_str()));
 
+        let security = station_info.security.unwrap_or_else(|| {
+            infer_connected_security(&known_networks, &new_networks)
+                .unwrap_or_else(|| "-".to_string())
+        });
+
         Ok(WifiState {
             ifaces,
             connected_ssid,
             known_networks,
             new_networks,
+            device: Some(WifiDeviceInfo {
+                iface: iface.clone(),
+                mode: "station".to_string(),
+                powered: "On".to_string(),
+                state: station_info.state.unwrap_or_else(|| "-".to_string()),
+                scanning: station_info.scanning.unwrap_or_else(|| "-".to_string()),
+                frequency: station_info.frequency.unwrap_or_else(|| "-".to_string()),
+                security,
+            }),
         })
     }
 }
@@ -157,6 +172,8 @@ fn parse_networks(iface: &str) -> Vec<WifiNetwork> {
             security,
             signal,
             connected,
+            hidden: None,
+            autoconnect: None,
         });
     }
 
@@ -202,12 +219,75 @@ fn parse_known_networks() -> Vec<WifiNetwork> {
             security,
             signal: "-".to_string(),
             connected: false,
+            hidden: None,
+            autoconnect: None,
         });
     }
 
     nets
 }
 
+#[derive(Default)]
+struct StationInfo {
+    state: Option<String>,
+    scanning: Option<String>,
+    frequency: Option<String>,
+    security: Option<String>,
+}
+
+fn parse_station_info(iface: &str) -> StationInfo {
+    let out = std::process::Command::new("iwctl")
+        .arg("station")
+        .arg(iface)
+        .arg("show")
+        .output();
+
+    let Ok(out) = out else {
+        return StationInfo::default();
+    };
+    if !out.status.success() {
+        return StationInfo::default();
+    }
+
+    let txt = String::from_utf8_lossy(&out.stdout);
+    let mut info = StationInfo::default();
+
+    for raw in txt.lines() {
+        let line = raw.trim();
+        if let Some(v) = value_after_key(line, "State") {
+            info.state = Some(v.to_string());
+        } else if let Some(v) = value_after_key(line, "Scanning") {
+            info.scanning = Some(v.to_string());
+        } else if let Some(v) = value_after_key(line, "Frequency") {
+            info.frequency = Some(v.to_string());
+        } else if let Some(v) = value_after_key(line, "Security") {
+            info.security = Some(v.to_string());
+        }
+    }
+
+    info
+}
+
+fn value_after_key<'a>(line: &'a str, key: &str) -> Option<&'a str> {
+    if !line.starts_with(key) {
+        return None;
+    }
+    let mut rest = &line[key.len()..];
+    rest = rest.trim();
+    if let Some(stripped) = rest.strip_prefix(':') {
+        rest = stripped.trim();
+    }
+    if rest.is_empty() { None } else { Some(rest) }
+}
+
+fn infer_connected_security(known: &[WifiNetwork], new: &[WifiNetwork]) -> Option<String> {
+    known
+        .iter()
+        .find(|n| n.connected)
+        .map(|n| n.security.clone())
+        .or_else(|| new.iter().find(|n| n.connected).map(|n| n.security.clone()))
+}
+
 async fn run_iwctl(args: &[&str]) -> Result<()> {
     let out = Command::new("iwctl").args(args).output().await?;
     if out.status.success() {

src/backend/iwd.rs

@@ -4,6 +4,19 @@ pub struct WifiNetwork {
     pub security: String,
     pub signal: String,
     pub connected: bool,
+    pub hidden: Option<bool>,
+    pub autoconnect: Option<bool>,
+}
+
+#[derive(Debug, Clone)]
+pub struct WifiDeviceInfo {
+    pub iface: String,
+    pub mode: String,
+    pub powered: String,
+    pub state: String,
+    pub scanning: String,
+    pub frequency: String,
+    pub security: String,
 }
 
 #[derive(Debug, Clone)]
@@ -12,6 +25,7 @@ pub struct WifiState {
     pub connected_ssid: Option<String>,
     pub known_networks: Vec<WifiNetwork>,
     pub new_networks: Vec<WifiNetwork>,
+    pub device: Option<WifiDeviceInfo>,
 }
 
 impl WifiState {
@@ -21,6 +35,7 @@ impl WifiState {
             connected_ssid: None,
             known_networks: Vec::new(),
             new_networks: Vec::new(),
+            device: None,
         }
     }
 

src/domain/wifi.rs

@@ -1,6 +1,6 @@
 use crate::{
     app::App,
-    domain::common::{ActiveTab, ToastKind, WifiFocus},
+    domain::common::{ActiveTab, ToastKind},
 };
 use ratatui::{
     Frame,
@@ -53,23 +53,15 @@ pub fn render_footer(app: &App, frame: &mut Frame, area: Rect) {
 
     match app.active_tab {
         ActiveTab::Wifi => {
-            let focus = match app.wifi_focus {
-                WifiFocus::KnownNetworks => "Known",
-                WifiFocus::NewNetworks => "New",
-                WifiFocus::Adapter => "Adapter",
-            };
             spans.extend([
                 Span::from("Tab").bold(),
                 Span::from(" section"),
                 Span::from(" | "),
-                Span::from("focus:").bold(),
-                Span::from(format!(" {focus}")),
-                Span::from(" | "),
                 Span::from("s").bold(),
                 Span::from(" scan"),
                 Span::from(" | "),
                 Span::from("Enter").bold(),
-                Span::from(" connect/disconnect"),
+                Span::from(" dis/connect"),
                 Span::from(" | "),
                 Span::from("i").bold(),
                 Span::from(" details"),

src/ui/components.rs

@@ -9,7 +9,7 @@ use ratatui::{
 };
 
 pub fn render(app: &mut App, frame: &mut Frame) {
-    const MIN_W: u16 = 90;
+    const MIN_W: u16 = 118;
     const MIN_H: u16 = 26;
 
     let area = frame.area();