476 lines
16 KiB
C++
476 lines
16 KiB
C++
/*
|
|
* app_devexplorer.cpp
|
|
* ZenithOS Desktop - Device Explorer (lists hardware detected by the kernel)
|
|
* Copyright (c) 2026 Daniel Hammer
|
|
*/
|
|
|
|
#include "apps_common.hpp"
|
|
|
|
// ============================================================================
|
|
// Device Explorer state
|
|
// ============================================================================
|
|
|
|
static constexpr int DE_TOOLBAR_H = 36;
|
|
static constexpr int DE_CAT_H = 28;
|
|
static constexpr int DE_ITEM_H = 24;
|
|
static constexpr int DE_MAX_DEVS = 64;
|
|
static constexpr int DE_POLL_MS = 2000;
|
|
static constexpr int DE_INDENT = 28;
|
|
|
|
// Category names matching DevInfo.category values
|
|
static const char* category_names[] = {
|
|
"CPU", // 0
|
|
"Interrupt", // 1
|
|
"Timer", // 2
|
|
"Input", // 3
|
|
"USB", // 4
|
|
"Network", // 5
|
|
"Display", // 6
|
|
"PCI", // 7
|
|
};
|
|
static constexpr int NUM_CATEGORIES = 8;
|
|
|
|
static Color category_colors[] = {
|
|
Color::from_rgb(0x33, 0x66, 0xCC), // CPU - blue
|
|
Color::from_rgb(0x88, 0x44, 0xAA), // Interrupt - purple
|
|
Color::from_rgb(0x22, 0x88, 0x22), // Timer - green
|
|
Color::from_rgb(0xCC, 0x88, 0x00), // Input - amber
|
|
Color::from_rgb(0x00, 0x88, 0x88), // USB - teal
|
|
Color::from_rgb(0xCC, 0x55, 0x22), // Network - orange
|
|
Color::from_rgb(0x44, 0x66, 0xCC), // Display - indigo
|
|
Color::from_rgb(0x66, 0x66, 0x66), // PCI - gray
|
|
};
|
|
|
|
struct DevExplorerState {
|
|
DesktopState* desktop;
|
|
Zenith::DevInfo devs[DE_MAX_DEVS];
|
|
int dev_count;
|
|
bool collapsed[NUM_CATEGORIES]; // per-category collapse state
|
|
int selected_row; // index into visible display rows (-1 = none)
|
|
int scroll_y; // scroll offset in display rows
|
|
uint64_t last_poll_ms;
|
|
};
|
|
|
|
// ============================================================================
|
|
// Display row model
|
|
// ============================================================================
|
|
|
|
enum RowType { ROW_CATEGORY, ROW_DEVICE };
|
|
|
|
struct DisplayRow {
|
|
RowType type;
|
|
int category; // category index (0..7)
|
|
int dev_index; // index into devs[] (only valid for ROW_DEVICE)
|
|
};
|
|
|
|
static constexpr int MAX_DISPLAY_ROWS = DE_MAX_DEVS + NUM_CATEGORIES;
|
|
|
|
static int build_display_rows(DevExplorerState* de, DisplayRow* rows) {
|
|
int count = 0;
|
|
for (int cat = 0; cat < NUM_CATEGORIES; cat++) {
|
|
// Count devices in this category
|
|
int cat_count = 0;
|
|
for (int d = 0; d < de->dev_count; d++) {
|
|
if (de->devs[d].category == cat) cat_count++;
|
|
}
|
|
if (cat_count == 0) continue;
|
|
|
|
// Emit category header
|
|
rows[count].type = ROW_CATEGORY;
|
|
rows[count].category = cat;
|
|
rows[count].dev_index = -1;
|
|
count++;
|
|
|
|
// Emit device rows if expanded
|
|
if (!de->collapsed[cat]) {
|
|
for (int d = 0; d < de->dev_count; d++) {
|
|
if (de->devs[d].category == cat) {
|
|
rows[count].type = ROW_DEVICE;
|
|
rows[count].category = cat;
|
|
rows[count].dev_index = d;
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Triangle drawing helpers
|
|
// ============================================================================
|
|
|
|
static void draw_triangle_right(Canvas& c, int x, int y, int size, Color col) {
|
|
// Right-pointing filled triangle (▶)
|
|
int half = size / 2;
|
|
for (int row = 0; row < size; row++) {
|
|
int dist = (row <= half) ? row : (size - 1 - row);
|
|
for (int col_px = 0; col_px <= dist; col_px++) {
|
|
c.put_pixel(x + col_px, y + row, col);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void draw_triangle_down(Canvas& c, int x, int y, int size, Color col) {
|
|
// Down-pointing filled triangle (▼)
|
|
int half = size / 2;
|
|
for (int row = 0; row < half + 1; row++) {
|
|
int w = size - row * 2;
|
|
for (int col_px = 0; col_px < w; col_px++) {
|
|
c.put_pixel(x + row + col_px, y + row, col);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// Callbacks
|
|
// ============================================================================
|
|
|
|
static void devexplorer_on_poll(Window* win) {
|
|
DevExplorerState* de = (DevExplorerState*)win->app_data;
|
|
if (!de) return;
|
|
|
|
uint64_t now = zenith::get_milliseconds();
|
|
if (now - de->last_poll_ms < DE_POLL_MS) return;
|
|
de->last_poll_ms = now;
|
|
|
|
de->dev_count = zenith::devlist(de->devs, DE_MAX_DEVS);
|
|
}
|
|
|
|
static void devexplorer_on_draw(Window* win, Framebuffer& fb) {
|
|
DevExplorerState* de = (DevExplorerState*)win->app_data;
|
|
if (!de) return;
|
|
|
|
Canvas c(win);
|
|
c.fill(colors::WINDOW_BG);
|
|
|
|
int fh = system_font_height();
|
|
|
|
// --- Toolbar ---
|
|
c.fill_rect(0, 0, c.w, DE_TOOLBAR_H, Color::from_rgb(0xF5, 0xF5, 0xF5));
|
|
c.hline(0, DE_TOOLBAR_H - 1, c.w, colors::BORDER);
|
|
|
|
// "Refresh" button
|
|
int btn_w = 80;
|
|
int btn_h = 26;
|
|
int btn_x = 8;
|
|
int btn_y = (DE_TOOLBAR_H - btn_h) / 2;
|
|
c.button(btn_x, btn_y, btn_w, btn_h, "Refresh",
|
|
Color::from_rgb(0x33, 0x66, 0xCC), colors::WHITE, 4);
|
|
|
|
// Device count on right
|
|
char count_str[24];
|
|
snprintf(count_str, sizeof(count_str), "%d devices", de->dev_count);
|
|
int cw = text_width(count_str);
|
|
c.text(c.w - cw - 12, (DE_TOOLBAR_H - fh) / 2, count_str, colors::TEXT_COLOR);
|
|
|
|
// --- Build display rows ---
|
|
DisplayRow rows[MAX_DISPLAY_ROWS];
|
|
int row_count = build_display_rows(de, rows);
|
|
|
|
// --- Compute visible area ---
|
|
int list_y = DE_TOOLBAR_H;
|
|
int list_h = c.h - list_y;
|
|
if (list_h < 1) return;
|
|
|
|
// Clamp scroll
|
|
// Calculate total content height
|
|
int total_h = 0;
|
|
for (int i = 0; i < row_count; i++) {
|
|
total_h += (rows[i].type == ROW_CATEGORY) ? DE_CAT_H : DE_ITEM_H;
|
|
}
|
|
int max_scroll_px = total_h - list_h;
|
|
if (max_scroll_px < 0) max_scroll_px = 0;
|
|
|
|
// Convert scroll_y (in rows) to pixel offset for simplicity,
|
|
// but keep the row-based model: scroll_y = row offset
|
|
// We'll compute cumulative pixel offsets
|
|
int scroll_px = 0;
|
|
for (int i = 0; i < de->scroll_y && i < row_count; i++) {
|
|
scroll_px += (rows[i].type == ROW_CATEGORY) ? DE_CAT_H : DE_ITEM_H;
|
|
}
|
|
if (scroll_px > max_scroll_px) {
|
|
scroll_px = max_scroll_px;
|
|
// Recalculate scroll_y to match
|
|
de->scroll_y = 0;
|
|
int acc = 0;
|
|
for (int i = 0; i < row_count; i++) {
|
|
int rh = (rows[i].type == ROW_CATEGORY) ? DE_CAT_H : DE_ITEM_H;
|
|
if (acc + rh > max_scroll_px) break;
|
|
acc += rh;
|
|
de->scroll_y = i + 1;
|
|
}
|
|
}
|
|
if (de->scroll_y < 0) de->scroll_y = 0;
|
|
|
|
// Clamp selected_row
|
|
if (de->selected_row >= row_count) de->selected_row = row_count - 1;
|
|
|
|
// --- Draw rows ---
|
|
int draw_y = list_y - scroll_px;
|
|
// Advance to first visible area by recomputing from scroll offset
|
|
draw_y = list_y;
|
|
int first_visible = de->scroll_y;
|
|
|
|
// Compute starting y by accumulating heights of skipped rows
|
|
// Actually, let's just iterate all rows and skip those above the viewport
|
|
draw_y = list_y;
|
|
for (int i = 0; i < first_visible && i < row_count; i++) {
|
|
draw_y -= (rows[i].type == ROW_CATEGORY) ? DE_CAT_H : DE_ITEM_H;
|
|
}
|
|
|
|
// Draw from first_visible onward
|
|
int cur_y = list_y;
|
|
for (int i = first_visible; i < row_count; i++) {
|
|
int row_h = (rows[i].type == ROW_CATEGORY) ? DE_CAT_H : DE_ITEM_H;
|
|
if (cur_y >= c.h) break; // Past bottom of window
|
|
|
|
if (rows[i].type == ROW_CATEGORY) {
|
|
// Category header
|
|
int cat = rows[i].category;
|
|
c.fill_rect(0, cur_y, c.w, DE_CAT_H, Color::from_rgb(0xF0, 0xF0, 0xF0));
|
|
|
|
// Highlight if selected
|
|
if (i == de->selected_row) {
|
|
c.fill_rect(0, cur_y, c.w, DE_CAT_H, colors::MENU_HOVER);
|
|
}
|
|
|
|
// Expand/collapse triangle
|
|
int tri_x = 10;
|
|
int tri_y = cur_y + (DE_CAT_H - 8) / 2;
|
|
Color tri_color = Color::from_rgb(0x55, 0x55, 0x55);
|
|
if (de->collapsed[cat]) {
|
|
draw_triangle_right(c, tri_x, tri_y, 8, tri_color);
|
|
} else {
|
|
draw_triangle_down(c, tri_x, tri_y, 8, tri_color);
|
|
}
|
|
|
|
// Colored dot
|
|
int dot_x = 24;
|
|
int dot_y = cur_y + (DE_CAT_H - 8) / 2;
|
|
Color cat_col = (cat >= 0 && cat < NUM_CATEGORIES)
|
|
? category_colors[cat] : colors::TEXT_COLOR;
|
|
c.fill_rounded_rect(dot_x, dot_y, 8, 8, 4, cat_col);
|
|
|
|
// Category name
|
|
const char* cat_name = (cat >= 0 && cat < NUM_CATEGORIES)
|
|
? category_names[cat] : "?";
|
|
int text_y = cur_y + (DE_CAT_H - fh) / 2;
|
|
c.text(36, text_y, cat_name, Color::from_rgb(0x33, 0x33, 0x33));
|
|
|
|
// Device count in parentheses on right
|
|
int cat_count = 0;
|
|
for (int d = 0; d < de->dev_count; d++) {
|
|
if (de->devs[d].category == cat) cat_count++;
|
|
}
|
|
char cnt_buf[16];
|
|
snprintf(cnt_buf, sizeof(cnt_buf), "(%d)", cat_count);
|
|
int name_w = text_width(cat_name);
|
|
c.text(36 + name_w + 8, text_y, cnt_buf,
|
|
Color::from_rgb(0x88, 0x88, 0x88));
|
|
|
|
// Bottom border
|
|
c.hline(0, cur_y + DE_CAT_H - 1, c.w, Color::from_rgb(0xE0, 0xE0, 0xE0));
|
|
} else {
|
|
// Device item row
|
|
int di = rows[i].dev_index;
|
|
|
|
// Selected row highlight
|
|
if (i == de->selected_row) {
|
|
c.fill_rect(0, cur_y, c.w, DE_ITEM_H, colors::MENU_HOVER);
|
|
}
|
|
|
|
int text_y = cur_y + (DE_ITEM_H - fh) / 2;
|
|
|
|
// Device name (indented)
|
|
c.text(DE_INDENT + 10, text_y, de->devs[di].name, colors::TEXT_COLOR);
|
|
|
|
// Detail string (right column, gray)
|
|
int detail_x = c.w / 2 + 20;
|
|
c.text(detail_x, text_y, de->devs[di].detail,
|
|
Color::from_rgb(0x66, 0x66, 0x66));
|
|
}
|
|
|
|
cur_y += row_h;
|
|
}
|
|
|
|
// --- Scrollbar ---
|
|
if (total_h > list_h) {
|
|
int sb_x = c.w - 6;
|
|
int thumb_h = (list_h * list_h) / total_h;
|
|
if (thumb_h < 20) thumb_h = 20;
|
|
int thumb_y = list_y + (scroll_px * (list_h - thumb_h)) / max_scroll_px;
|
|
c.fill_rect(sb_x, list_y, 4, list_h, Color::from_rgb(0xE0, 0xE0, 0xE0));
|
|
c.fill_rect(sb_x, thumb_y, 4, thumb_h, Color::from_rgb(0xAA, 0xAA, 0xAA));
|
|
}
|
|
}
|
|
|
|
static void devexplorer_on_mouse(Window* win, MouseEvent& ev) {
|
|
DevExplorerState* de = (DevExplorerState*)win->app_data;
|
|
if (!de) return;
|
|
|
|
Rect cr = win->content_rect();
|
|
int lx = ev.x - cr.x;
|
|
int ly = ev.y - cr.y;
|
|
|
|
// Scroll
|
|
if (ev.scroll != 0) {
|
|
de->scroll_y += ev.scroll;
|
|
if (de->scroll_y < 0) de->scroll_y = 0;
|
|
return;
|
|
}
|
|
|
|
if (ev.left_pressed()) {
|
|
// Check "Refresh" button click
|
|
int btn_w = 80;
|
|
int btn_h = 26;
|
|
int btn_x = 8;
|
|
int btn_y = (DE_TOOLBAR_H - btn_h) / 2;
|
|
Rect btn_rect = {btn_x, btn_y, btn_w, btn_h};
|
|
if (btn_rect.contains(lx, ly)) {
|
|
de->last_poll_ms = 0; // force refresh
|
|
return;
|
|
}
|
|
|
|
// Check row click in list area
|
|
int list_y = DE_TOOLBAR_H;
|
|
if (ly >= list_y) {
|
|
// Build display rows to map click to row
|
|
DisplayRow rows[MAX_DISPLAY_ROWS];
|
|
int row_count = build_display_rows(de, rows);
|
|
|
|
// Walk rows from scroll offset, accumulating y
|
|
int cur_y = list_y;
|
|
for (int i = de->scroll_y; i < row_count; i++) {
|
|
int row_h = (rows[i].type == ROW_CATEGORY) ? DE_CAT_H : DE_ITEM_H;
|
|
if (ly >= cur_y && ly < cur_y + row_h) {
|
|
// Hit this row
|
|
if (rows[i].type == ROW_CATEGORY) {
|
|
// Toggle collapse
|
|
int cat = rows[i].category;
|
|
de->collapsed[cat] = !de->collapsed[cat];
|
|
de->selected_row = -1;
|
|
} else {
|
|
de->selected_row = i;
|
|
}
|
|
return;
|
|
}
|
|
cur_y += row_h;
|
|
if (cur_y >= win->content_h) break;
|
|
}
|
|
// Clicked below all rows
|
|
de->selected_row = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void devexplorer_on_key(Window* win, const Zenith::KeyEvent& key) {
|
|
DevExplorerState* de = (DevExplorerState*)win->app_data;
|
|
if (!de || !key.pressed) return;
|
|
|
|
DisplayRow rows[MAX_DISPLAY_ROWS];
|
|
int row_count = build_display_rows(de, rows);
|
|
if (row_count == 0) return;
|
|
|
|
if (key.scancode == 0x48) { // Up arrow
|
|
if (de->selected_row <= 0) {
|
|
de->selected_row = 0;
|
|
} else {
|
|
de->selected_row--;
|
|
}
|
|
// Scroll to keep selection visible
|
|
if (de->selected_row < de->scroll_y) {
|
|
de->scroll_y = de->selected_row;
|
|
}
|
|
} else if (key.scancode == 0x50) { // Down arrow
|
|
if (de->selected_row < row_count - 1) {
|
|
de->selected_row++;
|
|
}
|
|
// Scroll to keep selection visible — estimate visible rows
|
|
int list_h = win->content_h - DE_TOOLBAR_H;
|
|
int cur_h = 0;
|
|
int last_visible = de->scroll_y;
|
|
for (int i = de->scroll_y; i < row_count; i++) {
|
|
int rh = (rows[i].type == ROW_CATEGORY) ? DE_CAT_H : DE_ITEM_H;
|
|
if (cur_h + rh > list_h) break;
|
|
cur_h += rh;
|
|
last_visible = i;
|
|
}
|
|
if (de->selected_row > last_visible) {
|
|
de->scroll_y += (de->selected_row - last_visible);
|
|
}
|
|
} else if (key.scancode == 0x4B) { // Left arrow — collapse
|
|
if (de->selected_row >= 0 && de->selected_row < row_count) {
|
|
int cat = rows[de->selected_row].category;
|
|
if (!de->collapsed[cat]) {
|
|
de->collapsed[cat] = true;
|
|
// If we were on a device row, move selection to the category header
|
|
if (rows[de->selected_row].type == ROW_DEVICE) {
|
|
// Find the category header row for this category
|
|
for (int i = de->selected_row - 1; i >= 0; i--) {
|
|
if (rows[i].type == ROW_CATEGORY && rows[i].category == cat) {
|
|
de->selected_row = i;
|
|
break;
|
|
}
|
|
}
|
|
// After collapsing, rebuild and clamp
|
|
int new_count = build_display_rows(de, rows);
|
|
if (de->selected_row >= new_count)
|
|
de->selected_row = new_count - 1;
|
|
}
|
|
}
|
|
}
|
|
} else if (key.scancode == 0x4D) { // Right arrow — expand
|
|
if (de->selected_row >= 0 && de->selected_row < row_count) {
|
|
int cat = rows[de->selected_row].category;
|
|
de->collapsed[cat] = false;
|
|
}
|
|
} else if (key.scancode == 0x1C) { // Enter — toggle on category row
|
|
if (de->selected_row >= 0 && de->selected_row < row_count) {
|
|
if (rows[de->selected_row].type == ROW_CATEGORY) {
|
|
int cat = rows[de->selected_row].category;
|
|
de->collapsed[cat] = !de->collapsed[cat];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void devexplorer_on_close(Window* win) {
|
|
if (win->app_data) {
|
|
zenith::mfree(win->app_data);
|
|
win->app_data = nullptr;
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// Device Explorer launcher
|
|
// ============================================================================
|
|
|
|
void open_devexplorer(DesktopState* ds) {
|
|
int idx = desktop_create_window(ds, "Devices", 140, 70, 640, 460);
|
|
if (idx < 0) return;
|
|
|
|
Window* win = &ds->windows[idx];
|
|
|
|
DevExplorerState* de = (DevExplorerState*)zenith::malloc(sizeof(DevExplorerState));
|
|
zenith::memset(de, 0, sizeof(DevExplorerState));
|
|
de->desktop = ds;
|
|
de->selected_row = -1;
|
|
de->scroll_y = 0;
|
|
de->last_poll_ms = 0;
|
|
|
|
// All categories start expanded
|
|
for (int i = 0; i < NUM_CATEGORIES; i++)
|
|
de->collapsed[i] = false;
|
|
|
|
// Initial poll
|
|
de->dev_count = zenith::devlist(de->devs, DE_MAX_DEVS);
|
|
|
|
win->app_data = de;
|
|
win->on_draw = devexplorer_on_draw;
|
|
win->on_mouse = devexplorer_on_mouse;
|
|
win->on_key = devexplorer_on_key;
|
|
win->on_close = devexplorer_on_close;
|
|
win->on_poll = devexplorer_on_poll;
|
|
}
|