tiling: Animate tree changes

src/shell/layout/floating/grabs/moving.rs

@@ -68,6 +68,7 @@ impl MoveGrabState {
                     renderer,
                     Rectangle::from_loc_and_size(render_location, self.window.geometry().size),
                     self.indicator_thickness,
+                    1.0,
                 ))
                 .into(),
             );
@@ -77,6 +78,7 @@ impl MoveGrabState {
             renderer,
             (render_location - self.window.geometry().loc).to_physical_precise_round(scale),
             scale,
+            1.0,
         ));
         elements
     }
@@ -266,7 +268,7 @@ impl MoveSurfaceGrab {
                     .active_space_mut(&output)
                     .floating_layer
                     .map_internal(grab_state.window, &output, Some(window_location + offset));
-                
+
                 let pointer_pos = handle.current_location();
                 let relative_pos = state.common.shell.map_global_to_space(pointer_pos, &output);
                 Some(window_location + offset + (pointer_pos - relative_pos).to_i32_round())
@@ -282,7 +284,10 @@ impl MoveSurfaceGrab {
             if let Some(position) = position {
                 handle.motion(
                     state,
-                    Some((PointerFocusTarget::from(self.window.clone()), position - self.window.geometry().loc)),
+                    Some((
+                        PointerFocusTarget::from(self.window.clone()),
+                        position - self.window.geometry().loc,
+                    )),
                     &MotionEvent {
                         location: handle.current_location(),
                         serial: serial,

src/shell/layout/floating/mod.rs

@@ -374,6 +374,7 @@ impl FloatingLayout {
                     renderer,
                     render_location.to_physical_precise_round(output_scale),
                     output_scale.into(),
+                    1.0,
                 );
                 if focused == Some(elem) {
                     if indicator_thickness > 0 {
@@ -384,6 +385,7 @@ impl FloatingLayout {
                                 elem.geometry().size,
                             ),
                             indicator_thickness,
+                            1.0,
                         );
                         elements.insert(0, element.into());
                     }

src/shell/layout/tiling/blocker.rs

@@ -0,0 +1,65 @@
+use crate::{
+    shell::element::CosmicSurface, state::Data,
+    wayland::handlers::compositor::client_compositor_state,
+};
+use calloop::LoopHandle;
+use smithay::{
+    reexports::wayland_server::{backend::ClientId, Client, Resource},
+    utils::Serial,
+    wayland::{
+        compositor::{Blocker, BlockerState},
+        seat::WaylandFocus,
+    },
+};
+use std::{
+    collections::HashMap,
+    time::{Duration, Instant},
+};
+
+#[derive(Debug, Clone)]
+pub struct TilingBlocker {
+    pub necessary_acks: Vec<(CosmicSurface, Serial)>,
+    start: Instant,
+}
+
+impl Blocker for TilingBlocker {
+    fn state(&self) -> BlockerState {
+        if self.is_ready() {
+            BlockerState::Released
+        } else {
+            BlockerState::Pending
+        }
+    }
+}
+
+impl TilingBlocker {
+    pub fn new(configures: impl IntoIterator<Item = (CosmicSurface, Serial)>) -> Self {
+        TilingBlocker {
+            necessary_acks: configures.into_iter().collect(),
+            start: Instant::now(),
+        }
+    }
+
+    pub fn is_ready(&self) -> bool {
+        Instant::now().duration_since(self.start) >= Duration::from_millis(200)
+            || self
+                .necessary_acks
+                .iter()
+                .all(|(surf, serial)| surf.serial_acked(serial))
+    }
+
+    pub fn signal_ready(&self, handle: &LoopHandle<'static, Data>) {
+        let clients = self
+            .necessary_acks
+            .iter()
+            .flat_map(|(surface, _)| surface.wl_surface().and_then(|s| s.client()))
+            .map(|client| (client.id(), client))
+            .collect::<HashMap<ClientId, Client>>();
+        handle.insert_idle(move |data| {
+            let dh = data.display.handle();
+            for client in clients.values() {
+                client_compositor_state(&client).blocker_cleared(&mut data.state, &dh);
+            }
+        });
+    }
+}

src/shell/layout/tiling/grabs.rs

@@ -64,7 +64,8 @@ impl PointerGrab<State> for ResizeForkGrab {
 
         if let Some(output) = self.output.upgrade() {
             let tiling_layer = &mut data.common.shell.active_space_mut(&output).tiling_layer;
-            if let Some(tree) = tiling_layer.trees.get_mut(&output) {
+            if let Some(queue) = tiling_layer.queues.get_mut(&output) {
+                let tree = &mut queue.trees.back_mut().unwrap().0;
                 if tree.get(&self.node).is_ok() {
                     let orientation = tree.get(&self.node).unwrap().data().orientation();
                     let delta = match orientation {