wip: animations via frame event

Author: wash2

examples/sctk_todos/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 publish = false
 
 [dependencies]
-iced = { path = "../..", default-features=false, features = ["async-std", "wayland", "debug", "image"] }
+iced = { path = "../..", default-features=false, features = ["async-std", "wayland", "debug", "a11y"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 once_cell = "1.15"
@@ -29,3 +29,5 @@ assets = [
     ["target/release-opt/todos", "usr/bin/iced-todos", "755"],
     ["iced-todos.desktop", "usr/share/applications/", "644"],
 ]
+[profile.release-opt]
+debug = true

examples/todos/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 publish = false
 
 [dependencies]
-iced = { path = "../..", features = ["async-std", "debug"] }
+iced = { path = "../..", features = ["async-std", "debug", "a11y"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 once_cell = "1.15"

runtime/src/window.rs

@@ -19,12 +19,9 @@ use crate::futures::subscription::{self, Subscription};
 /// animations without missing any frames.
 pub fn frames() -> Subscription<(Id, Instant)> {
     subscription::raw_events(|event, _status| match event {
-        iced_core::Event::Window(id, Event::RedrawRequested(at))
-        | iced_core::Event::PlatformSpecific(
-            iced_core::event::PlatformSpecific::Wayland(
-                iced_core::event::wayland::Event::Frame(at, _, id),
-            ),
-        ) => Some((id, at)),
+        iced_core::Event::Window(id, Event::RedrawRequested(at)) => {
+            Some((id, at))
+        }
         _ => None,
     })
 }

sctk/src/application.rs

@@ -5,10 +5,12 @@ use crate::{
     commands::{layer_surface::get_layer_surface, window::get_window},
     dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize},
     error::{self, Error},
-    event_loop::{control_flow::ControlFlow, proxy, SctkEventLoop},
+    event_loop::{
+        control_flow::ControlFlow, proxy, state::SctkState, SctkEventLoop,
+    },
     sctk_event::{
         DataSourceEvent, IcedSctkEvent, KeyboardEventVariant,
-        LayerSurfaceEventVariant, PopupEventVariant, SctkEvent,
+        LayerSurfaceEventVariant, PopupEventVariant, SctkEvent, StartCause,
     },
     settings,
 };
@@ -40,7 +42,7 @@ use iced_futures::{
 use tracing::error;
 
 use sctk::{
-    reexports::client::{protocol::wl_surface::WlSurface, Proxy},
+    reexports::client::{protocol::wl_surface::WlSurface, Proxy, QueueHandle},
     seat::{keyboard::Modifiers, pointer::PointerEventKind},
 };
 use std::{collections::HashMap, ffi::c_void, hash::Hash, marker::PhantomData};
@@ -251,6 +253,7 @@ where
 
     // let (display, context, config, surface) = init_egl(&wl_surface, 100, 100);
     let backend = event_loop.state.connection.backend();
+    let qh = event_loop.state.queue_handle.clone();
     let wrapper = SurfaceDisplayWrapper::<C> {
         comp_surface: None,
         backend: backend.clone(),
@@ -266,6 +269,7 @@ where
     let surface_ids = Default::default();
 
     let (mut sender, receiver) = mpsc::unbounded::<IcedSctkEvent<A::Message>>();
+    let (control_sender, mut control_receiver) = mpsc::unbounded();
 
     let compositor_surfaces = HashMap::new();
     let mut instance = Box::pin(run_instance::<A, E, C>(
@@ -276,6 +280,7 @@ where
         ev_proxy,
         debug,
         receiver,
+        control_sender,
         compositor_surfaces,
         surface_ids,
         auto_size_surfaces,
@@ -285,6 +290,7 @@ where
         backend,
         init_command,
         exit_on_close_request,
+        qh,
     ));
 
     let mut context = task::Context::from_waker(task::noop_waker_ref());
@@ -294,12 +300,18 @@ where
             return;
         }
 
-        sender.start_send(event).expect("Send event");
+        sender.start_send(event).expect("Failed to send event");
 
         let poll = instance.as_mut().poll(&mut context);
 
         *control_flow = match poll {
-            task::Poll::Pending => ControlFlow::Wait,
+            task::Poll::Pending => {
+                if let Ok(Some(flow)) = control_receiver.try_next() {
+                    flow
+                } else {
+                    ControlFlow::Wait
+                }
+            }
             task::Poll::Ready(_) => ControlFlow::ExitWithCode(1),
         };
     });
@@ -326,12 +338,14 @@ async fn run_instance<A, E, C>(
     mut ev_proxy: proxy::Proxy<Event<A::Message>>,
     mut debug: Debug,
     mut receiver: mpsc::UnboundedReceiver<IcedSctkEvent<A::Message>>,
+    mut control_sender: mpsc::UnboundedSender<ControlFlow>,
     mut compositor_surfaces: HashMap<SurfaceId, SurfaceDisplayWrapper<C>>,
     mut surface_ids: HashMap<ObjectId, SurfaceIdWrapper>,
     mut auto_size_surfaces: HashMap<SurfaceIdWrapper, (u32, u32, Limits, bool)>,
     backend: wayland_backend::client::Backend,
     init_command: Command<A::Message>,
     _exit_on_close_request: bool, // TODO Ashley
+    queue_handle: QueueHandle<SctkState<<A as Program>::Message>>,
 ) -> Result<(), Error>
 where
     A: Application + 'static,
@@ -381,6 +395,8 @@ where
     let mut messages: Vec<A::Message> = Vec::new();
     #[cfg(feature = "a11y")]
     let mut commands: Vec<Command<A::Message>> = Vec::new();
+    let mut redraw_pending = false;
+
     debug.startup_finished();
 
     // let mut current_context_window = init_id_inner;
@@ -393,7 +409,14 @@ where
 
     'main: while let Some(event) = receiver.next().await {
         match event {
-            IcedSctkEvent::NewEvents(_) => {} // TODO Ashley: Seems to be ignored in iced_winit so i'll ignore for now
+            IcedSctkEvent::NewEvents(start_cause) => {
+                redraw_pending = matches!(
+                    start_cause,
+                    StartCause::Init
+                        | StartCause::Poll
+                        | StartCause::ResumeTimeReached { .. }
+                );
+            }
             IcedSctkEvent::UserEvent(message) => {
                 messages.push(message);
             }
@@ -679,9 +702,10 @@ where
                     }
                     SctkEvent::Frame(surface) => {
                         if let Some(id) = surface_ids.get(&surface.id()) {
-                            runtime.broadcast(CoreEvent::PlatformSpecific(
-                                PlatformSpecific::Wayland(WaylandEvent::Frame(Instant::now(), surface, id.inner()))
-                            ), Status::Ignored);
+                            if let Some(state) = states.get_mut(&id.inner()) {
+                                // TODO set this to the callback?
+                                state.set_frame(Some(surface));
+                            }
                         }
                     },
                     SctkEvent::ScaleFactorChanged { .. } => {}
@@ -873,16 +897,18 @@ where
                         break 'main;
                     }
                 } else {
-                    // TODO ensure that the surface_ids are
-                    let mut needs_redraw = false;
                     for (object_id, surface_id) in &surface_ids {
                         if matches!(surface_id, SurfaceIdWrapper::Dnd(_)) {
                             continue;
                         }
+                        let state = match states.get_mut(&surface_id.inner()) {
+                            Some(s) => s,
+                            None => continue,
+                        };
                         let mut filtered_sctk =
                             Vec::with_capacity(sctk_events.len());
-
                         let mut i = 0;
+
                         while i < sctk_events.len() {
                             let has_kbd_focus =
                                 kbd_surface_id.as_ref() == Some(object_id);
@@ -897,12 +923,7 @@ where
                             }
                         }
                         let has_events = !sctk_events.is_empty();
-
-                        let cursor_position =
-                            match states.get(&surface_id.inner()) {
-                                Some(s) => s.cursor(),
-                                None => continue,
-                            };
+                        let cursor_position = state.cursor();
                         debug.event_processing_started();
                         #[allow(unused_mut)]
                         let mut native_events: Vec<_> = filtered_sctk
@@ -966,11 +987,6 @@ where
                             auto_size_surfaces.remove(surface_id)
                         {
                             if dirty {
-                                let state =
-                                    match states.get_mut(&surface_id.inner()) {
-                                        Some(s) => s,
-                                        None => continue,
-                                    };
                                 state.set_logical_size(w as f64, h as f64);
                                 match surface_id {
                                     SurfaceIdWrapper::Window(id) => {
@@ -990,22 +1006,18 @@ where
                         }
 
                         // TODO ASHLEY if event is a configure which isn't a new size and has no other changes, don't redraw
-                        if has_events
+                        if redraw_pending
+                            || has_events
                             || !messages.is_empty()
                             || matches!(
                                 interface_state,
                                 user_interface::State::Outdated
                             )
                         {
-                            needs_redraw = true;
-                            ev_proxy.send_event(Event::SctkEvent(
-                                IcedSctkEvent::RedrawRequested(
-                                    object_id.clone(),
-                                ),
-                            ));
+                            state.set_needs_redraw(true);
                         }
                     }
-                    if needs_redraw {
+                    if states.iter().any(|(_, s)| s.needs_redraw) {
                         let mut pure_states: HashMap<_, _> =
                             ManuallyDrop::into_inner(interfaces)
                                 .drain()
@@ -1017,7 +1029,13 @@ where
                         for surface_id in surface_ids.values() {
                             let state =
                                 match states.get_mut(&surface_id.inner()) {
-                                    Some(s) => s,
+                                    Some(s) => {
+                                        if !s.needs_redraw() {
+                                            continue;
+                                        } else {
+                                            s
+                                        }
+                                    }
                                     None => continue,
                                 };
                             let mut cache =
@@ -1058,6 +1076,84 @@ where
                             &mut auto_size_surfaces,
                             &mut ev_proxy,
                         ));
+
+                        for (object_id, surface_id) in &surface_ids {
+                            let state = match states
+                                .get_mut(&surface_id.inner())
+                            {
+                                Some(s) => {
+                                    if !s.needs_redraw() || s.frame().is_none()
+                                    {
+                                        continue;
+                                    } else {
+                                        s
+                                    }
+                                }
+                                None => continue,
+                            };
+                            let Some(user_interface) = interfaces
+                                .get_mut(&surface_id.inner()) else {
+                                    continue;
+                                };
+                            let redraw_event = CoreEvent::Window(
+                                surface_id.inner(),
+                                crate::core::window::Event::RedrawRequested(
+                                    Instant::now(),
+                                ),
+                            );
+
+                            let (interface_state, _) = user_interface.update(
+                                &[redraw_event.clone()],
+                                state.cursor(),
+                                &mut renderer,
+                                &mut simple_clipboard,
+                                &mut messages,
+                            );
+
+                            debug.draw_started();
+                            let new_mouse_interaction = user_interface.draw(
+                                &mut renderer,
+                                state.theme(),
+                                &Style {
+                                    text_color: state.text_color(),
+                                },
+                                state.cursor(),
+                            );
+                            debug.draw_finished();
+
+                            if new_mouse_interaction != mouse_interaction {
+                                mouse_interaction = new_mouse_interaction;
+                                ev_proxy.send_event(Event::SetCursor(
+                                    mouse_interaction,
+                                ));
+                            }
+
+                            runtime.broadcast(redraw_event, Status::Ignored);
+
+                            ev_proxy.send_event(Event::SctkEvent(
+                                IcedSctkEvent::RedrawRequested(
+                                    object_id.clone(),
+                                ),
+                            ));
+
+                            let _ =
+                                control_sender
+                                    .start_send(match interface_state {
+                                    user_interface::State::Updated {
+                                        redraw_request: Some(redraw_request),
+                                    } => match redraw_request {
+                                        crate::core::window::RedrawRequest::NextFrame => {
+                                            ControlFlow::Poll
+                                        }
+                                        crate::core::window::RedrawRequest::At(at) => {
+                                            ControlFlow::WaitUntil(at)
+                                        }
+                                    },
+                                    _ => ControlFlow::Wait,
+                                });
+                            state.set_needs_redraw(false);
+                            redraw_pending = false;
+                        }
                     }
                 }
                 sctk_events.clear();
@@ -1079,6 +1175,14 @@ where
                     let state = states.get_mut(&id.inner());
                     Some((*id, surface, interface, state))
                 }) {
+                    // request a new frame
+                    // NOTE Ashley: this is done here only after a redraw
+                    // to prevent more events from being produced after repeatedly requesting redraws
+                    if let Some(surface) = state.frame.take() {
+                        surface.frame(&queue_handle, surface.clone());
+                        surface.commit();
+                    }
+
                     debug.render_started();
                     #[cfg(feature = "a11y")]
                     if let Some(Some(adapter)) = a11y_enabled
@@ -1387,6 +1491,8 @@ where
     theme: <A::Renderer as Renderer>::Theme,
     appearance: application::Appearance,
     application: PhantomData<A>,
+    frame: Option<WlSurface>,
+    needs_redraw: bool,
 }
 
 impl<A: Application> State<A>
@@ -1414,9 +1520,27 @@ where
             theme,
             appearance,
             application: PhantomData,
+            frame: None,
+            needs_redraw: false,
         }
     }
 
+    pub(crate) fn set_needs_redraw(&mut self, needs_redraw: bool) {
+        self.needs_redraw = needs_redraw;
+    }
+
+    pub(crate) fn needs_redraw(&self) -> bool {
+        self.needs_redraw
+    }
+
+    pub(crate) fn set_frame(&mut self, frame: Option<WlSurface>) {
+        self.frame = frame;
+    }
+
+    pub(crate) fn frame(&self) -> Option<&WlSurface> {
+        self.frame.as_ref()
+    }
+
     /// Returns the current [`Viewport`] of the [`State`].
     pub fn viewport(&self) -> &Viewport {
         &self.viewport