fix: dnd improvements

Author: wash2

cosmic-panel-bin/src/main.rs

@@ -87,7 +87,6 @@ fn main() -> Result<()> {
     let usage = "USAGE: cosmic-panel";
     let config = match arg.as_ref().map(|s| &s[..]) {
         Some(arg) if arg == "--help" || arg == "-h" => {
-            println!("{}", usage);
             std::process::exit(1);
         },
         None => match cosmic_panel_config::CosmicPanelContainerConfig::load() {
@@ -101,7 +100,6 @@ fn main() -> Result<()> {
             },
         },
         _ => {
-            println!("{}", usage);
             std::process::exit(1);
         },
     };

cosmic-panel-bin/src/xdg_shell_wrapper/client/handlers/compositor.rs

@@ -28,13 +28,19 @@ impl CompositorHandler for GlobalState {
         time: u32,
     ) {
         // TODO proxied layer surfaces
-        if let Some(seat) = self
-            .server_state
-            .seats
-            .iter_mut()
-            .find(|s| s.client.dnd_icon.iter().any(|dnd_icon| &dnd_icon.1 == surface))
-        {
-            seat.client.dnd_icon.as_mut().unwrap().4 = Some(time);
+        if let Some((icon, s_surface)) = self.server_state.seats.iter_mut().find_map(|s| {
+            s.client
+                .dnd_icon
+                .iter_mut()
+                .find(|dnd_icon| &dnd_icon.surface == surface)
+                .map(|dnd_icon| (dnd_icon, s.server.dnd_icon.clone()))
+        }) {
+            icon.has_frame = true;
+            if let Some(s_surface) = s_surface
+                && icon.egl_surface.is_none()
+            {
+                smithay::wayland::compositor::CompositorHandler::commit(self, &s_surface);
+            }
             self.draw_dnd_icon();
         } else {
             self.space.frame(surface, time);

cosmic-panel-bin/src/xdg_shell_wrapper/client/handlers/data_device/data_device.rs

@@ -40,8 +40,6 @@ impl DataDeviceHandler for GlobalState {
         _qh: &sctk::reexports::client::QueueHandle<Self>,
         data_device: &WlDataDevice,
     ) {
-        println!("selection");
-
         let seat = match self
             .server_state
             .seats
@@ -72,7 +70,6 @@ impl DataDeviceHandler for GlobalState {
             mime_types,
             (),
         );
-        println!("set");
     }
 
     fn enter(
@@ -84,8 +81,6 @@ impl DataDeviceHandler for GlobalState {
         _y: f64,
         surface: &WlSurface,
     ) {
-        println!("Enter");
-
         let seat = match self
             .server_state
             .seats
@@ -134,7 +129,6 @@ impl DataDeviceHandler for GlobalState {
         } else if c_action.contains(ClientDndAction::Ask) {
             dnd_actions.push(DndAction::Ask);
         }
-        dbg!(&dnd_actions);
 
         let metadata = SourceMetadata { mime_types, dnd_actions };
         let (x, y) = (offer.x, offer.y);
@@ -148,27 +142,11 @@ impl DataDeviceHandler for GlobalState {
             offer.surface.clone(),
             &ptr,
         );
-        dbg!(seat.client.next_dnd_offer_is_mine);
 
         // TODO: touch vs pointer start data
         if !seat.client.next_dnd_offer_is_mine {
             let focus = server_focus;
-            eprintln!("START DND");
-            /* TODO start server drag
-            start_dnd(
-                &self.server_state.display_handle.clone(),
-                &seat.server.seat.clone(),
-                self,
-                SERIAL_COUNTER.next_serial(),
-                Some(GrabStartData {
-                    focus: focus.map(|f| (f.surface, f.s_pos.to_f64())),
-                    button: 0x110, // assume left button for now, maybe there is another way..
-                    location: (x, y).into(),
-                }),
-                None,
-                metadata,
-            );
-            */
+
             let pointer_start_data = GrabStartData {
                 focus: focus.map(|f| (f.surface, f.s_pos.to_f64())),
                 button: 0x110, // assume left button for now, maybe there is another way..
@@ -179,7 +157,6 @@ impl DataDeviceHandler for GlobalState {
                 use smithay::input::dnd::DnDGrab;
                 use smithay::input::pointer::Focus;
                 let source = ServerGrabSource { metadata, dnd_offer: offer };
-                dbg!("START DND GRAB");
                 let dnd_grab = DnDGrab::new_pointer(
                     &self.server_state.display_handle,
                     pointer_start_data,
@@ -189,7 +166,7 @@ impl DataDeviceHandler for GlobalState {
                 pointer.set_grab(self, dnd_grab, SERIAL_COUNTER.next_serial(), Focus::Keep);
             }
         } else {
-            dbg!("Internal DND not starting server drag");
+            tracing::info!("Internal DND not starting server drag");
         }
     }
 
@@ -199,7 +176,6 @@ impl DataDeviceHandler for GlobalState {
         qh: &sctk::reexports::client::QueueHandle<Self>,
         data_device: &WlDataDevice,
     ) {
-        println!("Leave");
         let seat = match self
             .server_state
             .seats
@@ -251,7 +227,6 @@ impl DataDeviceHandler for GlobalState {
         _x: f64,
         _y: f64,
     ) {
-        // println!("Motion");
         // treat it as pointer motion
         let seat = match self
             .server_state
@@ -303,7 +278,6 @@ impl DataDeviceHandler for GlobalState {
         qh: &sctk::reexports::client::QueueHandle<Self>,
         data_device: &WlDataDevice,
     ) {
-        println!("Drop performed");
         // treat it as pointer button release
         let seat = match self
             .server_state

cosmic-panel-bin/src/xdg_shell_wrapper/client/state.rs

@@ -62,6 +62,15 @@ use super::handlers::wp_fractional_scaling::FractionalScalingManager;
 use super::handlers::wp_security_context::SecurityContextManager;
 use super::handlers::wp_viewporter::ViewporterState;
 
+#[derive(Debug)]
+pub(crate) struct DndIcon {
+    pub(crate) egl_surface: Option<EGLSurface>,
+    pub(crate) surface: WlSurface,
+    pub(crate) output_tracker: OutputDamageTracker,
+    pub(crate) is_ready: bool,
+    pub(crate) has_frame: bool,
+}
+
 #[derive(Debug)]
 pub(crate) struct ClientSeat {
     pub(crate) _seat: WlSeat,
@@ -78,8 +87,7 @@ pub(crate) struct ClientSeat {
     pub(crate) selection_offer: Option<SelectionOffer>,
     pub(crate) next_selection_offer_is_mine: bool,
     pub(crate) next_dnd_offer_is_mine: bool,
-    pub(crate) dnd_icon:
-        Option<(Option<EGLSurface>, WlSurface, OutputDamageTracker, bool, Option<u32>)>,
+    pub(crate) dnd_icon: Option<DndIcon>,
 }
 
 impl ClientSeat {

cosmic-panel-bin/src/xdg_shell_wrapper/server/handlers/compositor.rs

@@ -243,7 +243,6 @@ impl CompositorHandler for GlobalState {
                 }
             }
         } else if role == "dnd_icon".into() {
-            info!("dnd_icon commit");
             // render dnd icon to the active dnd icon surface
             on_commit_buffer_handler::<GlobalState>(surface);
             let seat = match self
@@ -259,11 +258,10 @@ impl CompositorHandler for GlobalState {
                 },
             };
             if let Some(c_icon) = seat.client.dnd_icon.as_mut() {
-                dbg!("Committing DND icon");
                 let size = bbox_from_surface_tree(surface, (0, 0)).size;
 
                 if let Some(renderer) = self.space.renderer() {
-                    match c_icon.0.as_mut() {
+                    match c_icon.egl_surface.as_mut() {
                         Some(egl_surface) => {
                             _ = unsafe {
                                 renderer.egl_context().make_current_with_surface(egl_surface)
@@ -274,7 +272,7 @@ impl CompositorHandler for GlobalState {
                             }
                         },
                         None => {
-                            let c_surface = &c_icon.1;
+                            let c_surface = &c_icon.surface;
                             let client_egl_surface = unsafe {
                                 ClientEglSurface::new(
                                     WlEglSurface::new(c_surface.id(), size.w.max(1), size.h.max(1))
@@ -299,20 +297,20 @@ impl CompositorHandler for GlobalState {
                                 renderer.egl_context().make_current_with_surface(&egl_surface)
                             };
                             _ = renderer.bind(&mut egl_surface);
-                            c_icon.0 = Some(egl_surface);
+                            c_icon.egl_surface = Some(egl_surface);
                         },
                     };
 
-                    c_icon.2 = OutputDamageTracker::new(
+                    c_icon.output_tracker = OutputDamageTracker::new(
                         (size.w.max(1), size.h.max(1)),
                         self.space.space_list[0].scale,
                         Transform::Flipped180,
                     );
                 }
 
-                c_icon.3 = true;
-                c_icon.1.commit();
-                c_icon.1.frame(&self.client_state.queue_handle, c_icon.1.clone());
+                c_icon.is_ready = true;
+                c_icon.surface.commit();
+                c_icon.surface.frame(&self.client_state.queue_handle, c_icon.surface.clone());
             }
         } else if role == "subsurface".into() {
             on_commit_buffer_handler::<GlobalState>(surface);

cosmic-panel-bin/src/xdg_shell_wrapper/server/handlers/mod.rs

@@ -231,7 +231,6 @@ impl DataDeviceHandler for GlobalState {
             client_preferred |= ClientDndAction::Ask;
         }
         offer.set_actions(client_actions, client_preferred);
-        dbg!("set actions", client_actions, client_preferred);
         preferred
     }
 }
@@ -273,15 +272,11 @@ impl WaylandDndGrabHandler for GlobalState {
     ) {
         // TODO icon
 
-        println!("FOO dnd_requested");
-
         let seat = match self.server_state.seats.iter_mut().find(|s| s.server.seat == seat) {
             Some(s) => s,
             None => return,
         };
 
-        dbg!("FOO DND REQUESTED 2");
-
         if let Some(metadata) = source.metadata() {
             seat.client.next_dnd_offer_is_mine = true;
             let mut actions = ClientDndAction::empty();
@@ -294,7 +289,6 @@ impl WaylandDndGrabHandler for GlobalState {
             if metadata.dnd_actions.contains(&DndAction::Ask) {
                 actions |= ClientDndAction::Ask;
             }
-            dbg!(&metadata.mime_types);
 
             let dnd_source = self.client_state.data_device_manager.create_drag_and_drop_source(
                 &self.client_state.queue_handle,
@@ -310,38 +304,38 @@ impl WaylandDndGrabHandler for GlobalState {
                         .create_surface(&self.client_state.queue_handle)
                 });
 
-                dbg!("FOO DND CLIENT START");
                 dnd_source.start_drag(
                     &seat.client.data_device,
                     &focus.0,
                     c_icon_surface.as_ref(),
                     seat.client.get_serial_of_last_seat_event(),
                 );
                 if let Some(client_surface) = c_icon_surface.as_ref() {
-                    dbg!("FOO DND ICON SURFACE CREATED");
                     client_surface.frame(&self.client_state.queue_handle, client_surface.clone());
                     client_surface.commit();
 
-                    seat.client.dnd_icon = Some((
-                        None,
-                        client_surface.clone(),
-                        OutputDamageTracker::new((32, 32), 1., Transform::Flipped180),
-                        false,
-                        Some(0),
-                    ));
+                    seat.client.dnd_icon = Some(DndIcon {
+                        surface: client_surface.clone(),
+                        egl_surface: None,
+                        output_tracker: OutputDamageTracker::new(
+                            (32, 32),
+                            self.space.space_list[0].scale,
+                            Transform::Flipped180,
+                        ),
+                        is_ready: false,
+                        has_frame: false,
+                    });
                 }
             }
             seat.client.dnd_source = Some(dnd_source);
         }
 
-        dbg!("FOO DND REQUESTED 3");
         //seat.server.dnd_source = source;
         seat.server.dnd_icon = icon;
 
         let seat = seat.server.seat.clone();
         match type_ {
             GrabType::Pointer => {
-                dbg!("Starting server pointer grab for DND");
                 let pointer = seat.get_pointer().unwrap();
                 let start_data = pointer.grab_start_data().unwrap();
                 pointer.set_grab(
@@ -426,7 +420,7 @@ impl ServerDndGrabHandler for GlobalState {
 
 use sctk::data_device_manager::data_offer::DragOffer;
 // TODO rename
-use crate::xdg_shell_wrapper::client_state::ClientSeat;
+use crate::xdg_shell_wrapper::client_state::{ClientSeat, DndIcon};
 pub(crate) struct ServerGrabSource {
     pub metadata: smithay::input::dnd::SourceMetadata,
     pub dnd_offer: DragOffer,

cosmic-panel-bin/src/xdg_shell_wrapper/server/state.rs

@@ -66,7 +66,7 @@ pub struct ServerState {
     pub(crate) _fractional_scale_state: FractionalScaleManagerState,
     pub(crate) _viewporter_state: ViewporterState,
     pub(crate) corner_radius_state: CornerRadiusState,
-    pub(crate) background_effect_state: BackgroundEffectState,
+    pub(crate) _background_effect_state: BackgroundEffectState,
 }
 
 impl ServerState {
@@ -89,7 +89,7 @@ impl ServerState {
             _fractional_scale_state: FractionalScaleManagerState::new::<GlobalState>(&dh),
             _viewporter_state: ViewporterState::new::<GlobalState>(&dh),
             corner_radius_state: CornerRadiusState::new::<GlobalState>(&dh),
-            background_effect_state: BackgroundEffectState::new::<GlobalState>(&dh),
+            _background_effect_state: BackgroundEffectState::new::<GlobalState>(&dh),
 
             dmabuf_state: None,
         }

cosmic-panel-bin/src/xdg_shell_wrapper/shared_state.rs

@@ -16,14 +16,15 @@ use smithay::backend::renderer::{Bind, ImportDma, ImportEgl};
 use smithay::desktop::utils::send_frames_surface_tree;
 use smithay::input::keyboard::FilterResult;
 use smithay::reexports::wayland_server::DisplayHandle;
+use smithay::reexports::wayland_server::protocol::wl_surface;
 use smithay::utils::SERIAL_COUNTER;
 use smithay::wayland::compositor::with_states;
 use smithay::wayland::dmabuf::DmabufState;
 use smithay::wayland::fractional_scale::with_fractional_scale;
 use tracing::{error, info};
 
 use crate::space_container::SpaceContainer;
-use crate::xdg_shell_wrapper::client_state::ClientState;
+use crate::xdg_shell_wrapper::client_state::{ClientState, DndIcon};
 use crate::xdg_shell_wrapper::server_state::ServerState;
 use crate::xdg_shell_wrapper::space::WrapperSpace;
 
@@ -153,15 +154,15 @@ impl GlobalState {
     pub fn draw_dnd_icon(&mut self) {
         // TODO proxied layer surfaces
         if let Some((
-            (egl_surface, wl_surface, dmg_tracked_renderer, is_dirty, has_frame),
+            DndIcon { egl_surface, surface: wl_surface, output_tracker, is_ready, has_frame },
             s_icon,
         )) = self
             .server_state
             .seats
             .iter_mut()
             .find_map(|s| s.client.dnd_icon.as_mut().zip(s.server.dnd_icon.as_mut()))
         {
-            if !*is_dirty || has_frame.is_none() {
+            if !*is_ready || !*has_frame {
                 return;
             }
             let Some(egl_surface) = egl_surface.as_mut() else {
@@ -194,7 +195,7 @@ impl GlobalState {
                     smithay::backend::renderer::element::Kind::Unspecified,
                 );
 
-            _ = dmg_tracked_renderer.render_output(renderer, &mut f, age, &elements, *clear_color);
+            _ = output_tracker.render_output(renderer, &mut f, age, &elements, *clear_color);
             drop(f);
             egl_surface.swap_buffers(None).unwrap();
             // FIXME: damage tracking issues on integrated graphics but not nvidia
@@ -217,8 +218,8 @@ impl GlobalState {
             wl_surface.frame(&self.client_state.queue_handle, wl_surface.clone());
             wl_surface.commit();
 
-            *is_dirty = false;
-            *has_frame = None;
+            *is_ready = false;
+            *has_frame = false;
         }
     }