`358d0c1`

Eliminate tab switching lag and improve column spacing

- ProcessList now renders from reference instead of owning copies
- Tab switching sorts in-place without cloning 100 ProcessInfo structs
- Adjusted column spacing for network/disk tabs (Sock/Listen/Estab/User)
- Column positions: 240/310/380/450 for better readability

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

SHA: 358d0c11c858b5ec4fe2a7c57ecd6fa0718734e1
Parents: 9daf2bb
Tree: f0869c4

2 changed files

Status	File	+	-
M	`gartop/src/gui/app.rs`	6	7
M	`gartop/src/gui/process_list.rs`	26	28

gartop/src/gui/app.rsmodified


         }) {
             if resp.success {
                 self.processes = resp.data.and_then(|d| serde_json::from_value(d).ok()).unwrap_or_default();
-                self.process_list.set_processes(self.processes.clone());
+                self.process_list.set_process_count(self.processes.len());
                 self.process_list.set_sort(sort_field);
             }
         }

             }
         }
 
-        // Render process list
-        self.process_list.render(&self.renderer, &self.theme)?;
+        // Render process list (pass reference, no clone)
+        self.process_list.render(&self.renderer, &self.theme, &self.processes)?;
 
         Ok(())
     }

         self.header = HeaderBar::new(Rect::new(0, 0, width, HEADER_HEIGHT));
         self.tab_bar.set_bounds(Rect::new(0, HEADER_HEIGHT as i32, width, TAB_BAR_HEIGHT));
         self.process_list = Self::create_process_list(width, height);
-        self.process_list.set_processes(self.processes.clone());
+        self.process_list.set_process_count(self.processes.len());
 
         Ok(())
     }

         }
 
         // Check process list
-        if self.process_list.on_click(pos).is_some() {
+        if self.process_list.on_click(pos, &self.processes).is_some() {
             return true;
         }
 
         false
     }
 
-    /// Sort cached processes by the given field and update process list.
+    /// Sort processes in place by the given field (no cloning).
     fn sort_processes(&mut self, sort_field: SortField) {
         match sort_field {
             SortField::Cpu => self.processes.sort_by(|a, b| {

             SortField::Pid => self.processes.sort_by_key(|p| p.pid),
             SortField::Name => self.processes.sort_by(|a, b| a.name.cmp(&b.name)),
         }
-        self.process_list.set_processes(self.processes.clone());
         self.process_list.set_sort(sort_field);
     }
 

gartop/src/gui/process_list.rsmodified

  /// Header row height.
  const HEADER_HEIGHT: u32 = 24;
 -/// Process list component.
 +/// Process list component - renders process data without owning it.
  pub struct ProcessList {
      bounds: Rect,
 -    processes: Vec<ProcessInfo>,
      scroll_offset: usize,
      selected: Option<usize>,
      sort_field: SortField,
      visible_rows: usize,
 +    process_count: usize,
+ }
  impl ProcessList {
          let visible_rows = ((bounds.height.saturating_sub(HEADER_HEIGHT)) / ROW_HEIGHT) as usize;
          Self {
              bounds,
 -            processes: Vec::new(),
              scroll_offset: 0,
              selected: None,
              sort_field: SortField::Cpu,
              visible_rows,
 +            process_count: 0,
+         }
+     }
          self.visible_rows = ((bounds.height.saturating_sub(HEADER_HEIGHT)) / ROW_HEIGHT) as usize;
+     }
 -    /// Set processes to display.
 -    pub fn set_processes(&mut self, processes: Vec<ProcessInfo>) {
 -        self.processes = processes;
 +    /// Update process count (for scroll calculations).
 +    pub fn set_process_count(&mut self, count: usize) {
 +        self.process_count = count;
          // Clamp scroll offset
          if self.scroll_offset > self.max_scroll() {
              self.scroll_offset = self.max_scroll();
      /// Maximum scroll offset.
      fn max_scroll(&self) -> usize {
 -        self.processes.len().saturating_sub(self.visible_rows)
 +        self.process_count.saturating_sub(self.visible_rows)
+     }
      /// Handle scroll (delta is number of rows to scroll, positive = down).
+     }
      /// Handle click, returns selected process PID if any.
 -    pub fn on_click(&mut self, pos: Point) -> Option<i32> {
 +    pub fn on_click(&mut self, pos: Point, processes: &[ProcessInfo]) -> Option<i32> {
          if !self.bounds.contains_point(pos) {
              return None;
+         }
          let row = ((local_y - HEADER_HEIGHT as i32) / ROW_HEIGHT as i32) as usize;
          let process_idx = self.scroll_offset + row;
 -        if process_idx < self.processes.len() {
 +        if process_idx < processes.len() {
              self.selected = Some(process_idx);
 -            return Some(self.processes[process_idx].pid);
 +            return Some(processes[process_idx].pid);
+         }
          None
+     }
      /// Get selected process PID.
 -    pub fn selected_pid(&self) -> Option<i32> {
 -        self.selected.and_then(|idx| self.processes.get(idx).map(|p| p.pid))
 +    pub fn selected_pid(&self, processes: &[ProcessInfo]) -> Option<i32> {
 +        self.selected.and_then(|idx| processes.get(idx).map(|p| p.pid))
+     }
      /// Clear selection.
+     }
      /// Render the process list.
 -    pub fn render(&self, renderer: &Renderer, theme: &Theme) -> anyhow::Result<()> {
 +    pub fn render(&self, renderer: &Renderer, theme: &Theme, processes: &[ProcessInfo]) -> anyhow::Result<()> {
          // Background
          renderer.fill_rect(self.bounds, theme.panel_bg)?;
              ..text_style.clone()
          };
 -        // Column positions (PID can be 7 digits, ~56px at 11px monospace)
 +        // Column positions - adjusted for better spacing
          let x = self.bounds.x as f64;
          let col_pid = x + 8.0;
          let col_name = x + 80.0;
 -        let col_cpu = x + 230.0;
 -        let col_mem = x + 300.0;
 -        let col_user = x + 390.0;
 +        let col_cpu = x + 240.0;   // CPU%/Read/Sock
 +        let col_mem = x + 310.0;   // Mem%/Write/Listen
 +        let col_extra = x + 380.0; // Estab (network only)
 +        let col_user = x + 450.0;  // User
++
 +        // Show different columns based on sort field
 +        let is_disk_sort = matches!(self.sort_field, SortField::DiskRead | SortField::DiskWrite | SortField::DiskTotal);
 +        let is_net_sort = matches!(self.sort_field, SortField::NetConnections | SortField::NetTcp | SortField::NetBandwidth);
          // Header - position text near top (Pango uses top-left positioning)
          let header_y = self.bounds.y as f64 + 4.0;
              ..header_style.clone()
          };
 -        // Show different columns based on sort field
 -        let is_disk_sort = matches!(self.sort_field, SortField::DiskRead | SortField::DiskWrite | SortField::DiskTotal);
 -        let is_net_sort = matches!(self.sort_field, SortField::NetConnections | SortField::NetTcp | SortField::NetBandwidth);
+-
 -        // Extra column position for network mode
 -        let col_extra = x + 350.0;
+-
          if is_disk_sort {
              renderer.text("Read/s", col_cpu, header_y, &sort_style)?;
              renderer.text("Write/s", col_mem, header_y, &sort_style)?;
          // Process rows
          let start_y = self.bounds.y + HEADER_HEIGHT as i32;
 -        for (i, process) in self.processes.iter()
 +        for (i, process) in processes.iter()
              .skip(self.scroll_offset)
              .take(self.visible_rows)
              .enumerate()
+         }
          // Scroll indicator if needed
 -        if self.processes.len() > self.visible_rows {
 +        if processes.len() > self.visible_rows {
              let scroll_info = format!(
                  "{}-{} of {}",
                  self.scroll_offset + 1,
 -                (self.scroll_offset + self.visible_rows).min(self.processes.len()),
 -                self.processes.len()
 +                (self.scroll_offset + self.visible_rows).min(processes.len()),
 +                processes.len()
              );
              let info_style = TextStyle {
                  font_size: 9.0,

`@@ -254,7 +254,7 @@` impl App {
254	254	}) {
255	255	if resp.success {
256	256	self.processes = resp.data.and_then(\|d\| serde_json::from_value(d).ok()).unwrap_or_default();
257		- self.process_list.set_processes(self.processes.clone());
	257	+ self.process_list.set_process_count(self.processes.len());
258	258	self.process_list.set_sort(sort_field);
259	259	}
260	260	}
`@@ -572,8 +572,8 @@` impl App {
572	572	}
573	573	}
574	574
575		- // Render process list
576		- self.process_list.render(&self.renderer, &self.theme)?;
	575	+ // Render process list (pass reference, no clone)
	576	+ self.process_list.render(&self.renderer, &self.theme, &self.processes)?;
577	577
578	578	Ok(())
579	579	}
`@@ -620,7 +620,7 @@` impl App {
620	620	self.header = HeaderBar::new(Rect::new(0, 0, width, HEADER_HEIGHT));
621	621	self.tab_bar.set_bounds(Rect::new(0, HEADER_HEIGHT as i32, width, TAB_BAR_HEIGHT));
622	622	self.process_list = Self::create_process_list(width, height);
623		- self.process_list.set_processes(self.processes.clone());
	623	+ self.process_list.set_process_count(self.processes.len());
624	624
625	625	Ok(())
626	626	}
`@@ -644,14 +644,14 @@` impl App {
644	644	}
645	645
646	646	// Check process list
647		- if self.process_list.on_click(pos).is_some() {
	647	+ if self.process_list.on_click(pos, &self.processes).is_some() {
648	648	return true;
649	649	}
650	650
651	651	false
652	652	}
653	653
654		- /// Sort cached processes by the given field and update process list.
	654	+ /// Sort processes in place by the given field (no cloning).
655	655	fn sort_processes(&mut self, sort_field: SortField) {
656	656	match sort_field {
657	657	SortField::Cpu => self.processes.sort_by(\|a, b\| {
`@@ -685,7 +685,6 @@` impl App {
685	685	SortField::Pid => self.processes.sort_by_key(\|p\| p.pid),
686	686	SortField::Name => self.processes.sort_by(\|a, b\| a.name.cmp(&b.name)),
687	687	}
688		- self.process_list.set_processes(self.processes.clone());
689	688	self.process_list.set_sort(sort_field);
690	689	}
691	690