Windows shell replacement in Rust: taskbar, file manager, NTFS search, task manager, disk cleaner. One installer exe.
Rust
//! Модель интерфейса: страницы, колонки, строки таблиц и их построение из данных.
use crate::{data::*, suspect, ui::*};
use std::collections::{HashMap, HashSet};
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum Page {
Processes,
Performance,
History,
Startup,
Users,
Details,
Services,
Insights,
Rules,
Settings,
Boost,
}
/// Пункты боковой панели: страница, символ значка, подпись.
pub static NAV: std::sync::LazyLock<[(Page, char, &'static str); 11]> = std::sync::LazyLock::new(|| [
(Page::Processes, '\u{E9D9}', t!("Процессы", "Processes")),
(Page::Performance, '\u{E9D2}', t!("Производительность", "Performance")),
(Page::History, '\u{E81C}', t!("Журнал приложений", "App history")),
(Page::Startup, '\u{EC4A}', t!("Автозагрузка", "Startup")),
(Page::Users, '\u{E77B}', t!("Пользователи", "Users")),
(Page::Details, '\u{EA37}', t!("Подробности", "Details")),
(Page::Services, '\u{E9F5}', t!("Службы", "Services")),
(Page::Insights, '\u{E946}', t!("Что тормозит", "What's slow")),
(Page::Rules, '\u{E7BA}', t!("Правила", "Rules")),
(Page::Settings, '\u{E713}', t!("Параметры", "Settings")),
// последней: настройки хранят номер открытой страницы, вставка в середину сдвинула бы его
(Page::Boost, '\u{E945}', t!("Ускорение", "Speed")),
]);
pub fn page_title(p: Page) -> &'static str {
NAV.iter().find(|n| n.0 == p).map_or("", |n| n.2)
}
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Align {
Left,
Right,
}
#[derive(Clone, Copy)]
pub struct Col {
pub title: &'static str,
pub w: f64, // логические px; 0 — всё оставшееся место
pub align: Align,
pub metric: Option<Metric>, // колонка с агрегатом в шапке и тепловой подсветкой
}
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Metric {
Cpu,
Mem,
Disk,
Net,
Gpu,
}
const fn col(title: &'static str, w: f64, align: Align) -> Col {
Col { title, w, align, metric: None }
}
const fn mcol(title: &'static str, m: Metric) -> Col {
Col { title, w: 84.0, align: Align::Right, metric: Some(m) }
}
pub fn columns(p: Page) -> Vec<Col> {
use Align::*;
use Metric::*;
match p {
Page::Processes => vec![
col(t!("Имя", "Name"), 270.0, Left),
col(t!("Состояние", "Status"), 112.0, Left),
mcol(t!("ЦП", "CPU"), Cpu),
mcol(t!("Память", "Memory"), Mem),
mcol(t!("Диск", "Disk"), Disk),
mcol(t!("Сеть", "Network"), Net),
mcol("GPU", Gpu),
col(t!("Подозрительное", "Suspicious"), 140.0, Left),
],
Page::Users => vec![
col(t!("Пользователь", "User"), 270.0, Left),
col(t!("Процессов", "Processes"), 112.0, Right),
mcol(t!("ЦП", "CPU"), Cpu),
mcol(t!("Память", "Memory"), Mem),
mcol(t!("Диск", "Disk"), Disk),
mcol(t!("Сеть", "Network"), Net),
mcol("GPU", Gpu),
],
Page::Details => vec![col(t!("Имя", "Name"), 220.0, Left), col("PID", 70.0, Right), col(t!("Состояние", "Status"), 100.0, Left), col(t!("ЦП", "CPU"), 70.0, Right), col(t!("Память", "Memory"), 110.0, Right), col(t!("Диск", "Disk"), 100.0, Right), col(t!("Командная строка", "Command line"), 0.0, Left)],
Page::Services => vec![col(t!("Имя", "Name"), 200.0, Left), col("PID", 70.0, Right), col(t!("Описание", "Description"), 360.0, Left), col(t!("Состояние", "Status"), 110.0, Left)],
Page::Startup => vec![col(t!("Имя", "Name"), 240.0, Left), col(t!("Издатель", "Publisher"), 180.0, Left), col(t!("Состояние", "Status"), 100.0, Left), col(t!("Замедляет загрузку", "Slows boot by"), 150.0, Right), col(t!("Команда", "Command"), 0.0, Left)],
Page::History => vec![col(t!("Время", "Time"), 150.0, Left), col(t!("ЦП %", "CPU %"), 80.0, Right), col(t!("Память %", "Memory %"), 90.0, Right), col(t!("Ввод-вывод КБ/с", "I/O KB/s"), 130.0, Right), col(t!("Сеть КБ/с", "Network KB/s"), 110.0, Right), col(t!("Основной потребитель", "Top consumer"), 0.0, Left)],
Page::Boost => vec![col(t!("Что", "What"), 320.0, Left), col(t!("Состояние", "Status"), 220.0, Left), col(t!("Что делает", "What it does"), 0.0, Left)],
Page::Rules => vec![col(t!("Процесс", "Process"), 220.0, Left), col(t!("Условие", "Condition"), 280.0, Left), col(t!("Действие", "Action"), 200.0, Left), col(t!("Сработало, раз", "Times triggered"), 130.0, Right)],
_ => vec![],
}
}
/// Сортировка по умолчанию: (индекс колонки, по убыванию).
pub fn default_sort(p: Page) -> (usize, bool) {
match p {
Page::Processes | Page::Users => (2, true), // ЦП
Page::Details => (3, true),
Page::History => (0, true),
_ => (0, false),
}
}
#[derive(Clone, Default)]
pub struct Row {
pub key: String,
pub depth: u8,
pub expandable: bool,
pub expanded: bool,
pub icon_path: Option<String>,
pub cells: Vec<String>,
pub heat: Vec<Option<(f64, f64)>>, // (значение, шкала) для колонок-метрик
pub sortv: Vec<f64>, // числовые ключи сортировки; NaN — сортировать как текст
pub sev: u8,
pub tip: String,
pub pids: Vec<u32>,
pub aux: String, // служебное: имя службы, ключ автозагрузки и т.п.
}
pub fn dec(v: f64, digits: usize) -> String {
let s = format!("{:.*}", digits, v);
if en!() { s } else { s.replace('.', ",") }
}
pub fn fmt_cpu(v: f32) -> String {
if v < 0.05 { "0%".into() } else { format!("{}%", dec(v as f64, 1)) }
}
pub fn fmt_mem_ru(b: u64) -> String {
let mb = b as f64 / 1_048_576.0;
if mb >= 1000.0 { tf!("{} МБ", "{} MB", { let g = group_thousands(mb as u64); if en!() { g } else { g.replace(',', " ") } }) } else if mb >= 100.0 { tf!("{} МБ", "{} MB", dec(mb, 0)) } else { tf!("{} МБ", "{} MB", dec(mb, 1)) }
}
pub fn fmt_disk_ru(bps: f64) -> String {
let mb = bps / 1_048_576.0;
if mb < 0.05 { t!("0 МБ/с", "0 MB/s").into() } else { tf!("{} МБ/с", "{} MB/s", dec(mb, 1)) }
}
pub fn fmt_net_ru(bps: f64, known: bool) -> String {
if !known {
return "—".into();
}
let mbit = bps * 8.0 / 1e6;
if mbit < 0.05 { t!("0 Мбит/с", "0 Mbps").into() } else { tf!("{} Мбит/с", "{} Mbps", dec(mbit, 1)) }
}
/// Описание/имя для отображения: описание файла, если известно, иначе имя без «.exe».
fn friendly(d: &Data, p: &Proc) -> String {
if let Some(r) = p.exe.as_deref().and_then(|e| d.res.get(e))
&& !r.desc.is_empty() {
return r.desc;
}
p.name.strip_suffix(".exe").or_else(|| p.name.strip_suffix(".EXE")).unwrap_or(&p.name).to_string()
}
fn svc_display(d: &Data, pid: u32) -> Option<String> {
let name = d.svc_pids.get(&pid)?.first()?.clone();
Some(d.svcs.iter().find(|s| s.name == name).map_or(name, |s| s.display.clone()))
}
fn child_name(d: &Data, p: &Proc) -> String {
if p.name.eq_ignore_ascii_case("svchost.exe")
&& let Some(s) = svc_display(d, p.pid) {
return tf!("Узел службы: {s}", "Service host: {s}");
}
if let Some(t) = &p.title {
return t.clone();
}
friendly(d, p)
}
fn tip_for(procs: &[&Proc], group: bool) -> String {
let mut by_text: Vec<(u8, String, Vec<u32>)> = vec![];
for p in procs {
for r in &p.reasons {
match by_text.iter_mut().find(|e| e.1 == r.text) {
Some(e) => e.2.push(p.pid),
None => by_text.push((r.sev, r.text.clone(), vec![p.pid])),
}
}
}
if by_text.is_empty() {
return String::new();
}
by_text.sort_by_key(|e| std::cmp::Reverse(e.0));
let total = by_text.len();
let mut s = String::from(t!("Почему помечено:", "Why flagged:"));
for (sev, t, pids) in by_text.into_iter().take(6) {
let who = if pids.len() > 1 { tf!(" (процессов: {})", " (processes: {})", pids.len()) } else if group && procs.len() > 1 { format!(" [PID {}]", pids[0]) } else { String::new() };
s += &format!("\n{} — {t}{who}", suspect::sev_word(sev));
}
if total > 6 {
s += &tf!("\n… и ещё причин: {}", "\n… and {} more reasons", total - 6);
}
s
}
fn proc_row(d: &Data, key: String, depth: u8, name: String, members: &[&Proc], expandable: bool, expanded: bool) -> Row {
let cpu: f32 = members.iter().map(|p| p.cpu).sum();
let mem: u64 = members.iter().map(|p| p.mem).sum();
let disk: f64 = members.iter().map(|p| p.disk).sum();
let net: f64 = members.iter().map(|p| p.net).sum();
let gpu: f32 = members.iter().map(|p| p.gpu).fold(0.0, f32::max);
let sev = members.iter().flat_map(|p| p.reasons.iter()).map(|r| r.sev).max().unwrap_or(0);
let status = if members.iter().all(|p| d.suspended.contains(&p.pid)) {
t!("Приостановлен", "Suspended")
} else if members.iter().all(|p| d.efficiency.contains(&p.pid)) {
t!("Эффективность", "Efficiency")
} else {
""
};
let etw = d.etw.is_some();
Row {
key,
depth,
expandable,
expanded,
icon_path: members.iter().find_map(|p| p.exe.clone()),
cells: vec![name, status.into(), fmt_cpu(cpu), fmt_mem_ru(mem), fmt_disk_ru(disk), fmt_net_ru(net, etw), if gpu >= 0.05 { format!("{}%", dec(gpu as f64, 0)) } else { "0%".into() }, suspect::label(sev).to_string()],
heat: vec![None, None, Some((cpu as f64, 40.0)), Some((mem as f64, 1.5e9)), Some((disk, 5e6)), Some((net, 5e6)), Some((gpu as f64, 40.0)), None],
sortv: vec![f64::NAN, f64::NAN, cpu as f64, mem as f64, disk, net, gpu as f64, sev as f64],
sev,
tip: tip_for(members, members.len() > 1),
pids: members.iter().map(|p| p.pid).collect(),
aux: String::new(),
}
}
pub struct BuildCtx<'a> {
pub page: Page,
pub search: &'a str,
pub expanded: &'a HashSet<String>,
pub sort: (usize, bool),
}
fn matches(d: &Data, p: &Proc, q: &str) -> bool {
p.name.to_lowercase().contains(q)
|| p.pid.to_string() == q
|| friendly(d, p).to_lowercase().contains(q)
|| p.exe.as_deref().and_then(|e| d.res.get(e)).is_some_and(|r| r.company.to_lowercase().contains(q))
|| p.title.as_deref().is_some_and(|t| t.to_lowercase().contains(q))
}
pub fn build_rows(d: &Data, c: &BuildCtx) -> Vec<Row> {
let q = c.search.trim().to_lowercase();
let mut rows: Vec<Row> = match c.page {
Page::Processes => {
let mut groups: HashMap<String, Vec<&Proc>> = HashMap::new();
for p in &d.procs {
groups.entry(group_key(&p.name)).or_default().push(p);
}
let mut out: Vec<(Row, Vec<Row>)> = vec![];
for (key, mut members) in groups {
if !q.is_empty() && !members.iter().any(|p| matches(d, p, &q) || suspect::label(p.reasons.iter().map(|r| r.sev).max().unwrap_or(0)).to_lowercase().contains(&q)) {
continue;
}
members.sort_by(|a, b| b.cpu.total_cmp(&a.cpu));
let multi = members.len() > 1;
let base = if members[0].name.eq_ignore_ascii_case("svchost.exe") { t!("Узел службы", "Service host").to_string() } else { friendly(d, members[0]) };
let name = if multi { format!("{base} ({})", members.len()) } else if members[0].name.eq_ignore_ascii_case("svchost.exe") { child_name(d, members[0]) } else { members[0].title.clone().filter(|_| false).unwrap_or(base) };
let expanded = multi && c.expanded.contains(&key);
let head = proc_row(d, key.clone(), 0, name, &members, multi, expanded);
let kids: Vec<Row> = if expanded {
members.iter().map(|p| proc_row(d, format!("{key}#{}", p.pid), 1, child_name(d, p), &[p], false, false)).collect()
} else {
vec![]
};
out.push((head, kids));
}
sort_pairs(&mut out, c.sort);
out.into_iter().flat_map(|(h, k)| std::iter::once(h).chain(k)).collect()
}
Page::Users => {
let mut groups: HashMap<String, Vec<&Proc>> = HashMap::new();
for p in &d.procs {
groups.entry(p.user.clone()).or_default().push(p);
}
let mut out: Vec<(Row, Vec<Row>)> = vec![];
for (user, mut members) in groups {
if !q.is_empty() && !user.to_lowercase().contains(&q) && !members.iter().any(|p| matches(d, p, &q)) {
continue;
}
members.sort_by(|a, b| b.cpu.total_cmp(&a.cpu));
let key = format!("user:{user}");
let expanded = c.expanded.contains(&key);
let mut head = proc_row(d, key.clone(), 0, user.clone(), &members, true, expanded);
head.cells[1] = members.len().to_string();
head.sortv[1] = members.len() as f64;
head.icon_path = None;
head.tip = String::new();
let kids: Vec<Row> = if expanded { members.iter().map(|p| proc_row(d, format!("{key}#{}", p.pid), 1, child_name(d, p), &[p], false, false)).collect() } else { vec![] };
out.push((head, kids));
}
sort_pairs(&mut out, c.sort);
out.into_iter().flat_map(|(h, k)| std::iter::once(h).chain(k)).collect()
}
Page::Details => d
.procs
.iter()
.filter(|p| q.is_empty() || matches(d, p, &q))
.map(|p| Row {
key: p.pid.to_string(),
icon_path: p.exe.clone(),
cells: vec![p.name.clone(), p.pid.to_string(), (if d.suspended.contains(&p.pid) { t!("Приостановлен", "Suspended") } else { t!("Выполняется", "Running") }).into(), fmt_cpu(p.cpu), fmt_mem_ru(p.mem), fmt_disk_ru(p.disk), process_cmd(d, p.pid)],
sortv: vec![f64::NAN, p.pid as f64, f64::NAN, p.cpu as f64, p.mem as f64, p.disk, f64::NAN],
pids: vec![p.pid],
heat: vec![None; 7],
..Default::default()
})
.collect(),
Page::Services => d
.svcs
.iter()
.filter(|s| q.is_empty() || s.name.to_lowercase().contains(&q) || s.display.to_lowercase().contains(&q))
.map(|s| Row {
key: s.name.clone(),
cells: vec![s.name.clone(), if s.pid != 0 { s.pid.to_string() } else { String::new() }, s.display.clone(), (if s.running { t!("Выполняется", "Running") } else { t!("Остановлена", "Stopped") }).into()],
sortv: vec![f64::NAN, s.pid as f64, f64::NAN, f64::NAN],
pids: vec![s.pid],
heat: vec![None; 4],
aux: s.name.clone(),
..Default::default()
})
.collect(),
Page::Startup => d
.startup
.iter()
.filter(|s| q.is_empty() || s.name.to_lowercase().contains(&q) || s.command.to_lowercase().contains(&q))
.map(|s| {
let exe = exe_from_command(&s.command);
let company = exe.as_deref().and_then(|e| d.res.get(e)).map(|r| r.company).unwrap_or_default();
// без администратора журнал загрузки не читается: «нет данных», а не «не замедляет»
let impact = if d.is_admin { crate::startup::boot_impact(s, crate::startup::boot_log()) } else { None };
let impact_txt = match impact {
Some(ms) => tf!("+{} с", "+{} s", dec(ms as f64 / 1000.0, 1)),
None if d.is_admin => "—".into(),
None => t!("нужен администратор", "administrator needed").into(),
};
Row {
key: s.key(),
icon_path: exe,
cells: vec![s.name.clone(), company, (if s.enabled { t!("Включено", "Enabled") } else { t!("Отключено", "Disabled") }).into(), impact_txt, s.command.clone()],
sortv: vec![f64::NAN, f64::NAN, f64::NAN, impact.unwrap_or(0) as f64, f64::NAN],
heat: vec![None; 5],
tip: tf!("Источник: {}.{}", "Source: {}.{}", s.source_label(), if s.needs_admin() && !d.is_admin { t!(" Для изменения нужны права администратора.", " Administrator rights are needed to change it.") } else { "" }),
..Default::default()
}
})
.collect(),
Page::Boost => crate::boost::ALL
.iter()
.map(|&id| {
use crate::boost::State;
let st = crate::boost::state(id, d.is_admin);
let text = match &st {
State::On => t!("Включено", "On").to_string(),
State::Off => t!("Выключено", "Off").to_string(),
State::Busy => t!("Выполняется…", "Running…").to_string(),
State::Info(s) => s.clone(),
State::Unavailable(s) => tf!("Недоступно: {s}", "Unavailable: {s}"),
};
Row {
key: id.key().into(),
cells: vec![id.title().into(), text, id.desc().into()],
sortv: vec![f64::NAN; 3],
heat: vec![None; 3],
tip: id.desc().into(),
..Default::default()
}
})
.collect(),
Page::History => d
.hist
.iter()
.filter(|h| q.is_empty() || h.iter().any(|c| c.to_lowercase().contains(&q)))
.map(|h| Row {
key: h[0].clone(),
cells: h.clone(),
sortv: vec![f64::NAN, h[1].parse().unwrap_or(0.0), h[2].parse().unwrap_or(0.0), h[3].parse().unwrap_or(0.0), h[4].parse().unwrap_or(0.0), f64::NAN],
heat: vec![None; 6],
..Default::default()
})
.collect(),
Page::Rules => d
.rules
.iter()
.enumerate()
.map(|(i, r)| Row {
key: i.to_string(),
cells: vec![
if r.proc == "*" { t!("любой", "any").into() } else { r.proc.clone() },
tf!("ЦП > {:.0}% дольше {} с", "CPU > {:.0}% for over {} s", r.cpu, r.secs),
(if r.act == crate::store::RuleAct::Lower { t!("Понизить приоритет", "Lower priority") } else { t!("Уведомить", "Notify") }).into(),
r.hits.to_string(),
],
sortv: vec![f64::NAN, f64::NAN, f64::NAN, r.hits as f64],
heat: vec![None; 4],
..Default::default()
})
.collect(),
_ => vec![],
};
if !matches!(c.page, Page::Processes | Page::Users | Page::Boost) {
let (ci, desc) = c.sort;
rows.sort_by(|a, b| {
let o = cmp_cells(a, b, ci);
if desc { o.reverse() } else { o }
});
}
rows
}
fn cmp_cells(a: &Row, b: &Row, ci: usize) -> std::cmp::Ordering {
let (x, y) = (a.sortv.get(ci).copied().unwrap_or(f64::NAN), b.sortv.get(ci).copied().unwrap_or(f64::NAN));
if x.is_nan() || y.is_nan() {
a.cells.get(ci).map(|s| s.to_lowercase()).cmp(&b.cells.get(ci).map(|s| s.to_lowercase()))
} else {
x.total_cmp(&y)
}
}
fn sort_pairs(v: &mut [(Row, Vec<Row>)], sort: (usize, bool)) {
let (ci, desc) = sort;
let ord = |a: &Row, b: &Row| {
let o = cmp_cells(a, b, ci);
if desc { o.reverse() } else { o }
};
v.sort_by(|a, b| ord(&a.0, &b.0));
for (_, kids) in v.iter_mut() {
kids.sort_by(|a, b| ord(a, b));
}
}
/// Путь к исполняемому файлу из команды автозагрузки (в кавычках или до первого пробела после «.exe»).
pub fn exe_from_command(cmd: &str) -> Option<String> {
let c = cmd.trim();
let path = if let Some(rest) = c.strip_prefix('"') {
rest.split('"').next()?.to_string()
} else {
let l = c.to_lowercase();
let end = l.find(".exe").map(|i| i + 4).unwrap_or(c.len());
c[..end].to_string()
};
let path = path.replace("%windir%", &std::env::var("WINDIR").unwrap_or_default());
(!path.is_empty() && path.contains('\\')).then_some(path)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn exe_extraction() {
assert_eq!(exe_from_command(r#""C:\Program Files\X\x.exe" --silent"#).as_deref(), Some(r"C:\Program Files\X\x.exe"));
assert_eq!(exe_from_command(r"C:\Tools\a.exe -k b").as_deref(), Some(r"C:\Tools\a.exe"));
assert_eq!(exe_from_command("cmd /c foo"), None);
}
#[test]
fn number_formats_use_comma() {
assert_eq!(fmt_cpu(2.04), "2,0%");
assert_eq!(fmt_cpu(0.01), "0%");
assert_eq!(fmt_mem_ru(3_746_000_000), "3 572 МБ");
assert_eq!(fmt_mem_ru(73 * 1_048_576 + 100_000), "73,1 МБ");
assert_eq!(fmt_disk_ru(0.0), "0 МБ/с");
assert_eq!(fmt_net_ru(1.0, false), "—");
}
#[test]
fn every_page_with_table_has_valid_default_sort() {
for p in [Page::Processes, Page::Users, Page::Details, Page::Services, Page::Startup, Page::History, Page::Rules] {
assert!(default_sort(p).0 < columns(p).len(), "{p:?}");
}
}
#[test]
fn users_page_groups_processes_by_account() {
let mut d = Data::new(crate::store::Settings::default());
d.refresh();
let me = d.procs.iter().find(|p| p.pid == std::process::id()).expect("свой процесс").user.clone();
assert!(!me.is_empty() && me != "СИСТЕМА", "свой токен должен читаться: {me}");
let mut exp = HashSet::new();
let rows = build_rows(&d, &BuildCtx { page: Page::Users, search: "", expanded: &exp, sort: default_sort(Page::Users) });
assert!(rows.iter().all(|r| r.depth == 0 && r.expandable));
let mine = rows.iter().find(|r| r.cells[0] == me).expect("строка текущего пользователя");
assert!(mine.pids.contains(&std::process::id()));
exp.insert(mine.key.clone());
let rows2 = build_rows(&d, &BuildCtx { page: Page::Users, search: "", expanded: &exp, sort: default_sort(Page::Users) });
assert!(rows2.iter().filter(|r| r.depth == 1).count() == mine.pids.len());
}
#[test]
fn processes_rows_group_and_expand() {
let mut d = Data::new(crate::store::Settings::default());
d.refresh();
let exp: HashSet<String> = HashSet::new();
let ctx = BuildCtx { page: Page::Processes, search: "", expanded: &exp, sort: default_sort(Page::Processes) };
let rows = build_rows(&d, &ctx);
assert!(!rows.is_empty() && rows.iter().all(|r| r.depth == 0));
let multi = rows.iter().find(|r| r.expandable).expect("есть группа из нескольких процессов");
let mut exp2 = HashSet::new();
exp2.insert(multi.key.clone());
let ctx2 = BuildCtx { page: Page::Processes, search: "", expanded: &exp2, sort: default_sort(Page::Processes) };
let rows2 = build_rows(&d, &ctx2);
assert!(rows2.len() > rows.len());
assert!(rows2.iter().any(|r| r.depth == 1));
// поиск по PID находит нужную группу
let pid = std::process::id().to_string();
let ctx3 = BuildCtx { page: Page::Processes, search: &pid, expanded: &exp, sort: default_sort(Page::Processes) };
assert!(build_rows(&d, &ctx3).iter().any(|r| r.pids.contains(&std::process::id())));
}
}