`ae028c0`

Add per-process CPU/memory history sparklines in detail view

Authored by

espadonne 3 months ago

SHA: ae028c0e3e5383a84841b609500901708c31e89b
Parents: 5c84a22
Tree: 3a25ba6

1 changed file

Status	File	+	-
M	`gartop/src/gui/app.rs`	122	0

gartop/src/gui/app.rsmodified

  use gartk_render::{Renderer, TextStyle};
  use gartk_x11::{Connection, EventLoop, EventLoopConfig, Window, WindowConfig};
  use gartop_ipc::{Command, CpuStats, DiskStats, MemoryStats, NetworkStats, ProcessInfo, Response, SortField, StatusInfo, TempStats};
++use std::collections::HashMap;
  use std::io::{BufRead, BufReader, Write};
  use std::os::unix::net::UnixStream;
  use std::time::Instant;
  /// Vertical gap between sections.
  const SECTION_GAP: u32 = 12;
++/// Max history points per process
++const PROCESS_HISTORY_LEN: usize = 60;
++
++/// Per-process CPU/memory history for sparkline graphs.
++struct ProcessHistory {
++    cpu: Vec<f64>,
++    memory: Vec<f64>,
++}
++
++impl ProcessHistory {
++    fn new() -> Self {
++        Self {
++            cpu: Vec::with_capacity(PROCESS_HISTORY_LEN),
++            memory: Vec::with_capacity(PROCESS_HISTORY_LEN),
++        }
++    }
++
++    fn push(&mut self, cpu: f64, memory: f64) {
++        if self.cpu.len() >= PROCESS_HISTORY_LEN {
++            self.cpu.remove(0);
++            self.memory.remove(0);
++        }
++        self.cpu.push(cpu);
++        self.memory.push(memory);
++    }
++}
++
  /// GUI application.
  pub struct App {
      window: Window,
      network_history: Vec<Vec<NetworkStats>>,
      disk_history: Vec<Vec<DiskStats>>,
      processes: Vec<ProcessInfo>,
++    /// Per-process CPU/memory history for sparkline graphs
++    process_history: HashMap<i32, ProcessHistory>,
+ }
  impl App {
              network_history: Vec::new(),
              disk_history: Vec::new(),
              processes: Vec::new(),
++            process_history: HashMap::new(),
          })
+     }
                      // Sync selection - tracks process by PID across list reorders
                      self.process_list.sync_selection(&self.processes);
                      self.process_list.set_sort(sort_field);
++
++                    // Record per-process history for sparklines
++                    for proc in &self.processes {
++                        self.process_history
++                            .entry(proc.pid)
++                            .or_insert_with(ProcessHistory::new)
++                            .push(proc.cpu_percent, proc.memory_percent);
++                    }
++                    // Clean up history for dead processes
++                    let active_pids: std::collections::HashSet<i32> =
++                        self.processes.iter().map(|p| p.pid).collect();
++                    self.process_history.retain(|pid, _| active_pids.contains(pid));
+                 }
+             }
+         }
          };
          self.renderer.text("[K] Kill (SIGTERM)   [X] Kill (SIGKILL)", x, footer_y, &action_style)?;
++        // History sparklines (if we have history for this process)
++        if let Some(history) = self.process_history.get(&process.pid) {
++            if history.cpu.len() >= 2 {
++                let spark_y = footer_y - 90.0;
++                let spark_height = 50.0;
++                let spark_width = ((self.width - margin * 2) as f64 - 40.0) / 2.0 - 10.0;
++
++                // CPU sparkline
++                self.renderer.text("CPU History:", x, spark_y - 14.0, &label_style)?;
++                self.render_sparkline(
++                    x, spark_y, spark_width, spark_height,
++                    &history.cpu, self.theme.cpu_color,
++                )?;
++
++                // Memory sparkline
++                let mem_x = x + spark_width + 20.0;
++                self.renderer.text("Memory History:", mem_x, spark_y - 14.0, &label_style)?;
++                self.render_sparkline(
++                    mem_x, spark_y, spark_width, spark_height,
++                    &history.memory, self.theme.memory_color,
++                )?;
++            }
++        }
++
++        Ok(())
++    }
++
++    /// Render a sparkline graph (small inline chart).
++    fn render_sparkline(&self, x: f64, y: f64, w: f64, h: f64, values: &[f64], color: gartk_core::Color) -> Result<()> {
++        if values.is_empty() || w <= 0.0 || h <= 0.0 {
++            return Ok(());
++        }
++
++        let ctx = self.renderer.context()?;
++
++        // Background
++        ctx.set_source_rgba(
++            self.theme.graph_bg.r,
++            self.theme.graph_bg.g,
++            self.theme.graph_bg.b,
++            self.theme.graph_bg.a,
++        );
++        ctx.rectangle(x, y, w, h);
++        let _ = ctx.fill();
++
++        // Find max for scaling (at least 1% to avoid division by zero)
++        let max_val = values.iter().cloned().fold(1.0_f64, f64::max);
++        let scale = h / max_val.max(1.0);
++
++        let step = w / (values.len().saturating_sub(1).max(1)) as f64;
++
++        // Draw filled area
++        ctx.set_source_rgba(color.r, color.g, color.b, 0.3);
++        ctx.move_to(x, y + h);
++        for (i, &val) in values.iter().enumerate() {
++            let px = x + i as f64 * step;
++            let py = y + h - (val * scale);
++            ctx.line_to(px, py);
++        }
++        ctx.line_to(x + (values.len() - 1) as f64 * step, y + h);
++        ctx.close_path();
++        let _ = ctx.fill();
++
++        // Draw line
++        ctx.set_source_rgba(color.r, color.g, color.b, 1.0);
++        ctx.set_line_width(1.5);
++        let mut first = true;
++        for (i, &val) in values.iter().enumerate() {
++            let px = x + i as f64 * step;
++            let py = y + h - (val * scale);
++            if first {
++                ctx.move_to(px, py);
++                first = false;
++            } else {
++                ctx.line_to(px, py);
++            }
++        }
++        let _ = ctx.stroke();
++
          Ok(())
+     }