Introduce a WindowListModel

src/Widgets/MultitaskingView/MonitorClone.vala

@@ -33,42 +33,20 @@ public class Gala.MonitorClone : ActorTarget {
 
         background = new BackgroundManager (display, monitor, false);
 
-        window_container = new WindowCloneContainer (wm, monitor_scale);
+        var windows = new WindowListModel (display, STACKING, true, monitor);
+
+        window_container = new WindowCloneContainer (wm, windows, monitor_scale);
         window_container.add_constraint (new Clutter.BindConstraint (this, SIZE, 0.0f));
         window_container.window_selected.connect ((w) => { window_selected (w); });
         bind_property ("monitor-scale", window_container, "monitor-scale");
 
-        display.window_entered_monitor.connect (window_entered);
-        display.window_left_monitor.connect (window_left);
-
-#if HAS_MUTTER48
-        unowned GLib.List<Meta.WindowActor> window_actors = display.get_compositor ().get_window_actors ();
-#else
-        unowned GLib.List<Meta.WindowActor> window_actors = display.get_window_actors ();
-#endif
-        foreach (unowned Meta.WindowActor window_actor in window_actors) {
-            if (window_actor.is_destroyed ())
-                continue;
-
-            unowned Meta.Window window = window_actor.get_meta_window ();
-            if (window.get_monitor () == monitor) {
-                window_entered (monitor, window);
-            }
-        }
-
         add_child (background);
         add_child (window_container);
 
         var drop = new DragDropAction (DragDropActionType.DESTINATION, "multitaskingview-window");
         add_action (drop);
     }
 
-    ~MonitorClone () {
-        unowned var display = wm.get_display ();
-        display.window_entered_monitor.disconnect (window_entered);
-        display.window_left_monitor.disconnect (window_left);
-    }
-
     /**
      * Make sure the MonitorClone is at the location of the monitor on the stage
      */
@@ -82,18 +60,4 @@ public class Gala.MonitorClone : ActorTarget {
 
         monitor_scale = display.get_monitor_scale (monitor);
     }
-
-    private void window_left (int window_monitor, Meta.Window window) {
-        if (window_monitor != monitor)
-            return;
-
-        window_container.remove_window (window);
-    }
-
-    private void window_entered (int window_monitor, Meta.Window window) {
-        if (window_monitor != monitor || window.window_type != Meta.WindowType.NORMAL)
-            return;
-
-        window_container.add_window (window);
-    }
 }

src/Widgets/MultitaskingView/WindowClone.vala

@@ -440,8 +440,6 @@ public class Gala.WindowClone : ActorTarget, RootTarget {
             SignalHandler.disconnect (window.get_display (), check_confirm_dialog_cb);
             check_confirm_dialog_cb = 0;
         }
-
-        destroy ();
     }
 
     private void actor_clicked (uint32 button, Clutter.InputDeviceType device_type = POINTER_DEVICE) {

src/Widgets/MultitaskingView/WindowCloneContainer.vala

@@ -10,14 +10,14 @@
 public class Gala.WindowCloneContainer : ActorTarget {
     public signal void window_selected (Meta.Window window);
     public signal void requested_close ();
-    public signal void last_window_closed ();
 
     public int padding_top { get; set; default = 12; }
     public int padding_left { get; set; default = 12; }
     public int padding_right { get; set; default = 12; }
     public int padding_bottom { get; set; default = 12; }
 
     public WindowManager wm { get; construct; }
+    public WindowListModel windows { get; construct; }
     public float monitor_scale { get; construct set; }
     public bool overview_mode { get; construct; }
 
@@ -29,78 +29,54 @@ public class Gala.WindowCloneContainer : ActorTarget {
      */
     private unowned WindowClone? current_window = null;
 
-    public WindowCloneContainer (WindowManager wm, float monitor_scale, bool overview_mode = false) {
-        Object (wm: wm, monitor_scale: monitor_scale, overview_mode: overview_mode);
+    public WindowCloneContainer (WindowManager wm, WindowListModel windows, float monitor_scale, bool overview_mode = false) {
+        Object (wm: wm, windows: windows, monitor_scale: monitor_scale, overview_mode: overview_mode);
     }
 
-    /**
-     * Create a WindowClone for a Meta.Window and add it to the group
-     *
-     * @param window The window for which to create the WindowClone for
-     */
-    public void add_window (Meta.Window window) {
-        var windows = new List<Meta.Window> ();
-        windows.append (window);
-        foreach (unowned var clone in (GLib.List<weak WindowClone>) get_children ()) {
-            windows.append (clone.window);
-        }
-
-        var new_window = new WindowClone (wm, window, monitor_scale, overview_mode);
-        new_window.selected.connect ((_new_window) => window_selected (_new_window.window));
-        new_window.request_reposition.connect (() => reflow (false));
-        new_window.destroy.connect ((_new_window) => {
-            // make sure to release reference if the window is selected
-            if (_new_window == current_window) {
-                select_next_window (Meta.MotionDirection.RIGHT, false);
-            }
-
-            // if window is still selected, reset the selection
-            if (_new_window == current_window) {
-                current_window = null;
-            }
+    construct {
+        on_items_changed (0, 0, windows.get_n_items ());
+        windows.items_changed.connect (on_items_changed);
+    }
 
-            reflow (false);
-        });
-        bind_property ("monitor-scale", new_window, "monitor-scale");
+    private void on_items_changed (uint position, uint removed, uint added) {
+        // Used to make sure we only construct new window clones for windows that are really new
+        // and not when only the position changed (e.g. when sorted)
+        var to_remove = new HashTable<Meta.Window, WindowClone> (null, null);
 
-        unowned Meta.Window? target = null;
-        foreach (unowned var w in sort_windows (windows)) {
-            if (w != window) {
-                target = w;
-                continue;
-            }
-            break;
+        for (uint i = 0; i < removed; i++) {
+            var window_clone = (WindowClone) get_child_at_index ((int) position);
+            to_remove[window_clone.window] = window_clone;
+            remove_child (window_clone);
         }
 
-        // top most or no other children
-        if (target == null) {
-            add_child (new_window);
-        }
+        for (int i = (int) position; i < position + added; i++) {
+            var window = (Meta.Window) windows.get_item (i);
 
-        foreach (unowned var clone in (GLib.List<weak WindowClone>) get_children ()) {
-            if (target == clone.window) {
-                insert_child_below (new_window, clone);
-                break;
+            WindowClone? clone = to_remove.take (window);
+
+            if (clone == null) {
+                clone = new WindowClone (wm, window, monitor_scale, overview_mode);
+                clone.selected.connect ((_clone) => window_selected (_clone.window));
+                clone.request_reposition.connect (() => reflow (false));
+                bind_property ("monitor-scale", clone, "monitor-scale");
             }
+
+            insert_child_at_index (clone, i);
         }
 
-        reflow (false);
-    }
+        // Make sure we release the reference on the window
+        if (current_window != null && current_window.window in to_remove) {
+            select_next_window (RIGHT, false);
 
-    /**
-     * Find and remove the WindowClone for a MetaWindow
-     */
-    public void remove_window (Meta.Window window) {
-        foreach (unowned var clone in (GLib.List<weak WindowClone>) get_children ()) {
-            if (clone.window == window) {
-                remove_child (clone);
-                reflow (false);
-                break;
+            // There is no next window so select nothing
+            if (current_window.window in to_remove) {
+                current_window = null;
             }
         }
 
-        if (get_n_children () == 0) {
-            last_window_closed ();
+        // Don't reflow if only the sorting changed
+        if (to_remove.size () > 0 || added != removed) {
+            reflow (false);
         }
     }
 
@@ -120,10 +96,10 @@ public class Gala.WindowCloneContainer : ActorTarget {
                 }
             }
 
-            restack_windows ();
+            windows.sort ();
             reflow (true);
         } else if (action == MULTITASKING_VIEW) { // If we are open we only want to restack when we close
-            restack_windows ();
+            windows.sort ();
         }
     }
 
@@ -142,34 +118,6 @@ public class Gala.WindowCloneContainer : ActorTarget {
         }
     }
 
-    /**
-     * Sort the windows z-order by their actual stacking to make intersections
-     * during animations correct.
-     */
-    private void restack_windows () {
-        var children = (GLib.List<weak WindowClone>) get_children ();
-
-        var windows = new GLib.List<Meta.Window> ();
-        foreach (unowned var clone in children) {
-            windows.prepend (clone.window);
-        }
-
-        var windows_ordered = sort_windows (windows);
-        windows_ordered.reverse ();
-
-        var i = 0;
-        foreach (unowned var window in windows_ordered) {
-            foreach (unowned var clone in children) {
-                if (clone.window == window) {
-                    set_child_at_index (clone, i);
-                    children.remove (clone);
-                    i++;
-                    break;
-                }
-            }
-        }
-    }
-
     /**
      * Recalculate the tiling positions of the windows and animate them to the resulting spots.
      */
@@ -350,35 +298,6 @@ public class Gala.WindowCloneContainer : ActorTarget {
         current_window = closest;
     }
 
-    /**
-     * Sorts the windows by stacking order so that the window on active workspaces come first.
-     */
-    private GLib.SList<weak Meta.Window> sort_windows (GLib.List<Meta.Window> windows) {
-        unowned var display = wm.get_display ();
-
-        var windows_on_active_workspace = new GLib.SList<Meta.Window> ();
-        var windows_on_other_workspaces = new GLib.SList<Meta.Window> ();
-        unowned var active_workspace = display.get_workspace_manager ().get_active_workspace ();
-        foreach (unowned var window in windows) {
-            if (window.get_workspace () == active_workspace) {
-                windows_on_active_workspace.append (window);
-            } else {
-                windows_on_other_workspaces.append (window);
-            }
-        }
-
-        var sorted_windows = new GLib.SList<weak Meta.Window> ();
-        var windows_on_active_workspace_sorted = display.sort_windows_by_stacking (windows_on_active_workspace);
-        windows_on_active_workspace_sorted.reverse ();
-        var windows_on_other_workspaces_sorted = display.sort_windows_by_stacking (windows_on_other_workspaces);
-        windows_on_other_workspaces_sorted.reverse ();
-        sorted_windows.concat ((owned) windows_on_active_workspace_sorted);
-        sorted_windows.concat ((owned) windows_on_other_workspaces_sorted);
-
-        return sorted_windows;
-    }
-
-
     // Code ported from KWin present windows effect
     // https://projects.kde.org/projects/kde/kde-workspace/repository/revisions/master/entry/kwin/effects/presentwindows/presentwindows.cpp
 

src/Widgets/MultitaskingView/WorkspaceClone.vala

@@ -121,6 +121,7 @@ public class Gala.WorkspaceClone : ActorTarget {
     public WindowCloneContainer window_container { get; private set; }
 
     private BackgroundManager background;
+    private WindowListModel windows;
     private uint hover_activate_timeout = 0;
 
     public WorkspaceClone (WindowManager wm, Meta.Workspace workspace, float monitor_scale) {
@@ -136,7 +137,9 @@ public class Gala.WorkspaceClone : ActorTarget {
         background = new FramedBackground (display);
         background.add_action (background_click_action);
 
-        window_container = new WindowCloneContainer (wm, monitor_scale) {
+        windows = new WindowListModel (display, STACKING, true, display.get_primary_monitor (), workspace);
+
+        window_container = new WindowCloneContainer (wm, windows, monitor_scale) {
             width = monitor_geometry.width,
             height = monitor_geometry.height,
         };
@@ -164,79 +167,20 @@ public class Gala.WorkspaceClone : ActorTarget {
             }
         });
 
-        display.window_entered_monitor.connect (window_entered_monitor);
-        display.window_left_monitor.connect (window_left_monitor);
-        workspace.window_added.connect (add_window);
-        workspace.window_removed.connect (window_container.remove_window);
-
         add_child (background);
         add_child (window_container);
 
-        // add existing windows
-        foreach (var window in workspace.list_windows ()) {
-            add_window (window);
-        }
-
-        var static_windows = StaticWindowContainer.get_instance (display);
-        static_windows.window_changed.connect (on_window_static_changed);
-
         unowned var monitor_manager = display.get_context ().get_backend ().get_monitor_manager ();
         monitor_manager.monitors_changed.connect (update_targets);
         notify["monitor-scale"].connect (update_targets);
         update_targets ();
     }
 
     ~WorkspaceClone () {
-        unowned var display = workspace.get_display ();
-
-        display.window_entered_monitor.disconnect (window_entered_monitor);
-        display.window_left_monitor.disconnect (window_left_monitor);
-        workspace.window_added.disconnect (add_window);
-        workspace.window_removed.disconnect (window_container.remove_window);
-
         background.destroy ();
         window_container.destroy ();
     }
 
-    /**
-     * Add a window to the WindowCloneContainer if it belongs to this workspace and this monitor.
-     */
-    private void add_window (Meta.Window window) {
-        if (window.window_type != NORMAL ||
-            window.get_workspace () != workspace ||
-            StaticWindowContainer.get_instance (workspace.get_display ()).is_static (window) ||
-            !window.is_on_primary_monitor ()
-        ) {
-            return;
-        }
-
-        foreach (var child in (GLib.List<weak WindowClone>) window_container.get_children ()) {
-            if (child.window == window) {
-                return;
-            }
-        }
-
-        window_container.add_window (window);
-    }
-
-    private void window_entered_monitor (Meta.Display display, int monitor, Meta.Window window) {
-        add_window (window);
-    }
-
-    private void window_left_monitor (Meta.Display display, int monitor, Meta.Window window) {
-        if (monitor == display.get_primary_monitor ()) {
-            window_container.remove_window (window);
-        }
-    }
-
-    private void on_window_static_changed (Meta.Window window, bool is_static) {
-        if (is_static) {
-            window_container.remove_window (window);
-        } else {
-            add_window (window);
-        }
-    }
-
     public void update_size (Mtk.Rectangle monitor_geometry) {
         if (window_container.width != monitor_geometry.width || window_container.height != monitor_geometry.height) {
             window_container.set_size (monitor_geometry.width, monitor_geometry.height);
@@ -248,8 +192,11 @@ public class Gala.WorkspaceClone : ActorTarget {
         remove_all_targets ();
 
         unowned var display = workspace.get_display ();
+        var primary = display.get_primary_monitor ();
+
+        windows.monitor_filter = primary;
 
-        var monitor = display.get_monitor_geometry (display.get_primary_monitor ());
+        var monitor = display.get_monitor_geometry (primary);
 
         var scale = (float)(monitor.height - Utils.scale_to_int (TOP_OFFSET + BOTTOM_OFFSET, monitor_scale)) / monitor.height;
         var pivot_y = Utils.scale_to_int (TOP_OFFSET, monitor_scale) / (monitor.height - monitor.height * scale);