Cargo.toml

@@ -1,10 +1,7 @@
 [package]
 name = "smithay-clipboard"
 version = "0.8.0"
-authors = [
-    "Kirill Chibisov <contact@kchibisov.com>",
-    "Victor Berger <victor.berger@m4x.org>",
-]
+authors = ["Kirill Chibisov <contact@kchibisov.com>", "Victor Berger <victor.berger@m4x.org>"]
 edition = "2021"
 description = "Provides access to the wayland clipboard for client applications."
 repository = "https://github.com/smithay/smithay-clipboard"
@@ -15,25 +12,16 @@ rust-version = "1.65.0"
 
 [dependencies]
 libc = "0.2.149"
-sctk = { package = "smithay-client-toolkit", version = "0.20", default-features = false, features = [
-    "calloop",
-] }
-wayland-backend = { version = "0.3.3", default_features = false, features = [
-    "client_system",
-] }
-raw-window-handle = { version = "0.6", optional = true }
+sctk = { package = "smithay-client-toolkit", git = "https://github.com/Smithay/client-toolkit", default-features = false, features = ["calloop"] }
+wayland-backend = { version = "0.3.3", default_features = false, features = ["client_system"] }
 
 [dev-dependencies]
 dirs = "5.0.1"
-sctk = { package = "smithay-client-toolkit", version = "0.20", default-features = false, features = [
-    "calloop",
-    "xkbcommon",
-] }
+sctk = { package = "smithay-client-toolkit", git = "https://github.com/Smithay/client-toolkit", default-features = false, features = ["calloop", "xkbcommon"] }
 thiserror = "1.0.57"
 url = "2.5.0"
 
 [features]
-default = ["dlopen", "dnd", "rwh-6"]
-rwh-6 = ["raw-window-handle"]
+default = ["dlopen", "dnd"]
 dnd = []
-dlopen = ["wayland-backend/dlopen"]
+dlopen = ["wayland-backend/dlopen" ]

examples/clipboard.rs

@@ -30,7 +30,7 @@ use sctk::{
     delegate_compositor, delegate_keyboard, delegate_output, delegate_pointer, delegate_registry,
     delegate_seat, delegate_shm, delegate_xdg_shell, delegate_xdg_window, registry_handlers,
 };
-use smithay_clipboard::dnd::{DndDestinationRectangle, Icon, OfferEvent, Rectangle, SourceEvent};
+use smithay_clipboard::dnd::{DndDestinationRectangle, OfferEvent, Rectangle, SourceEvent};
 use smithay_clipboard::mime::{AllowedMimeTypes, AsMimeTypes, MimeType, ALLOWED_TEXT_MIME_TYPES};
 use smithay_clipboard::{Clipboard, SimpleClipboard};
 use thiserror::Error;
@@ -88,9 +88,9 @@ fn main() {
             smithay_clipboard::dnd::DndEvent::Offer(id, OfferEvent::Motion { x, y }) => {
                 if id != state.offer_hover_id {
                     state.offer_hover_id = id;
-                    if let Ok(data) =
-                        state.clipboard.peek_offer::<smithay_clipboard::text::Text>(None)
-                    {
+                    if let Ok(data) = state.clipboard.peek_offer::<smithay_clipboard::text::Text>(
+                        MimeType::Text(smithay_clipboard::mime::Text::TextPlain),
+                    ) {
                         println!("Peeked the data: {}", data.0);
                     }
                 }
@@ -116,10 +116,9 @@ fn main() {
             smithay_clipboard::dnd::DndEvent::Offer(id, OfferEvent::Enter { mime_types, .. }) => {
                 println!("Received DnD Enter for {id:?}");
                 state.offer_hover_id = id;
-                if let Some(mime) = mime_types.first() {
-                    if let Ok(data) = state
-                        .clipboard
-                        .peek_offer::<smithay_clipboard::text::Text>(Some(mime.clone()))
+                if let Some(mime) = mime_types.get(0) {
+                    if let Ok(data) =
+                        state.clipboard.peek_offer::<smithay_clipboard::text::Text>(mime.clone())
                     {
                         println!("Peeked the data: {}", data.0);
                     }
@@ -265,24 +264,6 @@ impl CompositorHandler for SimpleWindow {
     ) {
         self.draw(conn, qh);
     }
-
-    fn surface_enter(
-        &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        _surface: &wl_surface::WlSurface,
-        _output: &wl_output::WlOutput,
-    ) {
-    }
-
-    fn surface_leave(
-        &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        _surface: &wl_surface::WlSurface,
-        _output: &wl_output::WlOutput,
-    ) {
-    }
 }
 
 impl OutputHandler for SimpleWindow {
@@ -409,33 +390,21 @@ impl PointerHandler for SimpleWindow {
             match &e.kind {
                 PointerEventKind::Press { button, .. } if *button == BTN_LEFT => {
                     println!("Starting a drag!");
-
                     self.clipboard.start_dnd(
                         false,
                         self.window.wl_surface().clone(),
-                        Some(Icon::Buf {
-                            width: 256,
-                            height: 256,
-                            data: vec![0x99; 256 * 256 * 4],
-                            transparent: true,
-                        }),
+                        None,
                         smithay_clipboard::text::Text("Clipboard Drag and Drop!".to_string()),
                         DndAction::all(),
                     );
                 },
                 PointerEventKind::Press { button, .. } if *button == BTN_RIGHT => {
                     println!("Starting an internal drag!");
-
                     self.internal_dnd = true;
                     self.clipboard.start_dnd(
                         true,
                         self.window.wl_surface().clone(),
-                        Some(Icon::Buf {
-                            width: 256,
-                            height: 256,
-                            data: vec![0xFF; 256 * 256 * 4],
-                            transparent: true,
-                        }),
+                        None,
                         smithay_clipboard::text::Text(
                             "Internal clipboard Drag and Drop!".to_string(),
                         ),
@@ -556,25 +525,14 @@ impl KeyboardHandler for SimpleWindow {
     ) {
     }
 
-    fn repeat_key(
-        &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        _keyboard: &wl_keyboard::WlKeyboard,
-        _serial: u32,
-        _event: KeyEvent,
-    ) {
-    }
-
     fn update_modifiers(
         &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        _keyboard: &wl_keyboard::WlKeyboard,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        _: &wl_keyboard::WlKeyboard,
         _serial: u32,
         _modifiers: Modifiers,
-        _raw_modifiers: sctk::seat::keyboard::RawModifiers,
-        _layout: u32,
+        _: u32,
     ) {
     }
 }
@@ -618,7 +576,7 @@ impl SimpleWindow {
         };
 
         // Draw to the window:
-        canvas.chunks_exact_mut(4).for_each(|chunk| {
+        canvas.chunks_exact_mut(4).enumerate().for_each(|(_, chunk)| {
             // ARGB color.
             let color = 0xFF181818u32;
 

src/dnd/mod.rs

@@ -34,16 +34,6 @@ impl<T: RawSurface> DndSurface<T> {
     }
 }
 
-#[cfg(feature = "rwh-6")]
-impl<'a> RawSurface for raw_window_handle::WindowHandle<'a> {
-    unsafe fn get_ptr(&mut self) -> *mut c_void {
-        match self.as_raw() {
-            raw_window_handle::RawWindowHandle::Wayland(handle) => handle.surface.as_ptr().cast(),
-            _ => panic!("Unsupported window handle type."),
-        }
-    }
-}
-
 impl RawSurface for WlSurface {
     unsafe fn get_ptr(&mut self) -> *mut c_void {
         self.id().as_ptr().cast()
@@ -145,7 +135,7 @@ pub enum DndRequest<T> {
     StartDnd {
         internal: bool,
         source: DndSurface<T>,
-        icon: Option<Icon<DndSurface<T>>>,
+        icon: Option<DndSurface<T>>,
         content: Box<dyn AsMimeTypes + Send>,
         actions: DndAction,
     },
@@ -177,17 +167,6 @@ impl<T> Sender<T> for calloop::channel::SyncSender<DndEvent<T>> {
     }
 }
 
-pub enum Icon<S> {
-    Surface(S),
-    /// Argb8888 or Xrgb8888 encoded image data pre-multiplied by alpha.
-    Buf {
-        width: u32,
-        height: u32,
-        data: Vec<u8>,
-        transparent: bool,
-    },
-}
-
 impl<T: RawSurface> Clipboard<T> {
     /// Set up DnD operations for the Clipboard
     pub fn init_dnd(
@@ -202,17 +181,12 @@ impl<T: RawSurface> Clipboard<T> {
         &self,
         internal: bool,
         source_surface: T,
-        icon_surface: Option<Icon<T>>,
+        icon_surface: Option<T>,
         content: D,
         actions: DndAction,
     ) {
         let source = DndSurface::new(source_surface, &self.connection).unwrap();
-        let icon = icon_surface.map(|i| match i {
-            Icon::Surface(s) => Icon::Surface(DndSurface::new(s, &self.connection).unwrap()),
-            Icon::Buf { width, height, data, transparent } => {
-                Icon::Buf { width, height, data, transparent }
-            },
-        });
+        let icon = icon_surface.map(|s| DndSurface::new(s, &self.connection).unwrap());
         _ = self.request_sender.send(crate::worker::Command::DndRequest(DndRequest::StartDnd {
             internal,
             source,
@@ -229,7 +203,7 @@ impl<T: RawSurface> Clipboard<T> {
 
     /// Register a surface for receiving DnD offers
     /// Rectangles should be provided in order of decreasing priority.
-    /// This method c~an be called multiple time for a single surface if the
+    /// This method can be called multiple time for a single surface if the
     /// rectangles change.
     pub fn register_dnd_destination(&self, surface: T, rectangles: Vec<DndDestinationRectangle>) {
         let s = DndSurface::new(surface, &self.connection).unwrap();
@@ -249,12 +223,8 @@ impl<T: RawSurface> Clipboard<T> {
     /// Peek at the contents of a DnD offer
     pub fn peek_offer<D: AllowedMimeTypes + 'static>(
         &self,
-        mime_type: Option<MimeType>,
+        mime_type: MimeType,
     ) -> std::io::Result<D> {
-        let Some(mime_type) = mime_type.or_else(|| D::allowed().first().cloned()) else {
-            return Err(std::io::Error::new(std::io::ErrorKind::Other, "No mime type provided."));
-        };
-
         self.request_sender
             .send(crate::worker::Command::DndRequest(DndRequest::Peek(mime_type)))
             .map_err(|_| {

src/dnd/state.rs

@@ -9,7 +9,6 @@ use sctk::data_device_manager::WritePipe;
 use sctk::reexports::calloop::PostAction;
 use sctk::reexports::client::protocol::wl_data_device::WlDataDevice;
 use sctk::reexports::client::protocol::wl_data_device_manager::DndAction;
-use sctk::reexports::client::protocol::wl_shm::Format;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::reexports::client::Proxy;
 use wayland_backend::client::ObjectId;
@@ -17,7 +16,7 @@ use wayland_backend::client::ObjectId;
 use crate::mime::{AsMimeTypes, MimeType};
 use crate::state::{set_non_blocking, State};
 
-use super::{DndDestinationRectangle, DndEvent, DndRequest, DndSurface, Icon, OfferEvent};
+use super::{DndDestinationRectangle, DndEvent, DndRequest, DndSurface, OfferEvent};
 
 pub(crate) struct DndState<T> {
     pub(crate) sender: Option<Box<dyn crate::dnd::Sender<T>>>,
@@ -27,7 +26,6 @@ pub(crate) struct DndState<T> {
     source_actions: DndAction,
     selected_action: DndAction,
     selected_mime: Option<MimeType>,
-    pub(crate) icon_surface: Option<WlSurface>,
     pub(crate) source_content: Option<Box<dyn AsMimeTypes>>,
     accept_ctr: u32,
 }
@@ -44,7 +42,6 @@ impl<T> Default for DndState<T> {
             selected_mime: None,
             source_content: None,
             accept_ctr: 1,
-            icon_surface: None,
         }
     }
 }
@@ -52,12 +49,6 @@ impl<T> Default for DndState<T> {
 impl<T> DndState<T> {
     pub(crate) fn selected_action(&mut self, a: DndAction) {
         self.selected_action = a;
-        if let Some(tx) = self.sender.as_ref() {
-            _ = tx.send(DndEvent::Offer(
-                self.active_surface.as_ref().and_then(|(_, d)| d.as_ref().map(|d| d.id)),
-                OfferEvent::SelectedAction(a),
-            ));
-        }
     }
 }
 
@@ -119,37 +110,14 @@ where
                     }
                     return (s.clone(), None);
                 };
-                if !had_dest.is_some_and(|old_id| old_id == dest.id) {
-                    if let (Some((action, preferred_action)), Some(mime_type), Some(dnd_state)) =
-                        (actions, mime, dnd_state.as_ref())
-                    {
-                        if let Some((tx, old_id)) = self.dnd_state.sender.as_ref().zip(had_dest) {
-                            _ = tx.send(DndEvent::Offer(
-                                Some(old_id),
-                                super::OfferEvent::LeaveDestination,
-                            ));
-                        }
-                        if let Some(tx) = self.dnd_state.sender.as_ref() {
-                            _ = tx.send(DndEvent::Offer(Some(dest.id), OfferEvent::Enter {
-                                x,
-                                y,
-                                surface: s.s.clone(),
-                                mime_types: dest.mime_types.clone(),
-                            }));
-
-                            _ = tx.send(DndEvent::Offer(
-                                Some(dest.id),
-                                OfferEvent::SelectedAction(self.dnd_state.selected_action),
-                            ));
-                        }
-                        dnd_state.set_actions(action, preferred_action);
-                        self.dnd_state.selected_mime = Some(mime_type.clone());
-                        dnd_state.accept_mime_type(
-                            self.dnd_state.accept_ctr,
-                            Some(mime_type.to_string()),
-                        );
-                        self.dnd_state.accept_ctr = self.dnd_state.accept_ctr.wrapping_add(1);
-                    }
+                if let (Some((action, preferred_action)), Some(mime_type), Some(dnd_state)) =
+                    (actions, mime, dnd_state.as_ref())
+                {
+                    dnd_state.set_actions(action, preferred_action);
+                    self.dnd_state.selected_mime = Some(mime_type.clone());
+                    dnd_state
+                        .accept_mime_type(self.dnd_state.accept_ctr, Some(mime_type.to_string()));
+                    self.dnd_state.accept_ctr = self.dnd_state.accept_ctr.wrapping_add(1);
                 }
                 (s.clone(), Some(dest))
             });
@@ -241,7 +209,12 @@ where
     }
 
     pub(crate) fn offer_motion(&mut self, x: f64, y: f64, wl_data_device: &WlDataDevice) {
-        let Some(surface) = self.dnd_state.active_surface.clone().map(|(s, _)| s) else {
+        let Some((surface, dest)) = self
+            .dnd_state
+            .active_surface
+            .clone()
+            .map(|(s, dest)| (s, dest.filter(|d| d.rectangle.contains(x, y))))
+        else {
             return;
         };
         let Some(data_device) = self
@@ -256,7 +229,9 @@ where
             // Ignore cancelled internal DnD
             return;
         }
-        self.update_active_surface(&surface.surface, x, y, drag_offer.as_ref());
+        if dest.is_none() {
+            self.update_active_surface(&surface.surface, x, y, drag_offer.as_ref());
+        }
         let id = self.cur_id();
         if let Some(tx) = self.dnd_state.sender.as_ref() {
             _ = tx.send(DndEvent::Offer(id, super::OfferEvent::Motion { x, y }));
@@ -276,11 +251,7 @@ where
         match r {
             DndRequest::InitDnd(sender) => self.dnd_state.sender = Some(sender),
             DndRequest::Surface(s, dests) => {
-                if dests.is_empty() {
-                    self.dnd_state.destinations.remove(&s.surface.id());
-                } else {
-                    self.dnd_state.destinations.insert(s.surface.id(), (s, dests));
-                }
+                self.dnd_state.destinations.insert(s.surface.id(), (s, dests));
             },
             DndRequest::StartDnd { internal, source, icon, content, actions } => {
                 _ = self.start_dnd(internal, source, icon, content, actions);
@@ -289,12 +260,8 @@ where
                 _ = self.user_selected_action(a);
             },
             DndRequest::DndEnd => {
-                if let Some(s) = self.dnd_state.icon_surface.take() {
-                    _ = s.destroy();
-                }
                 self.dnd_state.source_content = None;
                 self.dnd_state.dnd_source = None;
-                self.pool.remove(&0);
             },
             DndRequest::Peek(mime_type) => {
                 if let Err(err) = self.load_dnd(mime_type, true) {
@@ -308,7 +275,7 @@ where
         &mut self,
         internal: bool,
         source_surface: DndSurface<T>,
-        mut icon: Option<Icon<DndSurface<T>>>,
+        icon: Option<DndSurface<T>>,
         content: Box<dyn AsMimeTypes + Send>,
         actions: DndAction,
     ) -> std::io::Result<()> {
@@ -327,36 +294,11 @@ where
             .as_ref()
             .ok_or_else(|| Error::new(ErrorKind::Other, "data device missing"))?;
 
-        let (icon_surface, buffer) = if let Some(i) = icon.take() {
-            match i {
-                Icon::Surface(s) => (Some(s.surface.clone()), None),
-                Icon::Buf { data, width, height, transparent } => {
-                    let surface = self.compositor_state.create_surface(&self.queue_handle);
-                    self.pool.remove(&0);
-                    let (_, wl_buffer, buf) = self
-                        .pool
-                        .create_buffer(
-                            width as i32,
-                            width as i32 * 4,
-                            height as i32,
-                            &0,
-                            if transparent { Format::Argb8888 } else { Format::Xrgb8888 },
-                        )
-                        .map_err(|err| Error::new(ErrorKind::Other, err))?;
-                    buf.copy_from_slice(&data);
-
-                    (Some(surface), Some((wl_buffer, width, height)))
-                },
-            }
-        } else {
-            (None, None)
-        };
-
         if internal {
             DragSource::start_internal_drag(
                 data_device,
                 &source_surface.surface,
-                icon_surface.as_ref(),
+                icon.as_ref().map(|s| &s.surface),
                 serial,
             )
         } else {
@@ -372,21 +314,17 @@ where
                     )
                 })
                 .ok_or_else(|| Error::new(ErrorKind::Other, "data device manager missing"))?;
-            source.start_drag(data_device, &source_surface.surface, icon_surface.as_ref(), serial);
-
+            source.start_drag(
+                data_device,
+                &source_surface.surface,
+                icon.as_ref().map(|s| &s.surface),
+                serial,
+            );
             self.dnd_state.dnd_source = Some(source);
             self.dnd_state.source_content = Some(content);
             self.dnd_state.source_actions = actions;
         }
 
-        if let (Some((wl_buffer, width, height)), Some(surface)) = (buffer, icon_surface) {
-            surface.damage_buffer(0, 0, width as i32, height as i32);
-            surface.attach(Some(wl_buffer), 0, 0);
-            surface.commit();
-
-            self.dnd_state.icon_surface = Some(surface);
-        }
-
         Ok(())
     }
 

src/state.rs

@@ -7,25 +7,20 @@ use std::os::unix::io::{AsRawFd, RawFd};
 use std::rc::Rc;
 use std::sync::mpsc::Sender;
 
-use sctk::compositor::{CompositorHandler, CompositorState};
 use sctk::data_device_manager::data_device::{DataDevice, DataDeviceHandler};
 use sctk::data_device_manager::data_offer::{DataOfferError, DataOfferHandler, DragOffer};
 use sctk::data_device_manager::data_source::{CopyPasteSource, DataSourceHandler};
 use sctk::data_device_manager::{DataDeviceManagerState, WritePipe};
-use sctk::output::{OutputHandler, OutputState};
 use sctk::primary_selection::device::{PrimarySelectionDevice, PrimarySelectionDeviceHandler};
 use sctk::primary_selection::selection::{PrimarySelectionSource, PrimarySelectionSourceHandler};
 use sctk::primary_selection::PrimarySelectionManagerState;
-use sctk::reexports::client::protocol::wl_output::WlOutput;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::registry::{ProvidesRegistryState, RegistryState};
 use sctk::seat::pointer::{PointerData, PointerEvent, PointerEventKind, PointerHandler};
 use sctk::seat::{Capability, SeatHandler, SeatState};
-use sctk::shm::multi::MultiPool;
-use sctk::shm::{Shm, ShmHandler};
 use sctk::{
-    delegate_compositor, delegate_data_device, delegate_output, delegate_pointer,
-    delegate_primary_selection, delegate_registry, delegate_seat, delegate_shm, registry_handlers,
+    delegate_data_device, delegate_pointer, delegate_primary_selection, delegate_registry,
+    delegate_seat, registry_handlers,
 };
 
 use sctk::reexports::calloop::{LoopHandle, PostAction};
@@ -73,10 +68,6 @@ pub struct State<T> {
     data_selection_mime_types: Rc<Cow<'static, [MimeType]>>,
     #[cfg(feature = "dnd")]
     pub(crate) dnd_state: crate::dnd::state::DndState<T>,
-    pub(crate) compositor_state: CompositorState,
-    output_state: OutputState,
-    pub(crate) shm: Shm,
-    pub(crate) pool: MultiPool<u8>,
     _phantom: PhantomData<T>,
 }
 
@@ -99,11 +90,6 @@ impl<T: 'static + Clone> State<T> {
             return None;
         }
 
-        let compositor_state =
-            CompositorState::bind(globals, queue_handle).expect("wl_compositor not available");
-        let output_state = OutputState::new(globals, queue_handle);
-        let shm = Shm::bind(globals, queue_handle).expect("wl_shm not available");
-
         let seat_state = SeatState::new(globals, queue_handle);
         for seat in seat_state.seats() {
             seats.insert(seat.id(), Default::default());
@@ -129,10 +115,6 @@ impl<T: 'static + Clone> State<T> {
             #[cfg(feature = "dnd")]
             dnd_state: DndState::default(),
             _phantom: PhantomData,
-            compositor_state,
-            output_state,
-            pool: MultiPool::new(&shm).expect("Failed to create memory pool."),
-            shm,
         })
     }
 
@@ -493,8 +475,6 @@ impl<T: 'static + Clone> DataSourceHandler for State<T> {
             if let Some(s) = self.dnd_state.sender.as_ref() {
                 _ = s.send(DndEvent::Source(crate::dnd::SourceEvent::Cancelled));
             }
-            _ = self.pool.remove(&0);
-            self.dnd_state.icon_surface = None;
         }
     }
 
@@ -521,8 +501,6 @@ impl<T: 'static + Clone> DataSourceHandler for State<T> {
             if let Some(s) = self.dnd_state.sender.as_ref() {
                 _ = s.send(DndEvent::Source(crate::dnd::SourceEvent::Dropped))
             }
-            _ = self.pool.remove(&0);
-            self.dnd_state.icon_surface = None;
         }
     }
 
@@ -642,92 +620,6 @@ impl<T: 'static + Clone> Dispatch<WlKeyboard, ObjectId, State<T>> for State<T> {
     }
 }
 
-impl<T: 'static + Clone> CompositorHandler for State<T> {
-    fn scale_factor_changed(
-        &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        _surface: &sctk::reexports::client::protocol::wl_surface::WlSurface,
-        _new_factor: i32,
-    ) {
-    }
-
-    fn transform_changed(
-        &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        _surface: &sctk::reexports::client::protocol::wl_surface::WlSurface,
-        _new_transform: sctk::reexports::client::protocol::wl_output::Transform,
-    ) {
-    }
-
-    fn frame(
-        &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        _surface: &sctk::reexports::client::protocol::wl_surface::WlSurface,
-        _time: u32,
-    ) {
-    }
-
-    fn surface_enter(
-        &mut self,
-        _: &Connection,
-        _: &QueueHandle<Self>,
-        _: &WlSurface,
-        _: &WlOutput,
-    ) {
-    }
-
-    fn surface_leave(
-        &mut self,
-        _: &Connection,
-        _: &QueueHandle<Self>,
-        _: &WlSurface,
-        _: &WlOutput,
-    ) {
-    }
-}
-
-impl<T: 'static + Clone> OutputHandler for State<T> {
-    fn output_state(&mut self) -> &mut sctk::output::OutputState {
-        &mut self.output_state
-    }
-
-    fn new_output(
-        &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        _output: sctk::reexports::client::protocol::wl_output::WlOutput,
-    ) {
-    }
-
-    fn update_output(
-        &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        _output: sctk::reexports::client::protocol::wl_output::WlOutput,
-    ) {
-    }
-
-    fn output_destroyed(
-        &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        _output: sctk::reexports::client::protocol::wl_output::WlOutput,
-    ) {
-    }
-}
-
-impl<T: 'static + Clone> ShmHandler for State<T> {
-    fn shm_state(&mut self) -> &mut Shm {
-        &mut self.shm
-    }
-}
-
-delegate_compositor!(@<T: 'static + Clone> State<T>);
-delegate_output!(@<T: 'static + Clone> State<T>);
-delegate_shm!(@<T: 'static + Clone> State<T>);
 delegate_seat!(@<T: 'static + Clone> State<T>);
 delegate_pointer!(@<T: 'static + Clone> State<T>);
 delegate_data_device!(@<T: 'static + Clone> State<T>);