Allow dropping windows from the MultitaskingView on the IconGroups

Author: leolost2605

src/DBus/WindowDragManager.vala

@@ -0,0 +1,103 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * SPDX-FileCopyrightText: 2025 elementary, Inc. (https://elementary.io)
+ */
+
+public class Dock.WindowDragManager : Object {
+    [DBus (name = "io.elementary.desktop.wm.WindowDragProvider")]
+    private interface WindowDragProvider : Object {
+        public signal void enter (uint64 window_id);
+        public signal void motion (int x, int y);
+        public signal void leave ();
+        public signal void dropped ();
+    }
+
+    public Gtk.Window dock_window { get; construct; }
+
+    private Window? current_window = null;
+    private WorkspaceIconGroup? current_icon_group = null;
+
+    private WindowDragProvider provider;
+
+    public WindowDragManager (Gtk.Window dock_window) {
+        Object (dock_window: dock_window);
+    }
+
+    construct {
+        connect_to_dbus.begin ();
+    }
+
+    private async void connect_to_dbus () {
+        try {
+            provider = yield Bus.get_proxy (SESSION, "io.elementary.gala", "/io/elementary/gala");
+            provider.enter.connect (on_enter);
+            provider.motion.connect (on_motion);
+            provider.leave.connect (on_leave);
+            provider.dropped.connect (on_dropped);
+        } catch (Error e) {
+            warning ("Failed to connect to WindowDragProvider DBus interface: %s", e.message);
+        }
+    }
+
+    private void on_enter (uint64 window_id) {
+        current_window = WindowSystem.get_default ().find_window (window_id);
+    }
+
+    private void on_motion (int x, int y) {
+        if (current_window == null) {
+            return;
+        }
+
+        var icon_group = find_icon_group (x, y);
+
+        if (icon_group == current_icon_group) {
+            return;
+        }
+
+        if (current_icon_group != null) {
+            current_icon_group.window_left ();
+        }
+
+        current_icon_group = icon_group;
+
+        if (current_icon_group != null) {
+            current_icon_group.window_entered (current_window);
+        }
+    }
+
+    private WorkspaceIconGroup? find_icon_group (int x, int y) {
+        double root_x, root_y;
+        dock_window.get_surface_transform (out root_x, out root_y);
+
+        var widget = dock_window.pick (x - root_x, y - root_y, DEFAULT);
+
+        while (!(widget is WorkspaceIconGroup) && widget != null) {
+            widget = widget.get_parent ();
+        }
+
+        if (widget is WorkspaceIconGroup) {
+            return (WorkspaceIconGroup) widget;
+        }
+
+        return null;
+    }
+
+    private void on_leave () {
+        if (current_icon_group != null) {
+            current_icon_group.window_left ();
+            current_icon_group = null;
+        }
+
+        current_window = null;
+    }
+
+    private void on_dropped () {
+        if (current_icon_group != null && current_window != null &&
+            current_icon_group.workspace.index != current_window.workspace_index
+        ) {
+            WindowSystem.get_default ().move_window_to_workspace.begin (
+                current_window.uid, current_icon_group.workspace.index
+            );
+        }
+    }
+}

src/MainWindow.vala

@@ -27,6 +27,8 @@ public class Dock.MainWindow : Gtk.ApplicationWindow {
 
     private Gtk.Box main_box;
 
+    private WindowDragManager window_drag_manager;
+
     class construct {
         set_css_name ("dock-window");
     }
@@ -75,6 +77,8 @@ public class Dock.MainWindow : Gtk.ApplicationWindow {
             transparency_settings.changed["use-transparency"].connect (update_transparency);
             update_transparency ();
         }
+
+        window_drag_manager = new WindowDragManager (this);
     }
 
     private void update_transparency () {

src/WindowSystem/DesktopIntegration.vala

@@ -27,6 +27,7 @@ public interface Dock.DesktopIntegration : GLib.Object {
     public abstract async Window[] get_windows () throws GLib.DBusError, GLib.IOError;
     public abstract async void show_windows_for (string app_id) throws GLib.DBusError, GLib.IOError;
     public abstract async void focus_window (uint64 uid) throws GLib.DBusError, GLib.IOError;
+    public abstract async void move_window_to_workspace (uint64 window, int workspace) throws GLib.DBusError, GLib.IOError;
     public abstract async void activate_workspace (int index) throws GLib.DBusError, GLib.IOError;
     public abstract async int get_n_workspaces () throws GLib.DBusError, GLib.IOError;
     public abstract async int get_active_workspace () throws GLib.DBusError, GLib.IOError;

src/WindowSystem/WindowSystem.vala

@@ -41,10 +41,10 @@
         }
     }
 
-    private Window? find_window (uint64 uid) {
+    public Window? find_window (uint64 uid) {
         uint index;
         if (windows.find_custom (uid, (win, uid) => {
-            return win.uid == uid;
+            return win.uid == (uint64) uid;
         }, out index)) {
             return windows[index];
         }
@@ -83,4 +83,12 @@
             critical (e.message);
         }
     }
+
+    public async void move_window_to_workspace (uint64 window, int workspace) requires (desktop_integration != null) {
+        try {
+            yield desktop_integration.move_window_to_workspace (window, workspace);
+        } catch (Error e) {
+            critical ("Failed to move window to workspace: %s", e.message);
+        }
+    }
 }

src/WorkspaceSystem/IconGroup.vala

@@ -6,12 +6,25 @@
 public class Dock.WorkspaceIconGroup : BaseIconGroup {
     public Workspace workspace { get; construct; }
 
+    public GLib.ListStore additional_icons { private get; construct; }
+
     public WorkspaceIconGroup (Workspace workspace) {
+        var additional_icons = new GLib.ListStore (typeof (GLib.Icon));
+
+        var workspace_icons = new Gtk.MapListModel (workspace.windows, (window) => {
+            return ((Window) window).icon;
+        });
+
+        var icon_sources_list_store = new GLib.ListStore (typeof (GLib.ListModel));
+        icon_sources_list_store.append (additional_icons);
+        icon_sources_list_store.append (workspace_icons);
+
+        var flatten_model = new Gtk.FlattenListModel (icon_sources_list_store);
+
         Object (
             workspace: workspace,
-            icons: new Gtk.MapListModel (workspace.windows, (window) => {
-                return ((Window) window).icon;
-            }),
+            additional_icons: additional_icons,
+            icons: flatten_model,
             group: Group.WORKSPACE
         );
     }
@@ -36,4 +49,16 @@ public class Dock.WorkspaceIconGroup : BaseIconGroup {
             workspace.reorder (ItemManager.get_default ().get_index_for_launcher (this));
         }
     }
+
+    public void window_entered (Window window) {
+        if (window.workspace_index == workspace.index) {
+            return;
+        }
+
+        additional_icons.append (window.icon);
+    }
+
+    public void window_left () {
+        additional_icons.remove_all ();
+    }
 }

src/meson.build

@@ -17,6 +17,7 @@ sources = [
     'DBus' / 'ShellKeyGrabber.vala',
     'DBus' / 'SwitcherooControl.vala',
     'DBus' / 'Unity.vala',
+    'DBus' / 'WindowDragManager.vala',
     'WindowSystem' / 'DesktopIntegration.vala',
     'WindowSystem' / 'Window.vala',
     'WindowSystem' / 'WindowSystem.vala',