WIP

crates/gpui/src/platform/linux/wayland/client.rs

@@ -478,7 +478,7 @@ impl WaylandClient {
             .map(|primary_selection_manager| primary_selection_manager.get_device(&seat, &qh, ()));
 
         // FIXME: Determine the scaling factor dynamically by the compositor
-        let mut cursor = Cursor::new(&conn, &globals, 24, 2);
+        let mut cursor = Cursor::new(&conn, &globals, 24, 1);
 
         handle
             .insert_source(XDPEventSource::new(&common.background_executor), {
@@ -905,7 +905,12 @@ impl Dispatch<wl_surface::WlSurface, ()> for WaylandClientStatePtr {
         let outputs = state.outputs.clone();
         drop(state);
 
-        window.handle_surface_event(event, outputs);
+        let scale = window.handle_surface_event(event, outputs);
+        dbg!(scale);
+        if let Some(scale) = scale {
+            let mut state = client.borrow_mut();
+            state.cursor.set_scale(scale as u32);
+        }
     }
 }
 
@@ -940,6 +945,8 @@ impl Dispatch<wl_output::WlOutput, ()> for WaylandClientStatePtr {
             }
             wl_output::Event::Done => {
                 if let Some(complete) = in_progress_output.complete() {
+                    dbg!(&state.outputs);
+                    dbg!(&complete);
                     state.outputs.insert(output.id(), complete);
                 }
                 state.in_progress_outputs.remove(&output.id());

crates/gpui/src/platform/linux/wayland/cursor.rs

@@ -26,7 +26,7 @@ impl Drop for Cursor {
 impl Cursor {
     pub fn new(connection: &Connection, globals: &Globals, size: u32, scale: u32) -> Self {
         Self {
-            theme: CursorTheme::load(&connection, globals.shm.clone(), size).log_err(),
+            theme: CursorTheme::load(&connection, globals.shm.clone(), size * scale).log_err(),
             theme_name: None,
             surface: globals.compositor.create_surface(&globals.qh, ()),
             shm: globals.shm.clone(),
@@ -60,6 +60,17 @@ impl Cursor {
 
     pub fn set_size(&mut self, size: u32) {
         self.size = size;
+        self.reload_theme();
+    }
+
+    pub fn set_scale(&mut self, scale: u32) {
+        self.scale = scale;
+        self.reload_theme();
+        self.surface.set_buffer_scale(self.scale as i32);
+        self.surface.commit();
+    }
+
+    fn reload_theme(&mut self) {
         self.theme = self
             .theme_name
             .as_ref()
@@ -68,11 +79,14 @@ impl Cursor {
                     &self.connection,
                     self.shm.clone(),
                     name.as_str(),
-                    self.size,
+                    self.size * self.scale,
                 )
                 .log_err()
             })
-            .or_else(|| CursorTheme::load(&self.connection, self.shm.clone(), self.size).log_err());
+            .or_else(|| {
+                CursorTheme::load(&self.connection, self.shm.clone(), self.size * self.scale)
+                    .log_err()
+            });
     }
 
     pub fn set_icon(&mut self, wl_pointer: &WlPointer, serial_id: u32, mut cursor_icon_name: &str) {

crates/gpui/src/platform/linux/wayland/window.rs

@@ -547,7 +547,8 @@ impl WaylandWindowStatePtr {
         &self,
         event: wl_surface::Event,
         outputs: HashMap<ObjectId, Output>,
-    ) {
+    ) -> Option<i32> {
+        dbg!("here");
         let mut state = self.state.borrow_mut();
 
         match event {
@@ -555,11 +556,15 @@ impl WaylandWindowStatePtr {
                 let id = output.id();
 
                 let Some(output) = outputs.get(&id) else {
-                    return;
+                    return None;
                 };
+                dbg!(&output);
+                dbg!(&outputs);
 
                 state.outputs.insert(id, output.clone());
 
+                dbg!(&outputs);
+
                 let scale = primary_output_scale(&mut state);
 
                 // We use `PreferredBufferScale` instead to set the scale if it's available
@@ -567,6 +572,8 @@ impl WaylandWindowStatePtr {
                     state.surface.set_buffer_scale(scale);
                     drop(state);
                     self.rescale(scale as f32);
+                    dbg!("SCALE");
+                    return Some(scale);
                 }
             }
             wl_surface::Event::Leave { output } => {
@@ -579,6 +586,8 @@ impl WaylandWindowStatePtr {
                     state.surface.set_buffer_scale(scale);
                     drop(state);
                     self.rescale(scale as f32);
+                    dbg!("SCALE");
+                    return Some(scale);
                 }
             }
             wl_surface::Event::PreferredBufferScale { factor } => {
@@ -587,10 +596,14 @@ impl WaylandWindowStatePtr {
                     state.surface.set_buffer_scale(factor);
                     drop(state);
                     self.rescale(factor as f32);
+                    dbg!("SCALE");
+                    return Some(factor);
                 }
             }
             _ => {}
         }
+
+        return None;
     }
 
     pub fn handle_ime(&self, ime: ImeInput) {
@@ -736,6 +749,7 @@ fn primary_output_scale(state: &mut RefMut<WaylandWindowState>) -> i32 {
     let mut scale = 1;
     let mut current_output = state.display.take();
     for (id, output) in state.outputs.iter() {
+        dbg!(output);
         if let Some((_, output_data)) = &current_output {
             if output.scale > output_data.scale {
                 current_output = Some((id.clone(), output.clone()));