zaxis 0.0.5

An event-driven immediate mode GUI for desktop tools
Documentation
use std::{error::Error, sync::Arc, time::Duration};
use zaxis::Instant;

use zaxis::accesskit_winit::{Adapter, Event as AccessEvent, WindowEvent as AccessRequest};
use zaxis::winit::{
    application::ApplicationHandler,
    dpi::LogicalSize,
    event::WindowEvent,
    event_loop::{ActiveEventLoop, ControlFlow, EventLoop, EventLoopProxy},
    window::{Window as NativeWindow, WindowId},
};
use zaxis::{
    vec2, Context, PresentationMode, RenderError, RenderStatus, Renderer, Separator, Window,
};

#[path = "../tests/support/gpu_cache.rs"]
mod gpu_cache;

struct Demo {
    state: Option<State>,
    error: Option<Box<dyn Error>>,
    smoke_test: bool,
    /// Assistive technology reports through the loop: its requests are user events.
    proxy: EventLoopProxy<AccessEvent>,
}

struct State {
    /// The accessibility adapter of the window; dropped before the window.
    access: Adapter,
    window: Arc<NativeWindow>,
    renderer: Renderer,
    context: Context,
    clicks: u64,
    checked: bool,
    occluded: bool,
    retry_at: Option<Instant>,
}

impl ApplicationHandler<AccessEvent> for Demo {
    /// A screen reader asked for the tree, requested an action, or disconnected. Nothing
    /// is collected until the first request; the next frame then publishes the tree.
    fn user_event(&mut self, _event_loop: &ActiveEventLoop, event: AccessEvent) {
        let Some(state) = &mut self.state else {
            return;
        };
        let redraw = match event.window_event {
            AccessRequest::InitialTreeRequested => {
                state.context.set_accessibility_active(false);
                state.context.set_accessibility_active(true);
                true
            }
            AccessRequest::ActionRequested(request) => {
                state.context.on_accessibility_action(&request).repaint
            }
            AccessRequest::AccessibilityDeactivated => {
                state.context.set_accessibility_active(false);
                false
            }
        };
        if redraw {
            state.window.request_redraw();
        }
    }

    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        if let Some(state) = &mut self.state {
            state.occluded = false;
            state.context.request_repaint();
            state.window.request_redraw();
            return;
        }
        let proxy = self.proxy.clone();
        let result = (|| -> Result<State, Box<dyn Error>> {
            // The adapter must exist before the window is first shown.
            let window = Arc::new(
                event_loop.create_window(
                    NativeWindow::default_attributes()
                        .with_title("zaxis — desktop GUI")
                        .with_inner_size(LogicalSize::new(860.0, 560.0))
                        .with_visible(false),
                )?,
            );
            let access = Adapter::with_event_loop_proxy(event_loop, &window, proxy);
            window.set_visible(true);
            let mode = if std::env::args().any(|arg| arg == "--vsync") {
                PresentationMode::Vsync
            } else {
                PresentationMode::Immediate
            };
            let renderer = pollster::block_on(Renderer::new_with_presentation_mode(
                Arc::clone(&window),
                mode,
            ))?;
            let mut context = Context::new();
            context.set_viewport(window.inner_size(), window.scale_factor());
            context.set_accessibility_title("zaxis — desktop GUI");
            window.request_redraw();
            Ok(State {
                access,
                window,
                renderer,
                context,
                clicks: 0,
                checked: true,
                occluded: false,
                retry_at: None,
            })
        })();
        match result {
            Ok(state) => self.state = Some(state),
            Err(error) => {
                self.error = Some(error);
                event_loop.exit();
            }
        }
    }

    fn suspended(&mut self, _event_loop: &ActiveEventLoop) {
        // Surfaces must be dropped on platforms which invalidate them on suspension.
        self.state = None;
    }

    fn window_event(&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
        let Some(state) = &mut self.state else {
            return;
        };
        if state.window.id() != id {
            return;
        }
        state.access.process_event(&state.window, &event);
        let response = state.context.on_window_event(&event);
        match event {
            WindowEvent::CloseRequested => event_loop.exit(),
            WindowEvent::Resized(_) | WindowEvent::ScaleFactorChanged { .. } => {
                let size = state.window.inner_size();
                state
                    .context
                    .set_viewport(size, state.window.scale_factor());
                if let Err(error) = state.renderer.resize(size) {
                    self.error = Some(Box::new(error));
                    event_loop.exit();
                }
            }
            WindowEvent::Occluded(value) => {
                state.occluded = value;
                if !value {
                    state.window.request_redraw();
                }
            }
            WindowEvent::RedrawRequested => {
                let size = state.window.inner_size();
                if state.occluded
                    || state.window.is_minimized() == Some(true)
                    || size.width == 0
                    || size.height == 0
                {
                    return;
                }
                state.retry_at = None;
                let clicks = &mut state.clicks;
                let checked = &mut state.checked;
                state
                    .context
                    .run(|context| show_ui(context, clicks, checked));
                if let Some(update) = state.context.take_accessibility_update() {
                    state.access.update_if_active(|| update);
                }
                state.context.sync_ime(&state.window);
                match state
                    .renderer
                    .render(state.context.draw_data(), state.context.style().background)
                {
                    Ok(RenderStatus::Presented) if self.smoke_test => {
                        gpu_cache::verify_gpu_cache(state);
                        event_loop.exit();
                    }
                    Ok(RenderStatus::Presented | RenderStatus::Dormant) => {}
                    Ok(RenderStatus::Retry) => {
                        state.retry_at = Some(Instant::now() + Duration::from_millis(16))
                    }
                    Err(RenderError::DeviceLost(_)) => {
                        match pollster::block_on(Renderer::new_with_presentation_mode(
                            Arc::clone(&state.window),
                            state.renderer.presentation_mode(),
                        )) {
                            Ok(renderer) => {
                                state.renderer = renderer;
                                state.window.request_redraw();
                            }
                            Err(error) => {
                                self.error = Some(Box::new(error));
                                event_loop.exit();
                            }
                        }
                    }
                    Err(error) => {
                        self.error = Some(Box::new(error));
                        event_loop.exit();
                    }
                }
            }
            _ => {}
        }
        if response.repaint && !state.occluded {
            state.window.request_redraw();
        }
        state.window.set_cursor(state.context.cursor_icon());
    }

    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
        let Some(state) = &mut self.state else {
            event_loop.set_control_flow(ControlFlow::Wait);
            return;
        };
        let size = state.window.inner_size();
        if state.occluded
            || state.window.is_minimized() == Some(true)
            || size.width == 0
            || size.height == 0
        {
            event_loop.set_control_flow(ControlFlow::Wait);
            return;
        }
        let now = Instant::now();
        let moving = state.renderer.presentation_mode() == PresentationMode::Vsync
            && state.context.wants_animation_frame();
        let redraw = state
            .retry_at
            .map_or(state.context.needs_repaint_at(now) || moving, |deadline| {
                deadline <= now
            });
        if redraw {
            state.window.request_redraw();
        }
        let deadline = state
            .retry_at
            .or(state.context.next_repaint())
            .filter(|time| !redraw && *time > now);
        event_loop.set_control_flow(deadline.map_or(ControlFlow::Wait, ControlFlow::WaitUntil));
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    let event_loop = EventLoop::<AccessEvent>::with_user_event().build()?;
    event_loop.set_control_flow(ControlFlow::Wait);
    let mut demo = Demo {
        state: None,
        error: None,
        smoke_test: std::env::args().any(|arg| arg == "--smoke-test"),
        proxy: event_loop.create_proxy(),
    };
    event_loop.run_app(&mut demo)?;
    if let Some(error) = demo.error {
        return Err(error);
    }
    Ok(())
}

fn show_ui(context: &mut Context, clicks: &mut u64, checked: &mut bool) {
    Window::new("zaxis")
        .default_position(vec2(56.0, 48.0))
        .default_size(vec2(410.0, 410.0))
        .min_size(vec2(270.0, 230.0))
        .show(context, |ui| {
            ui.title("A small desktop UI");
            ui.label("Immediate mode widgets, cached geometry, and an event-driven renderer.");
            ui.separator();
            if ui.button("Click me").clicked() { *clicks += 1; }
            ui.label(format!("Clicks: {clicks}"));
            ui.checkbox(checked, "Show checkmark");
            ui.add(Separator::new().thickness(2.0).inset(8.0).spacing(2.0));
            ui.muted("Drag the title bar or resize the lower-right corner. Tab focuses the button; Space or Enter clicks it.");
        });
}