627 lines
17 KiB
Rust
627 lines
17 KiB
Rust
//! `cargo run --example mini_shell`
|
|
//!
|
|
//! A self-contained mini-shell that exercises the patterns described in
|
|
//! `docs/architecture.md`:
|
|
//!
|
|
//! - Multi-screen routing on the main surface (Home / Settings)
|
|
//! - Two coordinated overlays (Quick Settings + Confirm dialog)
|
|
//! - A pass-through OSD overlay with a fade-in/fade-out animation driven by
|
|
//! `is_animating()`
|
|
//! - Live dark/light theme switching from a UI toggle
|
|
//! - Nested message enums (`AppMsg::Home(HomeMsg)`, `AppMsg::Settings(...)`)
|
|
//! - One module per screen / overlay so the file scales like a real app
|
|
//!
|
|
//! Controls:
|
|
//! Esc — quit
|
|
//! Swipe down — open Quick Settings
|
|
//! Tap outside — dismiss any overlay
|
|
//!
|
|
//! NOTE: ltk is a Wayland toolkit. Run inside a Wayland session
|
|
//! (sway, labwc, the Liberux desktop, …).
|
|
|
|
use std::time::{ Duration, Instant };
|
|
|
|
use ltk::
|
|
{
|
|
App, ButtonVariant, Color, Element, Keysym, OverlayId, OverlaySpec,
|
|
ThemeMode,
|
|
button, column, container, progress_bar, row, slider, spacer, text, toggle,
|
|
};
|
|
|
|
// ── Stable overlay ids ────────────────────────────────────────────────────────
|
|
//
|
|
// Declare ids as constants so the runtime can diff the overlay list across
|
|
// frames and keep the underlying surfaces alive.
|
|
|
|
const OVERLAY_QUICK_SETTINGS: OverlayId = OverlayId( 1 );
|
|
const OVERLAY_CONFIRM: OverlayId = OverlayId( 2 );
|
|
const OVERLAY_TOAST: OverlayId = OverlayId( 3 );
|
|
|
|
const TOAST_LIFETIME: Duration = Duration::from_millis( 1800 );
|
|
const TOAST_FADE_IN: Duration = Duration::from_millis( 200 );
|
|
const TOAST_FADE_OUT: Duration = Duration::from_millis( 600 );
|
|
|
|
// ── Routing ───────────────────────────────────────────────────────────────────
|
|
|
|
#[ derive( Clone, Copy, PartialEq, Eq ) ]
|
|
enum Route { Home, Settings }
|
|
|
|
// ── Confirm dialog payload ────────────────────────────────────────────────────
|
|
//
|
|
// Models a user-initiated action that needs confirmation before it takes
|
|
// effect. The dialog itself is just a view of `AppState::pending_action`.
|
|
|
|
#[ derive( Clone, Copy ) ]
|
|
enum Action
|
|
{
|
|
PowerOff,
|
|
Reset,
|
|
}
|
|
|
|
impl Action
|
|
{
|
|
fn label( self ) -> &'static str
|
|
{
|
|
match self
|
|
{
|
|
Action::PowerOff => "Power off this device?",
|
|
Action::Reset => "Reset all settings to defaults?",
|
|
}
|
|
}
|
|
}
|
|
|
|
// ── Message tree ──────────────────────────────────────────────────────────────
|
|
//
|
|
// The top-level enum stays small and forwards to per-screen sub-enums — the
|
|
// recommended pattern once a shell has more than a handful of messages.
|
|
|
|
#[ derive( Clone ) ]
|
|
enum AppMsg
|
|
{
|
|
Nav( Route ),
|
|
Home( HomeMsg ),
|
|
Settings( SettingsMsg ),
|
|
|
|
// Overlay coordination
|
|
OpenQuickSettings,
|
|
CloseQuickSettings,
|
|
SetBrightness( f32 ),
|
|
|
|
ShowConfirm( Action ),
|
|
DismissConfirm,
|
|
ConfirmYes,
|
|
|
|
// Cross-cutting
|
|
SetThemeMode( ThemeMode ),
|
|
ShowToast( String ),
|
|
Quit,
|
|
}
|
|
|
|
#[ derive( Clone ) ]
|
|
enum HomeMsg { LaunchApp( &'static str ) }
|
|
#[ derive( Clone ) ]
|
|
enum SettingsMsg { ToggleNotifications }
|
|
|
|
// ── App state ─────────────────────────────────────────────────────────────────
|
|
|
|
struct AppState
|
|
{
|
|
route: Route,
|
|
|
|
// Per-screen state (in a real app each lives in its own module struct).
|
|
home: home::Home,
|
|
settings: settings::Settings,
|
|
|
|
// Overlay state
|
|
quick_settings_visible: bool,
|
|
pending_action: Option<Action>,
|
|
brightness: f32,
|
|
|
|
// Animated OSD toast
|
|
toast_text: Option<String>,
|
|
toast_started: Option<Instant>,
|
|
}
|
|
|
|
impl AppState
|
|
{
|
|
fn new() -> Self
|
|
{
|
|
Self
|
|
{
|
|
route: Route::Home,
|
|
home: home::Home::new(),
|
|
settings: settings::Settings::new(),
|
|
quick_settings_visible: false,
|
|
pending_action: None,
|
|
brightness: 0.7,
|
|
toast_text: None,
|
|
toast_started: None,
|
|
}
|
|
}
|
|
|
|
fn show_toast( &mut self, msg: String )
|
|
{
|
|
self.toast_text = Some( msg );
|
|
self.toast_started = Some( Instant::now() );
|
|
}
|
|
|
|
/// 0.0 = invisible, 1.0 = fully opaque. Used by the OSD overlay's view.
|
|
fn toast_alpha( &self ) -> f32
|
|
{
|
|
let Some( start ) = self.toast_started else { return 0.0 };
|
|
let elapsed = start.elapsed();
|
|
if elapsed < TOAST_FADE_IN
|
|
{
|
|
elapsed.as_secs_f32() / TOAST_FADE_IN.as_secs_f32()
|
|
} else if elapsed < TOAST_LIFETIME - TOAST_FADE_OUT {
|
|
1.0
|
|
} else if elapsed < TOAST_LIFETIME {
|
|
let t = ( TOAST_LIFETIME - elapsed ).as_secs_f32() / TOAST_FADE_OUT.as_secs_f32();
|
|
t.max( 0.0 )
|
|
} else {
|
|
0.0
|
|
}
|
|
}
|
|
}
|
|
|
|
// ── App trait ─────────────────────────────────────────────────────────────────
|
|
|
|
impl App for AppState
|
|
{
|
|
type Message = AppMsg;
|
|
|
|
fn view( &self ) -> Element<AppMsg>
|
|
{
|
|
match self.route
|
|
{
|
|
Route::Home => self.home.view(),
|
|
Route::Settings => self.settings.view(),
|
|
}
|
|
}
|
|
|
|
fn overlays( &self ) -> Vec<OverlaySpec<AppMsg>>
|
|
{
|
|
let mut out = Vec::new();
|
|
|
|
if self.quick_settings_visible
|
|
{
|
|
out.push( OverlaySpec
|
|
{
|
|
id: OVERLAY_QUICK_SETTINGS,
|
|
layer: ltk::Layer::Overlay,
|
|
anchor: ltk::Anchor::ALL,
|
|
size: ( 0, 0 ),
|
|
exclusive_zone: 0,
|
|
keyboard_exclusive: false,
|
|
input_region: None,
|
|
view: overlays::quick_settings( self ),
|
|
on_dismiss: Some( AppMsg::CloseQuickSettings ),
|
|
anchor_widget_id: None,
|
|
} );
|
|
}
|
|
|
|
if let Some( action ) = self.pending_action
|
|
{
|
|
out.push( OverlaySpec
|
|
{
|
|
id: OVERLAY_CONFIRM,
|
|
layer: ltk::Layer::Overlay,
|
|
anchor: ltk::Anchor::ALL,
|
|
size: ( 0, 0 ),
|
|
exclusive_zone: 0,
|
|
keyboard_exclusive: false,
|
|
input_region: None,
|
|
view: overlays::confirm( action ),
|
|
on_dismiss: Some( AppMsg::DismissConfirm ),
|
|
anchor_widget_id: None,
|
|
} );
|
|
}
|
|
|
|
if self.toast_text.is_some()
|
|
{
|
|
out.push( OverlaySpec
|
|
{
|
|
id: OVERLAY_TOAST,
|
|
layer: ltk::Layer::Overlay,
|
|
anchor: ltk::Anchor::ALL,
|
|
size: ( 0, 0 ),
|
|
exclusive_zone: 0,
|
|
keyboard_exclusive: false,
|
|
// Pass-through: the OSD must not steal taps from anything below.
|
|
input_region: Some( Vec::new() ),
|
|
view: overlays::toast( self ),
|
|
on_dismiss: None,
|
|
anchor_widget_id: None,
|
|
} );
|
|
}
|
|
|
|
out
|
|
}
|
|
|
|
fn update( &mut self, msg: AppMsg )
|
|
{
|
|
match msg
|
|
{
|
|
AppMsg::Nav( r ) => self.route = r,
|
|
AppMsg::Home( m ) =>
|
|
{
|
|
if let Some( follow ) = self.home.update( m )
|
|
{
|
|
self.update( follow );
|
|
}
|
|
}
|
|
AppMsg::Settings( m ) => self.settings.update( m ),
|
|
|
|
AppMsg::OpenQuickSettings => self.quick_settings_visible = true,
|
|
AppMsg::CloseQuickSettings => self.quick_settings_visible = false,
|
|
AppMsg::SetBrightness( v ) => self.brightness = v,
|
|
|
|
AppMsg::ShowConfirm( a ) => self.pending_action = Some( a ),
|
|
AppMsg::DismissConfirm => self.pending_action = None,
|
|
AppMsg::ConfirmYes =>
|
|
{
|
|
if let Some( action ) = self.pending_action.take()
|
|
{
|
|
match action
|
|
{
|
|
Action::PowerOff => self.show_toast( "Pretending to power off…".into() ),
|
|
Action::Reset =>
|
|
{
|
|
self.settings = settings::Settings::new();
|
|
self.brightness = 0.7;
|
|
self.show_toast( "Settings reset".into() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
AppMsg::SetThemeMode( m ) => ltk::set_active_mode( m ),
|
|
AppMsg::ShowToast( s ) => self.show_toast( s ),
|
|
AppMsg::Quit => std::process::exit( 0 ),
|
|
}
|
|
}
|
|
|
|
// Animation: keep redrawing while the toast is on screen so it can fade.
|
|
fn is_animating( &self ) -> bool
|
|
{
|
|
self.toast_started.is_some()
|
|
}
|
|
|
|
// Auto-expire the toast once its lifetime is up. Putting this in
|
|
// `poll_external` (rather than `update`) means the loop wakes itself when
|
|
// `is_animating()` is driving redraws and cleans up without user input.
|
|
fn poll_external( &mut self ) -> Vec<AppMsg>
|
|
{
|
|
if let Some( start ) = self.toast_started
|
|
{
|
|
if start.elapsed() >= TOAST_LIFETIME
|
|
{
|
|
self.toast_text = None;
|
|
self.toast_started = None;
|
|
}
|
|
}
|
|
Vec::new()
|
|
}
|
|
|
|
fn on_swipe_down( &mut self ) -> Option<AppMsg>
|
|
{
|
|
Some( AppMsg::OpenQuickSettings )
|
|
}
|
|
|
|
fn swipe_down_threshold( &self ) -> f32 { 0.10 }
|
|
|
|
fn on_key( &mut self, k: Keysym ) -> Option<AppMsg>
|
|
{
|
|
match k
|
|
{
|
|
Keysym::Escape => Some( AppMsg::Quit ),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn background_color( &self ) -> Color
|
|
{
|
|
// Use the active theme's background so dark/light flips immediately.
|
|
ltk::theme_palette().bg
|
|
}
|
|
}
|
|
|
|
// ── Per-screen modules ────────────────────────────────────────────────────────
|
|
//
|
|
// In a real app each of these lives in its own file (`src/home.rs`,
|
|
// `src/settings.rs`, …). Inlined here so the example stays a single file.
|
|
|
|
mod home
|
|
{
|
|
use super::*;
|
|
|
|
pub struct Home
|
|
{
|
|
pub last_launched: Option<&'static str>,
|
|
}
|
|
|
|
impl Home
|
|
{
|
|
pub fn new() -> Self { Self { last_launched: None } }
|
|
|
|
/// Cmd-style: returns an optional follow-up message instead of mutating
|
|
/// shared state. The parent `update` runs the follow-up, which keeps
|
|
/// the borrow checker happy.
|
|
pub fn update( &mut self, msg: HomeMsg ) -> Option<AppMsg>
|
|
{
|
|
match msg
|
|
{
|
|
HomeMsg::LaunchApp( name ) =>
|
|
{
|
|
self.last_launched = Some( name );
|
|
Some( AppMsg::ShowToast( format!( "Launched {}", name ) ) )
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn view( &self ) -> Element<AppMsg>
|
|
{
|
|
let palette = ltk::theme_palette();
|
|
|
|
let title = text( "Mini Shell" )
|
|
.size( 28.0 )
|
|
.color( palette.text_primary )
|
|
.align_center();
|
|
|
|
let status = text( match self.last_launched
|
|
{
|
|
Some( n ) => format!( "Last launched: {}", n ),
|
|
None => "No app launched yet".into(),
|
|
} )
|
|
.size( 13.0 )
|
|
.color( palette.text_secondary )
|
|
.align_center();
|
|
|
|
let mut grid = ltk::grid::<AppMsg>( 2 ).spacing( 12.0 ).padding( 0.0 );
|
|
for name in &["Browser", "Mail", "Camera", "Music"]
|
|
{
|
|
grid = grid.push(
|
|
button::<AppMsg>( *name )
|
|
.variant( ButtonVariant::Secondary )
|
|
.on_press( AppMsg::Home( HomeMsg::LaunchApp( name ) ) ),
|
|
);
|
|
}
|
|
|
|
column::<AppMsg>()
|
|
.padding( 32.0 )
|
|
.spacing( 16.0 )
|
|
.push( title )
|
|
.push( status )
|
|
.push( spacer() )
|
|
.push( grid )
|
|
.push( spacer() )
|
|
.push(
|
|
button::<AppMsg>( "Settings" )
|
|
.on_press( AppMsg::Nav( Route::Settings ) ),
|
|
)
|
|
.into()
|
|
}
|
|
}
|
|
}
|
|
|
|
mod settings
|
|
{
|
|
use super::*;
|
|
|
|
pub struct Settings
|
|
{
|
|
pub notifications_enabled: bool,
|
|
}
|
|
|
|
impl Settings
|
|
{
|
|
pub fn new() -> Self { Self { notifications_enabled: true } }
|
|
|
|
pub fn update( &mut self, msg: SettingsMsg )
|
|
{
|
|
match msg
|
|
{
|
|
SettingsMsg::ToggleNotifications => self.notifications_enabled = !self.notifications_enabled,
|
|
}
|
|
}
|
|
|
|
pub fn view( &self ) -> Element<AppMsg>
|
|
{
|
|
let palette = ltk::theme_palette();
|
|
let is_dark = ltk::active_mode() == ThemeMode::Dark;
|
|
let next = if is_dark { ThemeMode::Light } else { ThemeMode::Dark };
|
|
let label = if is_dark { "Switch to Light" } else { "Switch to Dark" };
|
|
|
|
column::<AppMsg>()
|
|
.padding( 32.0 )
|
|
.spacing( 16.0 )
|
|
.push( text( "Settings" ).size( 24.0 ).color( palette.text_primary ) )
|
|
.push(
|
|
toggle::<AppMsg>( self.notifications_enabled )
|
|
.label( "Notifications" )
|
|
.on_toggle( AppMsg::Settings( SettingsMsg::ToggleNotifications ) ),
|
|
)
|
|
.push( spacer() )
|
|
.push( text( "Theme" ).size( 14.0 ).color( palette.text_secondary ) )
|
|
.push(
|
|
button::<AppMsg>( label )
|
|
.variant( ButtonVariant::Secondary )
|
|
.on_press( AppMsg::SetThemeMode( next ) ),
|
|
)
|
|
.push( spacer() )
|
|
.push(
|
|
row::<AppMsg>()
|
|
.spacing( 12.0 )
|
|
.push(
|
|
button::<AppMsg>( "Show toast" )
|
|
.variant( ButtonVariant::Secondary )
|
|
.on_press( AppMsg::ShowToast( "Hello from Settings".into() ) ),
|
|
)
|
|
.push(
|
|
button::<AppMsg>( "Reset settings" )
|
|
.variant( ButtonVariant::Secondary )
|
|
.on_press( AppMsg::ShowConfirm( Action::Reset ) ),
|
|
),
|
|
)
|
|
.push(
|
|
button::<AppMsg>( "Power off" )
|
|
.on_press( AppMsg::ShowConfirm( Action::PowerOff ) ),
|
|
)
|
|
.push( spacer() )
|
|
.push(
|
|
button::<AppMsg>( "Back" )
|
|
.variant( ButtonVariant::Tertiary )
|
|
.on_press( AppMsg::Nav( Route::Home ) ),
|
|
)
|
|
.into()
|
|
}
|
|
}
|
|
}
|
|
|
|
mod overlays
|
|
{
|
|
use super::*;
|
|
|
|
/// Quick Settings: brightness slider + theme toggle + close button.
|
|
pub fn quick_settings( app: &AppState ) -> Element<AppMsg>
|
|
{
|
|
let palette = ltk::theme_palette();
|
|
let is_dark = ltk::active_mode() == ThemeMode::Dark;
|
|
let next = if is_dark { ThemeMode::Light } else { ThemeMode::Dark };
|
|
|
|
let panel = container::<AppMsg>(
|
|
column::<AppMsg>()
|
|
.padding( 0.0 )
|
|
.spacing( 12.0 )
|
|
.push(
|
|
row::<AppMsg>()
|
|
.spacing( 8.0 )
|
|
.push( text( "Quick Settings" ).size( 18.0 ).color( palette.text_primary ) )
|
|
.push( spacer() )
|
|
.push(
|
|
button::<AppMsg>( "Close" )
|
|
.variant( ButtonVariant::Tertiary )
|
|
.on_press( AppMsg::CloseQuickSettings ),
|
|
),
|
|
)
|
|
.push( text( format!( "Brightness {:.0}%", app.brightness * 100.0 ) )
|
|
.size( 13.0 )
|
|
.color( palette.text_primary ) )
|
|
.push( slider::<AppMsg>( app.brightness ).on_change( AppMsg::SetBrightness ) )
|
|
.push(
|
|
button::<AppMsg>( if is_dark { "Light theme" } else { "Dark theme" } )
|
|
.variant( ButtonVariant::Secondary )
|
|
.on_press( AppMsg::SetThemeMode( next ) ),
|
|
),
|
|
)
|
|
.background( palette.surface_alt )
|
|
.radius( 16.0 )
|
|
.padding( 20.0 );
|
|
|
|
// Center the panel on the overlay surface using spacers.
|
|
column::<AppMsg>()
|
|
.padding( 24.0 )
|
|
.spacing( 0.0 )
|
|
.max_width( 360.0 )
|
|
.push( panel )
|
|
.push( spacer() )
|
|
.into()
|
|
}
|
|
|
|
/// Confirm dialog. Same overlay pattern, different content.
|
|
pub fn confirm( action: Action ) -> Element<AppMsg>
|
|
{
|
|
let palette = ltk::theme_palette();
|
|
|
|
let panel = container::<AppMsg>(
|
|
column::<AppMsg>()
|
|
.padding( 0.0 )
|
|
.spacing( 16.0 )
|
|
.push( text( action.label() )
|
|
.size( 16.0 )
|
|
.color( palette.text_primary )
|
|
.align_center() )
|
|
.push(
|
|
row::<AppMsg>()
|
|
.spacing( 12.0 )
|
|
.push(
|
|
button::<AppMsg>( "Cancel" )
|
|
.variant( ButtonVariant::Tertiary )
|
|
.on_press( AppMsg::DismissConfirm ),
|
|
)
|
|
.push( spacer() )
|
|
.push(
|
|
button::<AppMsg>( "Confirm" )
|
|
.on_press( AppMsg::ConfirmYes ),
|
|
),
|
|
),
|
|
)
|
|
.background( palette.surface_alt )
|
|
.radius( 16.0 )
|
|
.padding( 24.0 );
|
|
|
|
column::<AppMsg>()
|
|
.padding( 0.0 )
|
|
.spacing( 0.0 )
|
|
.max_width( 320.0 )
|
|
.push( spacer() )
|
|
.push( panel )
|
|
.push( spacer() )
|
|
.into()
|
|
}
|
|
|
|
/// Pass-through OSD. The fade is computed from elapsed time, not stored.
|
|
pub fn toast( app: &AppState ) -> Element<AppMsg>
|
|
{
|
|
let palette = ltk::theme_palette();
|
|
let alpha = app.toast_alpha();
|
|
let txt = app.toast_text.as_deref().unwrap_or( "" );
|
|
|
|
// Apply the fade by attenuating the surface alpha. Text/progress stay
|
|
// readable; the container background fades.
|
|
let mut bg = palette.surface_alt;
|
|
bg.a *= alpha;
|
|
|
|
let mut fg = palette.text_primary;
|
|
fg.a *= alpha;
|
|
|
|
let panel = container::<AppMsg>(
|
|
column::<AppMsg>()
|
|
.padding( 0.0 )
|
|
.spacing( 8.0 )
|
|
.push( text( txt ).size( 15.0 ).color( fg ).align_center() )
|
|
.push( progress_bar( alpha ) ),
|
|
)
|
|
.background( bg )
|
|
.radius( 12.0 )
|
|
.padding( 16.0 );
|
|
|
|
column::<AppMsg>()
|
|
.padding( 0.0 )
|
|
.spacing( 0.0 )
|
|
.max_width( 280.0 )
|
|
.push( spacer() )
|
|
.push( spacer() )
|
|
.push( spacer() )
|
|
.push( panel )
|
|
.into()
|
|
}
|
|
}
|
|
|
|
// ── Entry point ───────────────────────────────────────────────────────────────
|
|
|
|
fn main()
|
|
{
|
|
// Load the on-disk default theme. ltk has no in-code fallback: the
|
|
// `ltk-theme-default` Debian package (or a dev-time
|
|
// `LTK_THEMES_DIR=<repo>/themes`) must provide
|
|
// `default/theme.json`. `ltk::run` would otherwise panic on first
|
|
// theme access with the same message as the one below.
|
|
let doc = ltk::ThemeDocument::find( "default" )
|
|
.expect( "ltk: the `default` theme is required (install `ltk-theme-default` or set `LTK_THEMES_DIR`)" );
|
|
ltk::set_active_document( doc );
|
|
ltk::set_active_mode( ThemeMode::Dark );
|
|
|
|
ltk::run( AppState::new() );
|
|
}
|