v0.3.1: Fix mouse support for all tabs, per-tab sorting

Mouse support fixes:
- Fix tab bar click regions for Net and GPU tabs (off-by-one)
- Fix row click selection for Net/GPU tabs (was always targeting Main tab)
- Enable column header click sorting for Net and GPU tabs
- Add per-tab sort state (net_sort_field, gpu_sort_field) so each tab
  remembers its own sort column and direction independently
- Sort indicator arrows now display correctly per-tab
- F6 sort menu, < > cycling, and I (invert) all work per-tab
- Collector uses user's sort preference instead of hardcoded order

README: Remove outdated GetPerTcpConnectionEStats references, clarify
Net tab works without admin.

Author: Your Name

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pstop"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2021"
 description = "htop for Windows — beautiful, fast TUI system monitor with per-core CPU bars, memory/swap/network, tree view, process management, 7 color schemes, mouse support. Drop-in htop replacement for PowerShell & Windows Terminal."
 license = "MIT"

Cargo.toml

@@ -139,7 +139,7 @@ Press `F5` or `t` to toggle process tree view — see parent-child relationships
 ### 📋 Four Tab Views
 - **Main** - Full process table (PID, USER, CPU%, MEM%, TIME+, Command...)
 - **I/O** - Disk read/write rates per process
-- **Net** - Per-process network bandwidth (live download/upload rates with auto-scaling B/s, KB/s, MB/s, GB/s) plus active connection counts via `GetPerTcpConnectionEStats`. Admin recommended for bandwidth data.
+- **Net** - Per-process network bandwidth (live download/upload rates with auto-scaling B/s, KB/s, MB/s, GB/s) plus active connection counts. No admin required.
 - **GPU** - Per-process GPU engine utilization and dedicated/shared video memory usage via PDH performance counters
 
 ### ⚙️ F2 Setup Menu (Full htop Parity)
@@ -264,7 +264,7 @@ Format: simple `key=value` (htoprc-style). Persisted settings include:
 - [x] WinGet (`winget install marlocarlo.pstop`)
 - [x] Chocolatey (`choco install pstop`)
 - [x] GPU monitoring (per-process GPU engine usage + VRAM, header GPU/VMem bars)
-- [x] Network per-process tracking (live bandwidth via GetPerTcpConnectionEStats)
+- [x] Network per-process tracking (live bandwidth, no admin required)
 - [x] Auto-adjusting CPU column layout (2/4/8/16 columns based on core count)
 - [x] Independent htop-style header panel flow (no forced alignment)
 - [ ] Scoop bucket

README.md

@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2015/06/nuspec.xsd">
   <metadata>
     <id>pstop</id>
-    <version>0.3.0</version>
+    <version>0.3.1</version>
     <title>pstop - htop for Windows</title>
     <authors>marlocarlo</authors>
     <owners>marlocarlo</owners>

choco/pstop.nuspec

@@ -69,12 +69,20 @@ pub struct App {
     pub scroll_offset: usize,
     pub visible_rows: usize,
 
-    // Sorting
+    // Sorting (Main/IO tab)
     pub sort_field: ProcessSortField,
     pub sort_ascending: bool,
     pub sort_menu_index: usize,
     pub sort_scroll_offset: usize,
 
+    // Sorting (Net tab)
+    pub net_sort_field: ProcessSortField,
+    pub net_sort_ascending: bool,
+
+    // Sorting (GPU tab)
+    pub gpu_sort_field: ProcessSortField,
+    pub gpu_sort_ascending: bool,
+
     // Search (F3) — transient, doesn't filter
     pub search_query: String,
     pub search_not_found: bool,
@@ -210,6 +218,12 @@ impl App {
             sort_menu_index: 9,
             sort_scroll_offset: 0,
 
+            net_sort_field: ProcessSortField::IoReadRate,  // Download by default
+            net_sort_ascending: false,
+
+            gpu_sort_field: ProcessSortField::Cpu,  // GPU% by default
+            gpu_sort_ascending: false,
+
             search_query: String::new(),
             search_not_found: false,
             filter_query: String::new(),
@@ -635,16 +649,107 @@ impl App {
         self.filtered_processes.get(self.selected_index)
     }
 
-    /// Toggle sort field (cycle through or set specific)
+    /// Get the active sort field for the current tab
+    pub fn active_sort_field(&self) -> ProcessSortField {
+        match self.active_tab {
+            ProcessTab::Main | ProcessTab::Io => self.sort_field,
+            ProcessTab::Net => self.net_sort_field,
+            ProcessTab::Gpu => self.gpu_sort_field,
+        }
+    }
+
+    /// Get the active sort ascending for the current tab
+    pub fn active_sort_ascending(&self) -> bool {
+        match self.active_tab {
+            ProcessTab::Main | ProcessTab::Io => self.sort_ascending,
+            ProcessTab::Net => self.net_sort_ascending,
+            ProcessTab::Gpu => self.gpu_sort_ascending,
+        }
+    }
+
+    /// Toggle sort field for the current tab (cycle through or set specific)
     pub fn set_sort_field(&mut self, field: ProcessSortField) {
-        if self.sort_field == field {
-            self.sort_ascending = !self.sort_ascending;
-        } else {
-            self.sort_field = field;
-            self.sort_ascending = false;
+        match self.active_tab {
+            ProcessTab::Main | ProcessTab::Io => {
+                if self.sort_field == field {
+                    self.sort_ascending = !self.sort_ascending;
+                } else {
+                    self.sort_field = field;
+                    self.sort_ascending = false;
+                }
+            }
+            ProcessTab::Net => {
+                if self.net_sort_field == field {
+                    self.net_sort_ascending = !self.net_sort_ascending;
+                } else {
+                    self.net_sort_field = field;
+                    self.net_sort_ascending = false;
+                }
+                self.sort_net_processes();
+            }
+            ProcessTab::Gpu => {
+                if self.gpu_sort_field == field {
+                    self.gpu_sort_ascending = !self.gpu_sort_ascending;
+                } else {
+                    self.gpu_sort_field = field;
+                    self.gpu_sort_ascending = false;
+                }
+                self.sort_gpu_processes();
+            }
         }
     }
 
+    /// Sort Net tab data by current net_sort_field
+    pub fn sort_net_processes(&mut self) {
+        let ascending = self.net_sort_ascending;
+        let field = self.net_sort_field;
+
+        self.net_processes.sort_by(|a, b| {
+            let ord = match field {
+                ProcessSortField::Pid => a.pid.cmp(&b.pid),
+                ProcessSortField::Command => a.name.to_lowercase().cmp(&b.name.to_lowercase()),
+                ProcessSortField::IoReadRate => a.recv_bytes_per_sec.partial_cmp(&b.recv_bytes_per_sec).unwrap_or(std::cmp::Ordering::Equal),
+                ProcessSortField::IoWriteRate => a.send_bytes_per_sec.partial_cmp(&b.send_bytes_per_sec).unwrap_or(std::cmp::Ordering::Equal),
+                ProcessSortField::Nice => a.connection_count.cmp(&b.connection_count),
+                // Default: sort by total bandwidth
+                _ => {
+                    let a_total = a.recv_bytes_per_sec + a.send_bytes_per_sec;
+                    let b_total = b.recv_bytes_per_sec + b.send_bytes_per_sec;
+                    a_total.partial_cmp(&b_total).unwrap_or(std::cmp::Ordering::Equal)
+                }
+            };
+            if ascending { ord } else { ord.reverse() }
+        });
+    }
+
+    /// Sort GPU tab data by current gpu_sort_field
+    pub fn sort_gpu_processes(&mut self) {
+        let ascending = self.gpu_sort_ascending;
+        let field = self.gpu_sort_field;
+
+        self.gpu_processes.sort_by(|a, b| {
+            let ord = match field {
+                ProcessSortField::Pid => a.pid.cmp(&b.pid),
+                ProcessSortField::Command => {
+                    // Need process names — use pid comparison as fallback
+                    a.pid.cmp(&b.pid)
+                }
+                ProcessSortField::Cpu => a.gpu_usage.partial_cmp(&b.gpu_usage).unwrap_or(std::cmp::Ordering::Equal),
+                ProcessSortField::Status => a.engine_type.cmp(&b.engine_type),
+                ProcessSortField::ResMem => a.dedicated_mem.cmp(&b.dedicated_mem),
+                ProcessSortField::SharedMem => a.shared_mem.cmp(&b.shared_mem),
+                ProcessSortField::VirtMem => {
+                    let a_total = a.dedicated_mem + a.shared_mem;
+                    let b_total = b.dedicated_mem + b.shared_mem;
+                    a_total.cmp(&b_total)
+                }
+                // Default: sort by GPU usage
+                _ => a.gpu_usage.partial_cmp(&b.gpu_usage).unwrap_or(std::cmp::Ordering::Equal),
+            };
+            if ascending { ord } else { ord.reverse() }
+        });
+    }
+
     /// Toggle tag on selected process
     pub fn toggle_tag_selected(&mut self) {
         if let Some(proc) = self.selected_process() {

src/app.rs

@@ -94,7 +94,7 @@ fn handle_normal_mode(app: &mut App, key: KeyEvent) {
 
         // ── F6 — sort menu ──
         KeyCode::F(6) => {
-            app.sort_menu_index = app.sort_field.index();
+            app.sort_menu_index = app.active_sort_field().index();
             app.sort_scroll_offset = 0;
             // Ensure current selection is visible
             if app.sort_menu_index >= 10 {
@@ -110,7 +110,13 @@ fn handle_normal_mode(app: &mut App, key: KeyEvent) {
         KeyCode::Char('M') => app.set_sort_field(ProcessSortField::Mem),
         KeyCode::Char('T') => app.set_sort_field(ProcessSortField::Time),
         KeyCode::Char('N') => app.set_sort_field(ProcessSortField::Pid),
-        KeyCode::Char('I') => app.sort_ascending = !app.sort_ascending,
+        KeyCode::Char('I') => {
+            match app.active_tab {
+                ProcessTab::Main | ProcessTab::Io => app.sort_ascending = !app.sort_ascending,
+                ProcessTab::Net => { app.net_sort_ascending = !app.net_sort_ascending; app.sort_net_processes(); }
+                ProcessTab::Gpu => { app.gpu_sort_ascending = !app.gpu_sort_ascending; app.sort_gpu_processes(); }
+            }
+        }
 
         // ── F7 — Nice - (raise priority / lower nice) ──
         KeyCode::F(7) => {
@@ -724,14 +730,24 @@ fn kill_process_with_signal(pid: u32, signal_index: usize) {
     }
 }
 
-/// Cycle through sort fields
+/// Cycle through sort fields (tab-aware: uses header fields for current tab)
 fn cycle_sort_field(app: &mut App, forward: bool) {
-    let fields = ProcessSortField::all();
-    let current_idx = fields.iter().position(|f| *f == app.sort_field).unwrap_or(0);
+    use crate::ui::process_table::{HEADERS, IO_HEADERS, NET_HEADERS, GPU_HEADERS};
+    use crate::app::ProcessTab;
+
+    let headers: &[(&str, u16, ProcessSortField, u8)] = match app.active_tab {
+        ProcessTab::Main => HEADERS,
+        ProcessTab::Io   => IO_HEADERS,
+        ProcessTab::Net  => NET_HEADERS,
+        ProcessTab::Gpu  => GPU_HEADERS,
+    };
+    let fields: Vec<ProcessSortField> = headers.iter().map(|(_, _, f, _)| *f).collect();
+    let current = app.active_sort_field();
+    let current_idx = fields.iter().position(|f| *f == current).unwrap_or(0);
     let new_idx = if forward {
         (current_idx + 1) % fields.len()
     } else {
         if current_idx == 0 { fields.len() - 1 } else { current_idx - 1 }
     };
-    app.sort_field = fields[new_idx];
+    app.set_sort_field(fields[new_idx]);
 }

src/input.rs

@@ -3,7 +3,7 @@ use crossterm::event::{MouseEvent, MouseEventKind, MouseButton};
 use crate::app::{App, AppMode, ProcessTab};
 use crate::system::process::ProcessSortField;
 use crate::ui;
-use crate::ui::process_table::{HEADERS, IO_HEADERS, compute_display_columns};
+use crate::ui::process_table::{HEADERS, IO_HEADERS, NET_HEADERS, GPU_HEADERS, compute_display_columns};
 
 /// Handle a mouse event.
 /// Requires the terminal size (columns, rows) to compute layout areas.
@@ -62,33 +62,30 @@ fn handle_tab_bar_click(app: &mut App, x: u16) {
         app.active_tab = ProcessTab::Main;
     } else if (8..13).contains(&x) {
         app.active_tab = ProcessTab::Io;
-    } else if (14..18).contains(&x) {
+    } else if (14..19).contains(&x) {
         app.active_tab = ProcessTab::Net;
-    } else if (19..24).contains(&x) {
+    } else if (20..25).contains(&x) {
         app.active_tab = ProcessTab::Gpu;
     }
 }
 
 // ── Header click (sort by column) ───────────────────────────────────
 
 fn handle_header_click(app: &mut App, x: u16, term_width: u16) {
-    // Net and GPU tabs don't support column-click sorting (different data model)
-    if matches!(app.active_tab, ProcessTab::Net | ProcessTab::Gpu) {
-        return;
-    }
-
     let headers = match app.active_tab {
         ProcessTab::Main => HEADERS,
         ProcessTab::Io   => IO_HEADERS,
-        _ => return,
+        ProcessTab::Net  => NET_HEADERS,
+        ProcessTab::Gpu  => GPU_HEADERS,
     };
 
     // Compute display columns (same logic as rendering, so clicks match)
     let base_visible: std::collections::HashSet<ProcessSortField> = match app.active_tab {
         ProcessTab::Main => app.visible_columns.clone(),
         _ => headers.iter().map(|(_, _, f, _)| *f).collect(),
     };
-    let display_cols = compute_display_columns(headers, &base_visible, term_width, app.sort_field);
+    let sort_field = app.active_sort_field();
+    let display_cols = compute_display_columns(headers, &base_visible, term_width, sort_field);
 
     // Compute column boundaries, respecting auto-hidden columns
     let mut cursor: u16 = 0;
@@ -119,10 +116,26 @@ fn handle_header_click(app: &mut App, x: u16, term_width: u16) {
 
 fn handle_row_click(app: &mut App, y: u16, data_start_y: u16) {
     let row_offset = (y - data_start_y) as usize;
-    let target_index = app.scroll_offset + row_offset;
 
-    if target_index < app.filtered_processes.len() {
-        app.selected_index = target_index;
+    match app.active_tab {
+        ProcessTab::Main | ProcessTab::Io => {
+            let target_index = app.scroll_offset + row_offset;
+            if target_index < app.filtered_processes.len() {
+                app.selected_index = target_index;
+            }
+        }
+        ProcessTab::Net => {
+            let target_index = app.net_scroll_offset + row_offset;
+            if target_index < app.net_processes.len() {
+                app.net_selected_index = target_index;
+            }
+        }
+        ProcessTab::Gpu => {
+            let target_index = app.gpu_scroll_offset + row_offset;
+            if target_index < app.gpu_processes.len() {
+                app.gpu_selected_index = target_index;
+            }
+        }
     }
 }
 
@@ -195,7 +208,7 @@ fn execute_fkey_action(app: &mut App, action: FkeyAction) {
             }
         }
         FkeyAction::SortBy => {
-            app.sort_menu_index = app.sort_field.index();
+            app.sort_menu_index = app.active_sort_field().index();
             app.mode = AppMode::SortSelect;
         }
         FkeyAction::NiceMinus => {

src/mouse.rs

@@ -123,7 +123,7 @@ impl Collector {
             let conn_counts = netstat::count_connections_per_pid();
 
             // Build ProcessNetBandwidth by matching connection PIDs to process I/O rates
-            let mut net_procs: Vec<netstat::ProcessNetBandwidth> = conn_counts
+            let net_procs: Vec<netstat::ProcessNetBandwidth> = conn_counts
                 .into_iter()
                 .map(|(pid, count)| {
                     let (name, recv, send) = app.processes.iter()
@@ -143,23 +143,16 @@ impl Collector {
                 })
                 .collect();
 
-            // Sort: highest total bandwidth first, then by connection count
-            net_procs.sort_by(|a, b| {
-                let ar = a.recv_bytes_per_sec + a.send_bytes_per_sec;
-                let br = b.recv_bytes_per_sec + b.send_bytes_per_sec;
-                br.partial_cmp(&ar)
-                    .unwrap_or(std::cmp::Ordering::Equal)
-                    .then_with(|| b.connection_count.cmp(&a.connection_count))
-            });
-
+            // Sort by user's selected Net sort field
             app.net_processes = net_procs;
+            app.sort_net_processes();
         }
 
         // ── GPU per-process data (GPU tab) ──
         if matches!(app.active_tab, crate::app::ProcessTab::Gpu) {
             app.gpu_processes = self.gpu_collector.collect();
-            // Sort by GPU usage descending so busiest processes are at top
-            app.gpu_processes.sort_by(|a, b| b.gpu_usage.partial_cmp(&a.gpu_usage).unwrap_or(std::cmp::Ordering::Equal));
+            // Sort by user's selected GPU sort field
+            app.sort_gpu_processes();
 
             // Populate overall GPU stats for header meters
             let info = &self.gpu_collector.adapter_info;

src/system/collector.rs

@@ -96,7 +96,9 @@ pub fn draw_process_table(f: &mut Frame, app: &App, area: Rect) {
         ProcessTab::Main => app.visible_columns.clone(),
         _ => headers.iter().map(|(_, _, f, _)| *f).collect(),
     };
-    let display_cols = compute_display_columns(headers, &base_visible, area.width, app.sort_field);
+    let active_sort = app.active_sort_field();
+    let active_ascending = app.active_sort_ascending();
+    let display_cols = compute_display_columns(headers, &base_visible, area.width, active_sort);
 
     // Build header spans with sort indicator
     let mut header_spans: Vec<Span> = Vec::new();
@@ -106,12 +108,12 @@ pub fn draw_process_table(f: &mut Frame, app: &App, area: Rect) {
             continue;
         }
 
-        let is_sorted = *sort_field == app.sort_field;
+        let is_sorted = *sort_field == active_sort;
         let fixed_w = fixed_cols_width_for(headers, &display_cols);
         let w = if *width == 0 { (area.width as usize).saturating_sub(fixed_w) } else { *width as usize };
 
         let display = if is_sorted {
-            let arrow = if app.sort_ascending { "▲" } else { "▼" };
+            let arrow = if active_ascending { "▲" } else { "▼" };
             format!("{}{}", name, arrow)
         } else {
             name.to_string()