[parley] new selection logic and an editor example

Cargo.toml

@@ -5,6 +5,7 @@ members = [
     "parley",
     "examples/tiny_skia_render",
     "examples/swash_render",
+    "examples/vello_editor",
 ]
 
 [workspace.package]

examples/swash_render/src/main.rs

@@ -80,7 +80,6 @@ fn main() {
     let mut layout: Layout<Color> = builder.build();
 
     // Perform layout (including bidi resolution and shaping) with start alignment
-    layout.break_all_lines(max_advance);
     layout.align(max_advance, Alignment::Start);
 
     // Create image to render into

examples/vello_editor/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "vello_editor"
+version = "0.1.0"
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[dependencies]
+vello = "0.2.1"
+anyhow = "1.0.86"
+pollster = "0.3.0"
+winit = "0.30.3"
+parley = { workspace = true, default-features = true }
+peniko = { workspace = true }
+clipboard-rs = "0.1.11"
+
+[lints]
+workspace = true

examples/vello_editor/src/main.rs

@@ -0,0 +1,223 @@
+// Copyright 2024 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use anyhow::Result;
+use std::num::NonZeroUsize;
+use std::sync::Arc;
+use vello::peniko::Color;
+use vello::util::{RenderContext, RenderSurface};
+use vello::wgpu;
+use vello::{AaConfig, Renderer, RendererOptions, Scene};
+use winit::application::ApplicationHandler;
+use winit::dpi::LogicalSize;
+use winit::event::*;
+use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
+use winit::window::Window;
+
+// #[path = "text2.rs"]
+mod text;
+
+// Simple struct to hold the state of the renderer
+pub struct ActiveRenderState<'s> {
+    // The fields MUST be in this order, so that the surface is dropped before the window
+    surface: RenderSurface<'s>,
+    window: Arc<Window>,
+}
+
+enum RenderState<'s> {
+    Active(ActiveRenderState<'s>),
+    // Cache a window so that it can be reused when the app is resumed after being suspended
+    Suspended(Option<Arc<Window>>),
+}
+
+struct SimpleVelloApp<'s> {
+    // The vello RenderContext which is a global context that lasts for the
+    // lifetime of the application
+    context: RenderContext,
+
+    // An array of renderers, one per wgpu device
+    renderers: Vec<Option<Renderer>>,
+
+    // State for our example where we store the winit Window and the wgpu Surface
+    state: RenderState<'s>,
+
+    // A vello Scene which is a data structure which allows one to build up a
+    // description a scene to be drawn (with paths, fills, images, text, etc)
+    // which is then passed to a renderer for rendering
+    scene: Scene,
+
+    // Our text state object
+    editor: text::Editor,
+}
+
+impl<'s> ApplicationHandler for SimpleVelloApp<'s> {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        let RenderState::Suspended(cached_window) = &mut self.state else {
+            return;
+        };
+
+        // Get the winit window cached in a previous Suspended event or else create a new window
+        let window = cached_window
+            .take()
+            .unwrap_or_else(|| create_winit_window(event_loop));
+
+        // Create a vello Surface
+        let size = window.inner_size();
+        let surface_future = self.context.create_surface(
+            window.clone(),
+            size.width,
+            size.height,
+            wgpu::PresentMode::AutoVsync,
+        );
+        let surface = pollster::block_on(surface_future).expect("Error creating surface");
+        self.editor.update_layout(size.width as _, 1.0);
+
+        // Create a vello Renderer for the surface (using its device id)
+        self.renderers
+            .resize_with(self.context.devices.len(), || None);
+        self.renderers[surface.dev_id]
+            .get_or_insert_with(|| create_vello_renderer(&self.context, &surface));
+
+        // Save the Window and Surface to a state variable
+        self.state = RenderState::Active(ActiveRenderState { window, surface });
+
+        event_loop.set_control_flow(ControlFlow::Poll);
+    }
+
+    fn suspended(&mut self, event_loop: &ActiveEventLoop) {
+        if let RenderState::Active(state) = &self.state {
+            self.state = RenderState::Suspended(Some(state.window.clone()));
+        }
+        event_loop.set_control_flow(ControlFlow::Wait);
+    }
+
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        window_id: winit::window::WindowId,
+        event: WindowEvent,
+    ) {
+        // Ignore the event (return from the function) if
+        //   - we have no render_state
+        //   - OR the window id of the event doesn't match the window id of our render_state
+        //
+        // Else extract a mutable reference to the render state from its containing option for use below
+        let render_state = match &mut self.state {
+            RenderState::Active(state) if state.window.id() == window_id => state,
+            _ => return,
+        };
+
+        self.editor.handle_event(&event);
+        render_state.window.request_redraw();
+        // render_state
+        //     .window
+        //     .set_cursor(winit::window::Cursor::Icon(winit::window::CursorIcon::Text));
+
+        match event {
+            // Exit the event loop when a close is requested (e.g. window's close button is pressed)
+            WindowEvent::CloseRequested => event_loop.exit(),
+
+            // Resize the surface when the window is resized
+            WindowEvent::Resized(size) => {
+                self.context
+                    .resize_surface(&mut render_state.surface, size.width, size.height);
+                render_state.window.request_redraw();
+                self.editor.update_layout(size.width as _, 1.0);
+            }
+
+            // This is where all the rendering happens
+            WindowEvent::RedrawRequested => {
+                // Empty the scene of objects to draw. You could create a new Scene each time, but in this case
+                // the same Scene is reused so that the underlying memory allocation can also be reused.
+                self.scene.reset();
+
+                self.editor.draw(&mut self.scene);
+                // Re-add the objects to draw to the scene.
+                //                add_shapes_to_scene(&mut self.scene);
+
+                // Get the RenderSurface (surface + config)
+                let surface = &render_state.surface;
+
+                // Get the window size
+                let width = surface.config.width;
+                let height = surface.config.height;
+
+                // Get a handle to the device
+                let device_handle = &self.context.devices[surface.dev_id];
+
+                // Get the surface's texture
+                let surface_texture = surface
+                    .surface
+                    .get_current_texture()
+                    .expect("failed to get surface texture");
+
+                // Render to the surface's texture
+                self.renderers[surface.dev_id]
+                    .as_mut()
+                    .unwrap()
+                    .render_to_surface(
+                        &device_handle.device,
+                        &device_handle.queue,
+                        &self.scene,
+                        &surface_texture,
+                        &vello::RenderParams {
+                            base_color: Color::rgb8(30, 30, 30), // Background color
+                            width,
+                            height,
+                            antialiasing_method: AaConfig::Msaa16,
+                        },
+                    )
+                    .expect("failed to render to surface");
+
+                // Queue the texture to be presented on the surface
+                surface_texture.present();
+
+                device_handle.device.poll(wgpu::Maintain::Poll);
+            }
+            _ => {}
+        }
+    }
+}
+
+fn main() -> Result<()> {
+    // Setup a bunch of state:
+    let mut app = SimpleVelloApp {
+        context: RenderContext::new(),
+        renderers: vec![],
+        state: RenderState::Suspended(None),
+        scene: Scene::new(),
+        editor: text::Editor::default(),
+    };
+
+    app.editor.set_text(text::LOREM);
+
+    // Create and run a winit event loop
+    let event_loop = EventLoop::new()?;
+    event_loop
+        .run_app(&mut app)
+        .expect("Couldn't run event loop");
+    Ok(())
+}
+
+/// Helper function that creates a Winit window and returns it (wrapped in an Arc for sharing between threads)
+fn create_winit_window(event_loop: &ActiveEventLoop) -> Arc<Window> {
+    let attr = Window::default_attributes()
+        .with_inner_size(LogicalSize::new(1044, 800))
+        .with_resizable(true)
+        .with_title("Vello Text Editor");
+    Arc::new(event_loop.create_window(attr).unwrap())
+}
+
+/// Helper function that creates a vello `Renderer` for a given `RenderContext` and `RenderSurface`
+fn create_vello_renderer(render_cx: &RenderContext, surface: &RenderSurface) -> Renderer {
+    Renderer::new(
+        &render_cx.devices[surface.dev_id].device,
+        RendererOptions {
+            surface_format: Some(surface.format),
+            use_cpu: false,
+            antialiasing_support: vello::AaSupport::all(),
+            num_init_threads: NonZeroUsize::new(1),
+        },
+    )
+    .expect("Couldn't create renderer")
+}