`fdeca24`

Add network and disk rate summaries to header bar

Header now shows: CPU: x% MEM: x% NET: x/s DISK: x/s up Xm
- Network rate is sum of rx+tx across all interfaces
- Disk rate is sum of read+write across all devices
- Rates displayed in compact format (K/s, M/s, G/s)

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: fdeca2437f9767d37dd5054afbd00a7f8189ae5c
Parents: 358d0c1
Tree: 8d2d88b

2 changed files

Status	File	+	-
M	`gartop/src/gui/app.rs`	12	1
M	`gartop/src/gui/header.rs`	48	3

gartop/src/gui/app.rsmodified

          let uptime = self.status.as_ref().map(|s| s.uptime_secs).unwrap_or(0);
          let cpu = self.cpu_stats.as_ref().map(|s| s.usage_percent as f32).unwrap_or(0.0);
          let mem = self.memory_stats.as_ref().map(|s| s.usage_percent as f32).unwrap_or(0.0);
 -        self.header.update(uptime, cpu, mem);
++
 +        // Sum network rates across all interfaces
 +        let net_rate: f64 = self.network_stats.iter()
 +            .map(|s| s.rx_rate + s.tx_rate)
 +            .sum();
++
 +        // Sum disk rates across all devices
 +        let disk_rate: f64 = self.disk_stats.iter()
 +            .map(|s| s.read_rate + s.write_rate)
 +            .sum();
++
 +        self.header.update(uptime, cpu, mem, net_rate, disk_rate);
+     }
      /// Render the entire UI.

gartop/src/gui/header.rsmodified

      uptime: String,
      cpu_usage: f32,
      memory_usage: f32,
 +    net_rate: f64,   // Combined rx+tx bytes/sec
 +    disk_rate: f64,  // Combined read+write bytes/sec
+ }
  impl HeaderBar {
              uptime: String::from("0s"),
              cpu_usage: 0.0,
              memory_usage: 0.0,
 +            net_rate: 0.0,
 +            disk_rate: 0.0,
+         }
+     }
      /// Update header with current stats.
 -    pub fn update(&mut self, uptime_secs: u64, cpu: f32, memory: f32) {
 +    pub fn update(&mut self, uptime_secs: u64, cpu: f32, memory: f32, net_rate: f64, disk_rate: f64) {
          self.uptime = format_uptime(uptime_secs);
          self.cpu_usage = cpu;
          self.memory_usage = memory;
 +        self.net_rate = net_rate;
 +        self.disk_rate = disk_rate;
+     }
      /// Render the header bar.
              ..stats_style.clone()
          };
 +        // Network indicator
 +        let net_text = format!("NET: {}", format_rate(self.net_rate));
 +        let net_style = TextStyle {
 +            color: theme.network_color,
 +            ..stats_style.clone()
 +        };
++
 +        // Disk indicator
 +        let disk_text = format!("DISK: {}", format_rate(self.disk_rate));
 +        let disk_style = TextStyle {
 +            color: theme.disk_color,
 +            ..stats_style.clone()
 +        };
++
          // Uptime
          let uptime_text = format!("up {}", self.uptime);
          // Position from right side
          let right_margin = 16.0;
 -        let spacing = 20.0;
 +        let spacing = 16.0;
          let y = self.bounds.y as f64 + (self.bounds.height as f64 * 0.4) + 6.0;
          let uptime_width = renderer.measure_text(&uptime_text, &stats_style)?.width as f64;
 +        let disk_width = renderer.measure_text(&disk_text, &disk_style)?.width as f64;
 +        let net_width = renderer.measure_text(&net_text, &net_style)?.width as f64;
          let mem_width = renderer.measure_text(&mem_text, &mem_style)?.width as f64;
          let cpu_width = renderer.measure_text(&cpu_text, &cpu_style)?.width as f64;
          let right_edge = (self.bounds.x + self.bounds.width as i32) as f64;
          let uptime_x = right_edge - right_margin - uptime_width;
 -        let mem_x = uptime_x - spacing - mem_width;
 +        let disk_x = uptime_x - spacing - disk_width;
 +        let net_x = disk_x - spacing - net_width;
 +        let mem_x = net_x - spacing - mem_width;
          let cpu_x = mem_x - spacing - cpu_width;
          renderer.text(&cpu_text, cpu_x, y, &cpu_style)?;
          renderer.text(&mem_text, mem_x, y, &mem_style)?;
 +        renderer.text(&net_text, net_x, y, &net_style)?;
 +        renderer.text(&disk_text, disk_x, y, &disk_style)?;
          renderer.text(&uptime_text, uptime_x, y, &stats_style)?;
          Ok(())
          format!("{}d {}h", secs / 86400, (secs % 86400) / 3600)
+     }
+ }
++
 +/// Format rate (bytes/second) to compact human-readable string.
 +fn format_rate(bytes_per_sec: f64) -> String {
 +    const KIB: f64 = 1024.0;
 +    const MIB: f64 = KIB * 1024.0;
 +    const GIB: f64 = MIB * 1024.0;
++
 +    if bytes_per_sec >= GIB {
 +        format!("{:.1}G/s", bytes_per_sec / GIB)
 +    } else if bytes_per_sec >= MIB {
 +        format!("{:.1}M/s", bytes_per_sec / MIB)
 +    } else if bytes_per_sec >= KIB {
 +        format!("{:.0}K/s", bytes_per_sec / KIB)
 +    } else if bytes_per_sec > 0.0 {
 +        format!("{:.0}B/s", bytes_per_sec)
 +    } else {
 +        "0".to_string()
 +    }
 +}