use crate::{
app::{App, Focus},
model::cpu::{CoreKind, PhysicalCore},
ui::{cpu_matrix_tile, cpu_status::core_type_status, layout},
};
use ratatui::{
prelude::*,
widgets::{Block, Borders, Paragraph, Wrap},
};
pub fn render(frame: &mut Frame<'_>, area: Rect, app: &App) {
let block = Block::default()
.title(format!(" CPU MATRIX · {} ", core_type_status(app)))
.borders(Borders::ALL);
let inner = block.inner(area);
frame.render_widget(block, area);
if app.cpu.cores.is_empty() {
frame.render_widget(Paragraph::new("Waiting for CPU topology…"), inner);
return;
}
let (dimension, rects) = layout::matrix_layout(inner, app.cpu.cores.len());
for (index, rect) in rects.iter().enumerate() {
cpu_matrix_tile::render(
frame,
*rect,
app,
index,
dimension,
app.focus == Focus::Cpu && app.selected_core == index,
);
}
}
pub fn render_micro(frame: &mut Frame<'_>, area: Rect, app: &App) {
let block = Block::default()
.title(" CPU MICRO HEATMAP ")
.borders(Borders::ALL);
let inner = block.inner(area);
let mut lines = Vec::new();
let mut line = Vec::new();
for (index, core) in app.cpu.cores.iter().enumerate() {
if index > 0 {
line.push(Span::raw(" "));
}
let util = core
.logical_cpus
.iter()
.filter_map(|id| {
app.cpu
.cpus
.iter()
.find(|cpu| cpu.logical_id == *id)
.and_then(|cpu| cpu.utilization)
})
.sum::<f64>()
/ core.logical_cpus.len().max(1) as f64;
line.push(Span::raw(format!(
"[{} {} {util:02.0}%]",
display_label(app, index),
micro_gauge(util)
)));
if line.len() > inner.width as usize / 4 {
lines.push(Line::from(std::mem::take(&mut line)));
}
}
if !line.is_empty() {
lines.push(Line::from(line));
}
frame.render_widget(
Paragraph::new(Text::from(lines))
.block(block)
.wrap(Wrap { trim: true }),
area,
);
}
fn micro_gauge(util: f64) -> String {
let filled = (util.clamp(0.0, 100.0) / 25.0).round() as usize;
format!("{}{}", "█".repeat(filled), "·".repeat(4 - filled))
}
pub fn display_label(app: &App, index: usize) -> String {
let Some(core) = app.cpu.cores.get(index) else {
return format!("C{index}");
};
let kind = core_kind(app, core);
let ordinal = app
.cpu
.cores
.iter()
.take(index)
.filter(|candidate| core_kind(app, candidate) == kind)
.count();
format!(
"{}{}",
match kind {
CoreKind::Performance => "P",
CoreKind::Efficiency | CoreKind::LowPowerEfficiency => "E",
_ => "C",
},
ordinal
)
}
fn core_kind(app: &App, core: &PhysicalCore) -> CoreKind {
core.logical_cpus
.iter()
.find_map(|id| {
app.cpu
.cpus
.iter()
.find(|cpu| cpu.logical_id == *id)
.map(|cpu| cpu.core_kind)
})
.unwrap_or(CoreKind::Unknown)
}