sys-resource-manager 0.1.0

A system resource manager displaying system info.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use sysinfo::{System, Disks};
use std::time::{Duration, Instant};
use eframe::egui;

// Import your panel modules from panels folder
use crate::panels::cpu;
use crate::panels::memory;
use crate::panels::swap;
use crate::panels::disk;
use crate::panels::info;
use crate::panels::process;

pub struct SysApp {
    pub sys: System,
    pub refresh_interval: Duration,
    pub last_refresh: Instant,

    // Flags for which panels to show
    pub show_os: bool,
    pub show_cpu: bool,
    pub show_mem: bool,
    pub show_swap: bool,
    pub show_uptime: bool,
    pub show_disk: bool,
    pub show_procs: bool,
    pub top_procs: usize,

    pub disks: Disks,
}

impl eframe::App for SysApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        // Refresh system data on interval
        if self.last_refresh.elapsed() >= self.refresh_interval {
            self.sys.refresh_all();
            self.last_refresh = Instant::now();
        }

        egui::CentralPanel::default().show(ctx, |ui| {
            ui.heading("System Resource Manager");
            ui.separator();

            egui::ScrollArea::vertical().show(ui, |ui| {
                // OS Info
                if self.show_os {
                    info::show_os_info(&self.sys, ui);
                }

                // CPU Info
                if self.show_cpu {
                    egui::CollapsingHeader::new("CPU Info")
                        .default_open(true)
                        .show(ui, |ui| {
                            cpu::show_cpu_info(&self.sys, ui);
                        });
                }

                // Memory Info
                if self.show_mem {
                    memory::show_memory_info(&self.sys, ui);
                }

                // Swap Info
                if self.show_swap {
                    swap::show_swap_info(&self.sys, ui);
                }

                // Uptime Info
                if self.show_uptime {
                    info::show_uptime(&self.sys, ui);
                }

                // Disk Info
                if self.show_disk {
                    egui::CollapsingHeader::new("Disk Info")
                        .default_open(true)
                        .show(ui, |ui| {
                            disk::show_disk_info(&self.disks, ui);
                        });
                }

                // Process Info
                if self.show_procs {
                    egui::CollapsingHeader::new("Process Info")
                        .default_open(true)
                        .show(ui, |ui| {
                            process::show_process_info(&self.sys, self.top_procs, ui)
                        }); 
                }

                // Status bar
                let elapsed = self.last_refresh.elapsed().as_secs();
                let visuals = ctx.style().visuals.clone();
                let theme_mode = if visuals.dark_mode { "Dark" } else { "Light" };

                ui.horizontal(|ui| {
                    ui.label(format!("Last updated: {}s ago", elapsed));
                    ui.label(format!("Refresh interval: {}s", self.refresh_interval.as_secs()));
                    ui.label(format!("Theme: {}", theme_mode));

                    // Toggle theme button
                    if ui.button("Toggle Theme").clicked() {
                        if visuals.dark_mode {
                            ctx.set_visuals(egui::Visuals::light());
                        } else {
                            ctx.set_visuals(egui::Visuals::dark());
                        }

                        let mut style = (*ctx.style()).clone();
                        style.visuals.override_text_color = Some(if ctx.style().visuals.dark_mode {
                            egui::Color32::WHITE
                        } else {
                            egui::Color32::BLACK
                        });
                        ctx.set_style(style);
                    }
                });
            });
        });
        ctx.request_repaint();
    }
}