Update smithay to latest commit

Cargo.lock

@@ -4506,7 +4506,7 @@ checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
 [[package]]
 name = "smithay"
 version = "0.3.0"
-source = "git+https://github.com/smithay//smithay?rev=f133e418#f133e418a25b1dfa4520000e08d3c6f548f4f58a"
+source = "git+https://github.com/smithay//smithay?rev=ba0121a#ba0121aaed065c30ee4c42834126cce481cb0e57"
 dependencies = [
  "appendlist",
  "ash",

Cargo.toml

@@ -118,4 +118,4 @@ inherits = "release"
 lto = "fat"
 
 [patch."https://github.com/Smithay/smithay.git"]
-smithay = {git = "https://github.com/smithay//smithay", rev = "f133e418"}
+smithay = {git = "https://github.com/smithay//smithay", rev = "ba0121a"}

src/backend/kms/mod.rs

@@ -1268,6 +1268,7 @@ impl Surface {
                     elements.truncate(old_len);
                 }
 
+                let res = res.map(|(a, b)| (a.cloned(), b));
                 std::mem::drop(damage_tracking);
                 (session, frame, res)
             })
@@ -1295,7 +1296,7 @@ impl Surface {
 
                 if frame_result.needs_sync() {
                     if let PrimaryPlaneElement::Swapchain(elem) = &frame_result.primary_element {
-                        elem.sync.wait();
+                        elem.sync.wait()?;
                     }
                 }
 
@@ -1404,7 +1405,13 @@ impl Surface {
 
                             let transform = self.output.current_transform();
 
-                            match submit_buffer(frame, &mut renderer, transform, damage, sync) {
+                            match submit_buffer(
+                                frame,
+                                &mut renderer,
+                                transform,
+                                damage.as_deref(),
+                                sync,
+                            ) {
                                 Ok(Some((frame, damage))) => {
                                     if frame_result.is_empty {
                                         frame.success(transform, damage, state.clock.now());

src/backend/render/element.rs

@@ -8,7 +8,7 @@ use smithay::{
             Element, Id, RenderElement, UnderlyingStorage,
         },
         glow::{GlowFrame, GlowRenderer},
-        utils::CommitCounter,
+        utils::{CommitCounter, DamageSet},
         Frame, ImportAll, ImportMem, Renderer,
     },
     utils::{Buffer as BufferCoords, Logical, Physical, Point, Rectangle, Scale},
@@ -116,7 +116,7 @@ where
         &self,
         scale: Scale<f64>,
         commit: Option<CommitCounter>,
-    ) -> Vec<Rectangle<i32, Physical>> {
+    ) -> DamageSet<i32, Physical> {
         match self {
             CosmicElement::Workspace(elem) => elem.damage_since(scale, commit),
             CosmicElement::Cursor(elem) => elem.damage_since(scale, commit),
@@ -374,11 +374,11 @@ impl Element for DamageElement {
         &self,
         scale: Scale<f64>,
         _commit: Option<CommitCounter>,
-    ) -> Vec<Rectangle<i32, Physical>> {
+    ) -> DamageSet<i32, Physical> {
-        vec![Rectangle::from_loc_and_size(
+        DamageSet::from_slice(&[Rectangle::from_loc_and_size(
             (0, 0),
             self.geometry(scale).size,
-        )]
+        )])
     }
 }
 

src/backend/render/mod.rs

@@ -938,17 +938,17 @@ where
 }
 
 #[profiling::function]
-pub fn render_output<R, Target, OffTarget>(
+pub fn render_output<'d, R, Target, OffTarget>(
     gpu: Option<&DrmNode>,
     renderer: &mut R,
     target: Target,
-    damage_tracker: &mut OutputDamageTracker,
+    damage_tracker: &'d mut OutputDamageTracker,
     age: usize,
     state: &mut Common,
     output: &Output,
     cursor_mode: CursorMode,
     fps: Option<&mut Fps>,
-) -> Result<RenderOutputResult, RenderError<R>>
+) -> Result<RenderOutputResult<'d>, RenderError<R>>
 where
     R: Renderer
         + ImportAll
@@ -1058,7 +1058,7 @@ where
                                     .bind(render_buffer)
                                     .map_err(RenderError::Rendering)?;
                             }
-                            for rect in damage {
+                            for rect in damage.iter() {
                                 renderer
                                     .blit_from(target.clone(), *rect, *rect, TextureFilter::Nearest)
                                     .map_err(RenderError::Rendering)?;
@@ -1083,11 +1083,11 @@ where
 }
 
 #[profiling::function]
-pub fn render_workspace<R, Target, OffTarget>(
+pub fn render_workspace<'d, R, Target, OffTarget>(
     gpu: Option<&DrmNode>,
     renderer: &mut R,
     target: Target,
-    damage_tracker: &mut OutputDamageTracker,
+    damage_tracker: &'d mut OutputDamageTracker,
     age: usize,
     additional_damage: Option<Vec<Rectangle<i32, Logical>>>,
     state: &mut Common,
@@ -1097,7 +1097,7 @@ pub fn render_workspace<R, Target, OffTarget>(
     cursor_mode: CursorMode,
     mut fps: Option<&mut Fps>,
     exclude_workspace_overview: bool,
-) -> Result<(RenderOutputResult, Vec<CosmicElement<R>>), RenderError<R>>
+) -> Result<(RenderOutputResult<'d>, Vec<CosmicElement<R>>), RenderError<R>>
 where
     R: Renderer
         + ImportAll

src/backend/winit.rs

@@ -76,7 +76,7 @@ impl WinitState {
                     .bind()
                     .with_context(|| "Failed to bind display")?;
                 self.backend
-                    .submit(damage.as_deref())
+                    .submit(damage.map(|x| x.as_slice()))
                     .with_context(|| "Failed to submit buffer for display")?;
                 #[cfg(feature = "debug")]
                 self.fps.displayed();

src/shell/element/mod.rs

@@ -19,6 +19,7 @@ use smithay::{
             },
             gles::element::PixelShaderElement,
             glow::GlowRenderer,
+            utils::DamageSet,
             ImportAll, ImportMem, Renderer,
         },
     },
@@ -1146,7 +1147,7 @@ where
         &self,
         scale: Scale<f64>,
         commit: Option<smithay::backend::renderer::utils::CommitCounter>,
-    ) -> Vec<Rectangle<i32, Physical>> {
+    ) -> DamageSet<i32, Physical> {
         match self {
             CosmicMappedRenderElement::Stack(elem) => elem.damage_since(scale, commit),
             CosmicMappedRenderElement::Window(elem) => elem.damage_since(scale, commit),

src/shell/workspace.rs

@@ -31,6 +31,7 @@ use smithay::{
         },
         gles::{GlesError, GlesTexture},
         glow::{GlowFrame, GlowRenderer},
+        utils::DamageSet,
         ImportAll, ImportMem, Renderer,
     },
     desktop::{layer_map_for_output, space::SpaceElement},
@@ -1325,7 +1326,7 @@ where
         &self,
         scale: Scale<f64>,
         commit: Option<smithay::backend::renderer::utils::CommitCounter>,
-    ) -> Vec<Rectangle<i32, smithay::utils::Physical>> {
+    ) -> DamageSet<i32, smithay::utils::Physical> {
         match self {
             WorkspaceRenderElement::OverrideRedirect(elem) => elem.damage_since(scale, commit),
             WorkspaceRenderElement::Fullscreen(elem) => elem.damage_since(scale, commit),

src/wayland/handlers/screencopy/render.rs

@@ -58,7 +58,7 @@ pub fn submit_buffer<R>(
     frame: Frame,
     renderer: &mut R,
     transform: Transform,
-    damage: Option<Vec<Rectangle<i32, Physical>>>,
+    damage: Option<&[Rectangle<i32, Physical>]>,
     sync: SyncPoint,
 ) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, <R as Renderer>::Error>
 where
@@ -141,13 +141,13 @@ pub fn render_session<F, R>(
 ) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, DTError<R>>
 where
     R: ExportMem,
-    F: FnOnce(
+    F: for<'d> FnOnce(
         &WlBuffer,
         &mut R,
-        &mut OutputDamageTracker,
+        &'d mut OutputDamageTracker,
         usize,
         Vec<Rectangle<i32, BufferCoords>>,
-    ) -> Result<RenderOutputResult, DTError<R>>,
+    ) -> Result<RenderOutputResult<'d>, DTError<R>>,
 {
     #[cfg(feature = "debug")]
     puffin::profile_function!();
@@ -165,8 +165,14 @@ where
     );
 
     match res {
-        Ok(result) => submit_buffer(frame, renderer, transform, result.damage, result.sync)
+        Ok(result) => submit_buffer(
-            .map_err(DTError::Rendering),
+            frame,
+            renderer,
+            transform,
+            result.damage.map(|x| x.as_slice()),
+            result.sync,
+        )
+        .map_err(DTError::Rendering),
         Err(err) => {
             frame.fail(FailureReason::Unknown);
             Err(err)
@@ -214,17 +220,17 @@ pub fn render_workspace_to_buffer(
         return;
     }
 
-    fn render_fn<R>(
+    fn render_fn<'d, R>(
         buffer: &WlBuffer,
         renderer: &mut R,
-        dt: &mut OutputDamageTracker,
+        dt: &'d mut OutputDamageTracker,
         age: usize,
         additional_damage: Vec<Rectangle<i32, BufferCoords>>,
         draw_cursor: bool,
         common: &mut Common,
         output: &Output,
         handle: (WorkspaceHandle, usize),
-    ) -> Result<RenderOutputResult, DTError<R>>
+    ) -> Result<RenderOutputResult<'d>, DTError<R>>
     where
         R: Renderer
             + ImportAll
@@ -475,17 +481,17 @@ pub fn render_window_to_buffer(
         return;
     }
 
-    fn render_fn<R>(
+    fn render_fn<'d, R>(
         buffer: &WlBuffer,
         renderer: &mut R,
-        dt: &mut OutputDamageTracker,
+        dt: &'d mut OutputDamageTracker,
         age: usize,
         additional_damage: Vec<Rectangle<i32, BufferCoords>>,
         draw_cursor: bool,
         common: &mut Common,
         window: &CosmicSurface,
         geometry: Rectangle<i32, Logical>,
-    ) -> Result<RenderOutputResult, DTError<R>>
+    ) -> Result<RenderOutputResult<'d>, DTError<R>>
     where
         R: Renderer
             + ImportAll
@@ -734,15 +740,15 @@ pub fn render_cursor_to_buffer(
         return;
     }
 
-    fn render_fn<R>(
+    fn render_fn<'d, R>(
         buffer: &WlBuffer,
         renderer: &mut R,
-        dt: &mut OutputDamageTracker,
+        dt: &'d mut OutputDamageTracker,
         age: usize,
         additional_damage: Vec<Rectangle<i32, BufferCoords>>,
         common: &mut Common,
         seat: &Seat<State>,
-    ) -> Result<RenderOutputResult, DTError<R>>
+    ) -> Result<RenderOutputResult<'d>, DTError<R>>
     where
         R: Renderer
             + ImportAll

src/wayland/handlers/tablet_manager.rs

@@ -1,6 +1,15 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use crate::state::State;
-use smithay::delegate_tablet_manager;
+use smithay::{
+    backend::input::TabletToolDescriptor, delegate_tablet_manager,
+    input::pointer::CursorImageStatus, wayland::tablet_manager::TabletSeatHandler,
+};
+
+impl TabletSeatHandler for State {
+    fn tablet_tool_image(&mut self, _tool: &TabletToolDescriptor, _image: CursorImageStatus) {
+        // TODO display cursor for each tablet tool
+    }
+}
 
 delegate_tablet_manager!(State);