refactor project structure (start of redoing atomic branch without atomics)

src/default/app.rs

@@ -0,0 +1,53 @@
+use winit::{
+    application::ApplicationHandler,
+    event::WindowEvent,
+    event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy},
+    window::WindowId,
+};
+
+pub trait AppState {
+    type Event: 'static;
+    fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self;
+    fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop);
+    fn event(&mut self, event: Self::Event, event_loop: &ActiveEventLoop);
+    fn exit(&mut self);
+}
+
+pub struct App<State: AppState> {
+    state: Option<State>,
+    proxy: EventLoopProxy<State::Event>,
+}
+
+impl<State: AppState> App<State> {
+    pub fn run() {
+        let event_loop = EventLoop::with_user_event().build().unwrap();
+        let proxy = event_loop.create_proxy();
+        event_loop
+            .run_app(&mut App::<State> { state: None, proxy })
+            .unwrap();
+    }
+}
+
+impl<State: AppState> ApplicationHandler<State::Event> for App<State> {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        if self.state.is_none() {
+            let state = State::new(event_loop, self.proxy.clone());
+            self.state = Some(state);
+        }
+    }
+
+    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
+        let state = self.state.as_mut().unwrap();
+        state.window_event(event, event_loop);
+    }
+
+    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: State::Event) {
+        let state = self.state.as_mut().unwrap();
+        state.event(event, event_loop);
+    }
+
+    fn exiting(&mut self, _: &ActiveEventLoop) {
+        let state = self.state.as_mut().unwrap();
+        state.exit();
+    }
+}

src/default/attr.rs

@@ -0,0 +1,55 @@
+use crate::{default::UiState, prelude::*};
+use std::time::{Duration, Instant};
+use winit::dpi::{LogicalPosition, LogicalSize};
+
+pub struct Selector;
+
+impl<W: 'static + Widget> WidgetAttr<W> for Selector {
+    type Input = WidgetId<TextEdit>;
+
+    fn run(ui: &mut Ui, container: &WidgetId<W>, id: Self::Input) {
+        let container = container.clone();
+        ui.register_event(
+            &container.clone(),
+            CursorSense::click_or_drag(),
+            move |mut ctx| {
+                let ui = ctx.ui;
+                let region = ui.window_region(&id).unwrap();
+                let id_pos = region.top_left;
+                let container_pos = ui.window_region(&container).unwrap().top_left;
+                ctx.data.cursor += container_pos - id_pos;
+                ctx.data.size = region.size();
+                select(ui, id.clone(), ctx.state, ctx.data);
+            },
+        );
+    }
+}
+
+pub struct Selectable;
+
+impl WidgetAttr<TextEdit> for Selectable {
+    type Input = ();
+
+    fn run(ui: &mut Ui, id: &WidgetId<TextEdit>, _: Self::Input) {
+        let id = id.clone();
+        ui.register_event(&id.clone(), CursorSense::click_or_drag(), move |ctx| {
+            select(ctx.ui, id.clone(), ctx.state, ctx.data);
+        });
+    }
+}
+
+fn select(ui: &mut Ui, id: WidgetId<TextEdit>, state: &mut UiState, data: CursorData) {
+    let now = Instant::now();
+    let recent = (now - state.last_click) < Duration::from_millis(300);
+    state.last_click = now;
+    id.edit(ui)
+        .select(data.cursor, data.size, data.sense.is_dragging(), recent);
+    if let Some(region) = ui.window_region(&id) {
+        state.window.set_ime_allowed(true);
+        state.window.set_ime_cursor_area(
+            LogicalPosition::<f32>::from(region.top_left.tuple()),
+            LogicalSize::<f32>::from(region.size().tuple()),
+        );
+    }
+    state.focus = Some(id);
+}

src/default/event.rs

@@ -0,0 +1,9 @@
+use crate::layout::DefaultEvent;
+
+#[derive(Eq, PartialEq, Hash, Clone)]
+pub struct Submit;
+impl DefaultEvent for Submit {}
+
+#[derive(Eq, PartialEq, Hash, Clone)]
+pub struct Edited;
+impl DefaultEvent for Edited {}

src/default/input.rs

@@ -0,0 +1,78 @@
+use crate::prelude::*;
+use winit::{
+    event::{MouseButton, MouseScrollDelta, WindowEvent},
+    keyboard::{Key, NamedKey},
+};
+
+#[derive(Default)]
+pub struct Input {
+    cursor: CursorState,
+    pub modifiers: Modifiers,
+}
+
+impl Input {
+    pub fn event(&mut self, event: &WindowEvent) -> bool {
+        match event {
+            WindowEvent::CursorMoved { position, .. } => {
+                self.cursor.pos = Vec2::new(position.x as f32, position.y as f32);
+                self.cursor.exists = true;
+            }
+            WindowEvent::MouseInput { state, button, .. } => {
+                let buttons = &mut self.cursor.buttons;
+                let pressed = state.is_pressed();
+                match button {
+                    MouseButton::Left => buttons.left.update(pressed),
+                    MouseButton::Right => buttons.right.update(pressed),
+                    MouseButton::Middle => buttons.middle.update(pressed),
+                    _ => (),
+                }
+            }
+            WindowEvent::MouseWheel { delta, .. } => {
+                let mut delta = match *delta {
+                    MouseScrollDelta::LineDelta(x, y) => Vec2::new(x, y),
+                    MouseScrollDelta::PixelDelta(pos) => Vec2::new(pos.x as f32, pos.y as f32),
+                };
+                if delta.x == 0.0 && self.modifiers.shift {
+                    delta.x = delta.y;
+                    delta.y = 0.0;
+                }
+                self.cursor.scroll_delta = delta;
+            }
+            WindowEvent::CursorLeft { .. } => {
+                self.cursor.exists = false;
+                self.modifiers.clear();
+            }
+            WindowEvent::KeyboardInput { event, .. } => {
+                if let Key::Named(named) = event.logical_key {
+                    let pressed = event.state.is_pressed();
+                    match named {
+                        NamedKey::Control => {
+                            self.modifiers.control = pressed;
+                        }
+                        NamedKey::Shift => {
+                            self.modifiers.shift = pressed;
+                        }
+                        _ => (),
+                    }
+                }
+            }
+            _ => return false,
+        }
+        true
+    }
+
+    pub fn end_frame(&mut self) {
+        self.cursor.end_frame();
+    }
+}
+
+impl UiState {
+    pub fn window_size(&self) -> Vec2 {
+        let size = self.renderer.window().inner_size();
+        (size.width, size.height).into()
+    }
+
+    pub fn cursor_state(&self) -> &CursorState {
+        &self.input.cursor
+    }
+}

src/default/mod.rs

@@ -0,0 +1,183 @@
+use crate::prelude::*;
+use arboard::Clipboard;
+use std::sync::Arc;
+use std::time::Instant;
+use winit::event::{Ime, WindowEvent};
+use winit::event_loop::{ActiveEventLoop, EventLoopProxy};
+use winit::window::{Window, WindowAttributes};
+
+mod app;
+mod attr;
+mod event;
+mod input;
+mod render;
+
+pub use app::*;
+pub use attr::*;
+pub use event::*;
+pub use input::*;
+pub use render::*;
+
+pub type Proxy<Event> = EventLoopProxy<Event>;
+pub type DefaultApp<Data> = App<DefaultState<Data>>;
+
+pub struct DefaultState<AppState> {
+    ui: Ui,
+    ui_state: UiState,
+    app_state: AppState,
+}
+
+pub struct UiState {
+    pub renderer: UiRenderer,
+    pub input: Input,
+    pub focus: Option<WidgetId<TextEdit>>,
+    pub clipboard: Clipboard,
+    pub window: Arc<Window>,
+    pub ime: usize,
+    pub last_click: Instant,
+}
+
+pub trait DefaultAppState: 'static {
+    type Event: 'static = ();
+    fn new(ui: &mut Ui, state: &UiState, proxy: Proxy<Self::Event>) -> Self;
+    #[allow(unused_variables)]
+    fn event(&mut self, event: Self::Event, ui: &mut Ui, state: &UiState) {}
+    #[allow(unused_variables)]
+    fn exit(&mut self, ui: &mut Ui, state: &UiState) {}
+    #[allow(unused_variables)]
+    fn window_event(&mut self, event: WindowEvent, ui: &mut Ui, state: &UiState) {}
+    fn window_attrs() -> WindowAttributes {
+        WindowAttributes::default()
+    }
+}
+
+impl<State: DefaultAppState> AppState for DefaultState<State> {
+    type Event = State::Event;
+
+    fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self {
+        let window = Arc::new(
+            event_loop
+                .create_window(State::window_attrs())
+                .expect("failed to create window "),
+        );
+        let mut ui = Ui::new();
+        let ui_state = UiState {
+            renderer: UiRenderer::new(window.clone()),
+            window,
+            input: Input::default(),
+            clipboard: Clipboard::new().unwrap(),
+            ime: 0,
+            last_click: Instant::now(),
+            focus: None,
+        };
+        let app_state = State::new(&mut ui, &ui_state, proxy);
+        Self {
+            ui,
+            ui_state,
+            app_state,
+        }
+    }
+
+    fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
+        self.app_state.event(event, &mut self.ui, &self.ui_state);
+    }
+
+    fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
+        let Self {
+            ui,
+            ui_state,
+            app_state,
+        } = self;
+
+        let input_changed = ui_state.input.event(&event);
+        let cursor_state = ui_state.cursor_state().clone();
+        let old = ui_state.focus.clone();
+        if cursor_state.buttons.left.is_start() {
+            ui_state.focus = None;
+        }
+        if input_changed {
+            let window_size = ui_state.window_size();
+            // call sensors with all 3 important contexts
+            // TODO: allow user to specify custom contexts?
+            // and give them both states in case they need both
+            ui.run_sensors(&mut (), &cursor_state, window_size);
+            ui.run_sensors(ui_state, &cursor_state, window_size);
+            ui.run_sensors(app_state, &cursor_state, window_size);
+        }
+        if old != ui_state.focus
+            && let Some(old) = old
+        {
+            old.edit(ui).deselect();
+        }
+        match &event {
+            WindowEvent::CloseRequested => event_loop.exit(),
+            WindowEvent::RedrawRequested => {
+                ui.update();
+                ui_state.renderer.update(ui);
+                ui_state.renderer.draw();
+            }
+            WindowEvent::Resized(size) => {
+                ui.resize((size.width, size.height));
+                ui_state.renderer.resize(size)
+            }
+            WindowEvent::KeyboardInput { event, .. } => {
+                if let Some(sel) = &ui_state.focus
+                    && event.state.is_pressed()
+                {
+                    let sel = &sel.clone();
+                    let mut text = sel.edit(ui);
+                    match text.apply_event(event, &ui_state.input.modifiers) {
+                        TextInputResult::Unfocus => {
+                            ui_state.focus = None;
+                            ui_state.window.set_ime_allowed(false);
+                        }
+                        TextInputResult::Submit => {
+                            ui.run_event(app_state, sel, Submit, ());
+                        }
+                        TextInputResult::Paste => {
+                            if let Ok(t) = ui_state.clipboard.get_text() {
+                                text.insert(&t);
+                            }
+                            ui.run_event(app_state, sel, Edited, ());
+                        }
+                        TextInputResult::Copy(text) => {
+                            if let Err(err) = ui_state.clipboard.set_text(text) {
+                                eprintln!("failed to copy text to clipboard: {err}")
+                            }
+                        }
+                        TextInputResult::Used => {
+                            ui.run_event(app_state, sel, Edited, ());
+                        }
+                        TextInputResult::Unused => {}
+                    }
+                }
+            }
+            WindowEvent::Ime(ime) => {
+                if let Some(sel) = &ui_state.focus {
+                    let mut text = sel.edit(ui);
+                    match ime {
+                        Ime::Enabled | Ime::Disabled => (),
+                        Ime::Preedit(content, _pos) => {
+                            // TODO: highlight once that's real
+                            text.replace(ui_state.ime, content);
+                            ui_state.ime = content.chars().count();
+                        }
+                        Ime::Commit(content) => {
+                            text.insert(content);
+                        }
+                    }
+                }
+            }
+            _ => (),
+        }
+        app_state.window_event(event, ui, ui_state);
+        if ui.needs_redraw() {
+            ui_state.renderer.window().request_redraw();
+        }
+        ui_state.input.end_frame();
+    }
+
+    fn exit(&mut self) {
+        self.app_state.exit(&mut self.ui, &self.ui_state);
+    }
+}

src/default/render.rs

@@ -0,0 +1,153 @@
+use crate::{
+    layout::Ui,
+    render::{UiLimits, UiRenderNode},
+};
+use pollster::FutureExt;
+use std::sync::Arc;
+use wgpu::{util::StagingBelt, *};
+use winit::{dpi::PhysicalSize, window::Window};
+
+pub const CLEAR_COLOR: Color = Color::BLACK;
+
+pub struct UiRenderer {
+    window: Arc<Window>,
+    surface: Surface<'static>,
+    device: Device,
+    queue: Queue,
+    config: SurfaceConfiguration,
+    encoder: CommandEncoder,
+    staging_belt: StagingBelt,
+    pub ui: UiRenderNode,
+}
+
+impl UiRenderer {
+    pub fn update(&mut self, updates: &mut Ui) {
+        self.ui.update(&self.device, &self.queue, updates);
+    }
+
+    pub fn draw(&mut self) {
+        let output = self.surface.get_current_texture().unwrap();
+        let view = output
+            .texture
+            .create_view(&TextureViewDescriptor::default());
+
+        let mut encoder = std::mem::replace(&mut self.encoder, Self::create_encoder(&self.device));
+        {
+            let render_pass = &mut encoder.begin_render_pass(&RenderPassDescriptor {
+                color_attachments: &[Some(RenderPassColorAttachment {
+                    view: &view,
+                    resolve_target: None,
+                    ops: Operations {
+                        load: LoadOp::Clear(CLEAR_COLOR),
+                        store: StoreOp::Store,
+                    },
+                    depth_slice: None,
+                })],
+                ..Default::default()
+            });
+            self.ui.draw(render_pass);
+        }
+
+        self.queue.submit(std::iter::once(encoder.finish()));
+        self.staging_belt.finish();
+        output.present();
+        self.staging_belt.recall();
+    }
+
+    pub fn resize(&mut self, size: &PhysicalSize<u32>) {
+        self.config.width = size.width;
+        self.config.height = size.height;
+        self.surface.configure(&self.device, &self.config);
+        self.ui.resize(size, &self.queue);
+    }
+
+    fn create_encoder(device: &Device) -> CommandEncoder {
+        device.create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("Render Encoder"),
+        })
+    }
+
+    pub fn new(window: Arc<Window>) -> Self {
+        let size = window.inner_size();
+
+        let instance = Instance::new(&InstanceDescriptor {
+            backends: Backends::PRIMARY,
+            flags: InstanceFlags::empty(),
+            ..Default::default()
+        });
+
+        let surface = instance
+            .create_surface(window.clone())
+            .expect("Could not create window surface!");
+
+        let adapter = instance
+            .request_adapter(&RequestAdapterOptions {
+                power_preference: PowerPreference::default(),
+                compatible_surface: Some(&surface),
+                force_fallback_adapter: false,
+            })
+            .block_on()
+            .expect("Could not get adapter!");
+
+        let ui_limits = UiLimits::default();
+
+        let (device, queue) = adapter
+            .request_device(&DeviceDescriptor {
+                required_features: Features::TEXTURE_BINDING_ARRAY
+                    | Features::PARTIALLY_BOUND_BINDING_ARRAY
+                    | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
+                required_limits: Limits {
+                    max_binding_array_elements_per_shader_stage: ui_limits
+                        .max_binding_array_elements_per_shader_stage(),
+                    max_binding_array_sampler_elements_per_shader_stage: ui_limits
+                        .max_binding_array_sampler_elements_per_shader_stage(),
+                    max_buffer_size: 1 << 30,
+                    ..Default::default()
+                },
+                ..Default::default()
+            })
+            .block_on()
+            .expect("Could not get device!");
+
+        let surface_caps = surface.get_capabilities(&adapter);
+        let surface_format = surface_caps
+            .formats
+            .iter()
+            .copied()
+            .find(|f| f.is_srgb())
+            .unwrap_or(surface_caps.formats[0]);
+
+        let config = SurfaceConfiguration {
+            usage: TextureUsages::RENDER_ATTACHMENT,
+            format: surface_format,
+            width: size.width,
+            height: size.height,
+            present_mode: PresentMode::AutoVsync,
+            alpha_mode: surface_caps.alpha_modes[0],
+            desired_maximum_frame_latency: 2,
+            view_formats: vec![],
+        };
+
+        surface.configure(&device, &config);
+
+        let staging_belt = StagingBelt::new(4096 * 4);
+        let encoder = Self::create_encoder(&device);
+
+        let shape_pipeline = UiRenderNode::new(&device, &queue, &config, ui_limits);
+
+        Self {
+            surface,
+            device,
+            queue,
+            config,
+            encoder,
+            staging_belt,
+            ui: shape_pipeline,
+            window,
+        }
+    }
+
+    pub fn window(&self) -> &Window {
+        self.window.as_ref()
+    }
+}