424 lines
13 KiB
Rust
424 lines
13 KiB
Rust
use crate::{CrashReport, SystemOS};
|
|
use prometeu_hal::color::Color;
|
|
use prometeu_hal::primitives::Rect;
|
|
use prometeu_hal::{
|
|
FrameId, GfxUiCommand, InputPlatform, InputSignals, RenderSubmission, RuntimePlatform,
|
|
ShellUiFramePacket,
|
|
};
|
|
use prometeu_vm::VirtualMachine;
|
|
|
|
const SHELL_A_BUTTON: Rect = Rect { x: 112, y: 108, w: 112, h: 48 };
|
|
const SHELL_B_BUTTON: Rect = Rect { x: 256, y: 108, w: 112, h: 48 };
|
|
const CLOSE_BUTTON: Rect = Rect { x: 420, y: 24, w: 16, h: 16 };
|
|
const VIEWPORT: Rect = Rect { x: 0, y: 0, w: 480, h: 270 };
|
|
const HOME_PANEL: Rect = Rect { x: 48, y: 58, w: 384, h: 154 };
|
|
const TITLE_PANEL: Rect = Rect { x: 72, y: 34, w: 336, h: 28 };
|
|
#[cfg(test)]
|
|
const SHELL_FRAME: Rect = Rect { x: 40, y: 20, w: 400, h: 220 };
|
|
|
|
const COLOR_BG: Color = Color::rgb(12, 14, 22);
|
|
const COLOR_PANEL: Color = Color::rgb(25, 31, 48);
|
|
const COLOR_PANEL_DARK: Color = Color::rgb(8, 10, 16);
|
|
const COLOR_BORDER: Color = Color::rgb(180, 218, 222);
|
|
const COLOR_HILITE: Color = Color::rgb(252, 226, 122);
|
|
const COLOR_TEXT: Color = Color::rgb(230, 236, 224);
|
|
const COLOR_MUTED: Color = Color::rgb(91, 112, 128);
|
|
const COLOR_BUTTON: Color = Color::rgb(45, 59, 82);
|
|
const COLOR_BUTTON_ACTIVE: Color = Color::rgb(72, 91, 122);
|
|
|
|
/// PrometeuHub: Launcher and system UI environment.
|
|
pub struct PrometeuHub {
|
|
home_input_armed: bool,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum NativeShellApp {
|
|
ShellA,
|
|
ShellB,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
struct HubButtonSpec {
|
|
app: NativeShellApp,
|
|
rect: Rect,
|
|
label: &'static str,
|
|
}
|
|
|
|
const HOME_BUTTONS: [HubButtonSpec; 2] = [
|
|
HubButtonSpec { app: NativeShellApp::ShellA, rect: SHELL_A_BUTTON, label: "ShellA" },
|
|
HubButtonSpec { app: NativeShellApp::ShellB, rect: SHELL_B_BUTTON, label: "ShellB" },
|
|
];
|
|
|
|
impl NativeShellApp {
|
|
pub fn app_id(self) -> u32 {
|
|
match self {
|
|
Self::ShellA => 10_001,
|
|
Self::ShellB => 10_002,
|
|
}
|
|
}
|
|
|
|
pub fn title(self) -> &'static str {
|
|
match self {
|
|
Self::ShellA => "ShellA",
|
|
Self::ShellB => "ShellB",
|
|
}
|
|
}
|
|
|
|
pub fn color(self) -> Color {
|
|
match self {
|
|
Self::ShellA => Color::GREEN,
|
|
Self::ShellB => Color::BLUE,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum SystemProfileAction {
|
|
LaunchNativeShell(NativeShellApp),
|
|
CloseShell,
|
|
}
|
|
|
|
pub struct SystemProfileUpdate {
|
|
pub crash: Option<CrashReport>,
|
|
pub action: Option<SystemProfileAction>,
|
|
}
|
|
|
|
impl Default for PrometeuHub {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl PrometeuHub {
|
|
pub fn new() -> Self {
|
|
Self { home_input_armed: false }
|
|
}
|
|
|
|
pub fn init(&mut self) {
|
|
self.home_input_armed = false;
|
|
}
|
|
|
|
pub fn gui_update(
|
|
&mut self,
|
|
os: &mut SystemOS,
|
|
platform: &mut dyn RuntimePlatform,
|
|
) -> Option<SystemProfileAction> {
|
|
let in_shell = os.windows().focused_window().is_some();
|
|
|
|
if !in_shell {
|
|
if !self.home_input_armed {
|
|
self.home_input_armed = !activation_input_down(platform.input());
|
|
return None;
|
|
}
|
|
} else {
|
|
self.home_input_armed = false;
|
|
}
|
|
|
|
let input = platform.input();
|
|
if let Some(action) = action_for_click(
|
|
in_shell,
|
|
input.touch().x(),
|
|
input.touch().y(),
|
|
input.touch().f().pressed,
|
|
) {
|
|
return Some(action);
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
pub fn render(&mut self, os: &mut SystemOS, platform: &mut dyn RuntimePlatform) {
|
|
let pointer_x = platform.input().touch().x();
|
|
let pointer_y = platform.input().touch().y();
|
|
|
|
let packet = if os.windows().window_count() == 0 {
|
|
render_home_packet(pointer_x, pointer_y)
|
|
} else {
|
|
let mut commands = Vec::new();
|
|
for window in os.windows().windows() {
|
|
append_shell_window_commands(
|
|
&mut commands,
|
|
window.viewport,
|
|
window.color,
|
|
&window.title,
|
|
pointer_x,
|
|
pointer_y,
|
|
);
|
|
}
|
|
ShellUiFramePacket::new(commands)
|
|
};
|
|
platform
|
|
.render_submission_sink()
|
|
.submit_render_submission(RenderSubmission::shell_ui(FrameId::ZERO, packet))
|
|
.expect("hub render submission should publish");
|
|
}
|
|
|
|
pub fn update_shell_profile(
|
|
&mut self,
|
|
os: &mut SystemOS,
|
|
vm: &mut VirtualMachine,
|
|
signals: &InputSignals,
|
|
platform: &mut dyn RuntimePlatform,
|
|
) -> SystemProfileUpdate {
|
|
let mut crash = None;
|
|
let mut action = self.gui_update(os, platform);
|
|
|
|
if os.windows().focused_window().is_some() {
|
|
if platform.input().pad().start().down {
|
|
action = Some(SystemProfileAction::CloseShell);
|
|
} else if action != Some(SystemProfileAction::CloseShell) {
|
|
crash = os.vm().tick(vm, signals, platform);
|
|
}
|
|
}
|
|
|
|
self.render(os, platform);
|
|
|
|
SystemProfileUpdate { crash, action }
|
|
}
|
|
}
|
|
|
|
fn action_for_click(in_shell: bool, x: i32, y: i32, pressed: bool) -> Option<SystemProfileAction> {
|
|
if !pressed {
|
|
return None;
|
|
}
|
|
|
|
if in_shell {
|
|
return rect_contains(CLOSE_BUTTON, x, y).then_some(SystemProfileAction::CloseShell);
|
|
}
|
|
|
|
HOME_BUTTONS
|
|
.iter()
|
|
.find(|button| rect_contains(button.rect, x, y))
|
|
.map(|button| SystemProfileAction::LaunchNativeShell(button.app))
|
|
}
|
|
|
|
fn rect_contains(rect: Rect, x: i32, y: i32) -> bool {
|
|
x >= rect.x && x < rect.x + rect.w && y >= rect.y && y < rect.y + rect.h
|
|
}
|
|
|
|
fn activation_input_down(input: &dyn InputPlatform) -> bool {
|
|
input.touch().f().down
|
|
|| input.pad().a().down
|
|
|| input.pad().b().down
|
|
|| input.pad().start().down
|
|
}
|
|
|
|
fn render_home_packet(pointer_x: i32, pointer_y: i32) -> ShellUiFramePacket {
|
|
let mut commands = Vec::new();
|
|
commands.push(GfxUiCommand::Clear { color: COLOR_BG });
|
|
fill_rect(&mut commands, VIEWPORT, COLOR_BG);
|
|
draw_panel(&mut commands, TITLE_PANEL, COLOR_PANEL_DARK, COLOR_BORDER);
|
|
draw_buffer_text(
|
|
&mut commands,
|
|
TITLE_PANEL.x + 58,
|
|
TITLE_PANEL.y + 9,
|
|
"PROMETEU HUB",
|
|
COLOR_TEXT,
|
|
);
|
|
|
|
draw_panel(&mut commands, HOME_PANEL, COLOR_PANEL, COLOR_BORDER);
|
|
draw_buffer_text(
|
|
&mut commands,
|
|
HOME_PANEL.x + 26,
|
|
HOME_PANEL.y + 22,
|
|
"Native Shell Apps",
|
|
COLOR_TEXT,
|
|
);
|
|
draw_buffer_text(
|
|
&mut commands,
|
|
HOME_PANEL.x + 26,
|
|
HOME_PANEL.y + 40,
|
|
"first retro ui slice",
|
|
COLOR_MUTED,
|
|
);
|
|
|
|
for button in HOME_BUTTONS {
|
|
let hovered = rect_contains(button.rect, pointer_x, pointer_y);
|
|
draw_button(&mut commands, button.rect, button.label, hovered);
|
|
}
|
|
|
|
ShellUiFramePacket::new(commands)
|
|
}
|
|
|
|
fn append_shell_window_commands(
|
|
commands: &mut Vec<GfxUiCommand>,
|
|
viewport: Rect,
|
|
color: Color,
|
|
title: &str,
|
|
pointer_x: i32,
|
|
pointer_y: i32,
|
|
) {
|
|
fill_rect(commands, VIEWPORT, COLOR_BG);
|
|
draw_panel(commands, viewport, COLOR_PANEL_DARK, COLOR_BORDER);
|
|
fill_rect(
|
|
commands,
|
|
Rect { x: viewport.x + 4, y: viewport.y + 24, w: viewport.w - 8, h: viewport.h - 28 },
|
|
color,
|
|
);
|
|
draw_buffer_text(commands, viewport.x + 10, viewport.y + 8, title, COLOR_TEXT);
|
|
draw_buffer_text(
|
|
commands,
|
|
viewport.x + 18,
|
|
viewport.y + 44,
|
|
"native fake shell",
|
|
COLOR_PANEL_DARK,
|
|
);
|
|
|
|
let close_hovered = rect_contains(CLOSE_BUTTON, pointer_x, pointer_y);
|
|
let close_fill = if close_hovered { COLOR_HILITE } else { COLOR_BUTTON };
|
|
fill_rect(commands, CLOSE_BUTTON, close_fill);
|
|
draw_rect(commands, CLOSE_BUTTON, COLOR_BORDER);
|
|
draw_buffer_text(commands, CLOSE_BUTTON.x + 5, CLOSE_BUTTON.y + 4, "x", COLOR_TEXT);
|
|
}
|
|
|
|
fn fill_rect(commands: &mut Vec<GfxUiCommand>, rect: Rect, color: Color) {
|
|
commands.push(GfxUiCommand::FillRect { rect, color });
|
|
}
|
|
|
|
fn draw_rect(commands: &mut Vec<GfxUiCommand>, rect: Rect, color: Color) {
|
|
commands.push(GfxUiCommand::DrawLine {
|
|
x0: rect.x,
|
|
y0: rect.y,
|
|
x1: rect.x + rect.w - 1,
|
|
y1: rect.y,
|
|
color,
|
|
});
|
|
commands.push(GfxUiCommand::DrawLine {
|
|
x0: rect.x,
|
|
y0: rect.y + rect.h - 1,
|
|
x1: rect.x + rect.w - 1,
|
|
y1: rect.y + rect.h - 1,
|
|
color,
|
|
});
|
|
commands.push(GfxUiCommand::DrawLine {
|
|
x0: rect.x,
|
|
y0: rect.y,
|
|
x1: rect.x,
|
|
y1: rect.y + rect.h - 1,
|
|
color,
|
|
});
|
|
commands.push(GfxUiCommand::DrawLine {
|
|
x0: rect.x + rect.w - 1,
|
|
y0: rect.y,
|
|
x1: rect.x + rect.w - 1,
|
|
y1: rect.y + rect.h - 1,
|
|
color,
|
|
});
|
|
}
|
|
|
|
fn draw_panel(commands: &mut Vec<GfxUiCommand>, rect: Rect, fill: Color, border: Color) {
|
|
fill_rect(commands, rect, fill);
|
|
draw_rect(commands, rect, border);
|
|
draw_rect(
|
|
commands,
|
|
Rect { x: rect.x + 2, y: rect.y + 2, w: rect.w - 4, h: rect.h - 4 },
|
|
COLOR_MUTED,
|
|
);
|
|
}
|
|
|
|
fn draw_button(commands: &mut Vec<GfxUiCommand>, rect: Rect, label: &str, hovered: bool) {
|
|
let fill = if hovered { COLOR_BUTTON_ACTIVE } else { COLOR_BUTTON };
|
|
let border = if hovered { COLOR_HILITE } else { COLOR_BORDER };
|
|
fill_rect(commands, rect, fill);
|
|
draw_rect(commands, rect, border);
|
|
draw_rect(
|
|
commands,
|
|
Rect { x: rect.x + 3, y: rect.y + 3, w: rect.w - 6, h: rect.h - 6 },
|
|
COLOR_MUTED,
|
|
);
|
|
fill_rect(commands, Rect { x: rect.x + 12, y: rect.y + 12, w: 16, h: 24 }, border);
|
|
draw_rect(commands, Rect { x: rect.x + 34, y: rect.y + 12, w: 62, h: 24 }, COLOR_PANEL_DARK);
|
|
draw_buffer_text(commands, rect.x + 40, rect.y + 21, label, COLOR_TEXT);
|
|
}
|
|
|
|
fn draw_buffer_text(commands: &mut Vec<GfxUiCommand>, x: i32, y: i32, text: &str, color: Color) {
|
|
commands.push(GfxUiCommand::DrawText { x, y, text: text.to_string(), color });
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn shell_a_button_click_emits_launch_action() {
|
|
assert_eq!(
|
|
action_for_click(false, HOME_BUTTONS[0].rect.x, HOME_BUTTONS[0].rect.y, true),
|
|
Some(SystemProfileAction::LaunchNativeShell(NativeShellApp::ShellA))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn shell_b_button_click_emits_launch_action() {
|
|
assert_eq!(
|
|
action_for_click(
|
|
false,
|
|
SHELL_B_BUTTON.x + SHELL_B_BUTTON.w - 1,
|
|
SHELL_B_BUTTON.y,
|
|
true
|
|
),
|
|
Some(SystemProfileAction::LaunchNativeShell(NativeShellApp::ShellB))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn button_hit_test_excludes_right_and_bottom_edges() {
|
|
assert_eq!(
|
|
action_for_click(false, SHELL_A_BUTTON.x + SHELL_A_BUTTON.w, SHELL_A_BUTTON.y, true),
|
|
None
|
|
);
|
|
assert_eq!(
|
|
action_for_click(false, SHELL_A_BUTTON.x, SHELL_A_BUTTON.y + SHELL_A_BUTTON.h, true),
|
|
None
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn held_pointer_does_not_emit_click_action() {
|
|
assert_eq!(action_for_click(false, SHELL_A_BUTTON.x, SHELL_A_BUTTON.y, false), None);
|
|
}
|
|
|
|
#[test]
|
|
fn hub_starts_with_home_input_disarmed() {
|
|
let hub = PrometeuHub::new();
|
|
assert!(!hub.home_input_armed);
|
|
}
|
|
|
|
#[test]
|
|
fn close_button_click_emits_close_only_in_shell() {
|
|
assert_eq!(
|
|
action_for_click(true, CLOSE_BUTTON.x, CLOSE_BUTTON.y, true),
|
|
Some(SystemProfileAction::CloseShell)
|
|
);
|
|
assert_eq!(action_for_click(false, CLOSE_BUTTON.x, CLOSE_BUTTON.y, true), None);
|
|
}
|
|
|
|
#[test]
|
|
fn home_layout_exposes_exactly_two_manual_shell_buttons() {
|
|
assert_eq!(HOME_BUTTONS.len(), 2);
|
|
assert_eq!(HOME_BUTTONS[0].label, "ShellA");
|
|
assert_eq!(HOME_BUTTONS[0].app, NativeShellApp::ShellA);
|
|
assert_eq!(HOME_BUTTONS[1].label, "ShellB");
|
|
assert_eq!(HOME_BUTTONS[1].app, NativeShellApp::ShellB);
|
|
}
|
|
|
|
#[test]
|
|
fn home_render_produces_shell_ui_packet_commands() {
|
|
let packet = render_home_packet(SHELL_A_BUTTON.x, SHELL_A_BUTTON.y);
|
|
|
|
assert!(matches!(packet.commands.first(), Some(GfxUiCommand::Clear { .. })));
|
|
assert!(packet.commands.iter().any(|command| {
|
|
matches!(command, GfxUiCommand::DrawText { text, .. } if text == "PROMETEU HUB")
|
|
}));
|
|
}
|
|
|
|
#[test]
|
|
fn shell_close_button_sits_inside_shell_frame() {
|
|
assert!(rect_contains(SHELL_FRAME, CLOSE_BUTTON.x, CLOSE_BUTTON.y));
|
|
assert!(rect_contains(
|
|
SHELL_FRAME,
|
|
CLOSE_BUTTON.x + CLOSE_BUTTON.w - 1,
|
|
CLOSE_BUTTON.y + CLOSE_BUTTON.h - 1
|
|
));
|
|
}
|
|
}
|