Merge branch 'main' into lenemter/introduce-property-animator

Author: lenemter

daemon/MonitorLabel.vala

@@ -31,8 +31,8 @@
         var provider = new Gtk.CssProvider ();
         try {
             provider.load_from_string (COLORED_STYLE_CSS.printf (title, info.background_color, info.text_color));
-            get_style_context ().add_class (title);
-            get_style_context ().add_class ("monitor-label");
+            add_css_class (title);
+            add_css_class ("monitor-label");
 
             Gtk.StyleContext.add_provider_for_display (
                 Gdk.Display.get_default (),

lib/Drawing/StyleManager.vala

@@ -137,6 +137,9 @@ public class Gala.Drawing.StyleManager : Object {
 
             case 10: // Slate
                 return 0x667885;
+
+            case 11: // Latte
+                return 0xe7c591;
         }
 
         return 0;

lib/Gestures/GestureController.vala

@@ -73,7 +73,7 @@ public class Gala.GestureController : Object {
         get { return _progress; }
         set {
             _progress = value;
-            target.propagate (UPDATE, action, value);
+            target?.propagate (UPDATE, action, value);
         }
     }
 

lib/Gestures/GestureSettings.vala

@@ -34,21 +34,6 @@ private class Gala.GestureSettings : Object {
             : touchpad_settings.get_boolean ("natural-scroll");
     }
 
-    public Meta.MotionDirection? get_direction (Gesture gesture) {
-        switch (gesture.direction) {
-            case GestureDirection.UP:
-                return Meta.MotionDirection.UP;
-            case GestureDirection.DOWN:
-                return Meta.MotionDirection.DOWN;
-            case GestureDirection.LEFT:
-                return Meta.MotionDirection.LEFT;
-            case GestureDirection.RIGHT:
-                return Meta.MotionDirection.RIGHT;
-            default:
-                return null;
-        }
-    }
-
     public Meta.MotionDirection? get_natural_scroll_direction (Gesture gesture) {
         bool natural_scroll = is_natural_scroll_enabled (gesture.performed_on_device_type);
 

lib/Gestures/ScrollBackend.vala

@@ -73,7 +73,7 @@ private class Gala.ScrollBackend : Object, GestureBackend {
         // Scroll events apply the natural scroll preferences out of the box
         // Standardize them so the direction matches the physical direction of the gesture and the
         // GestureTracker user can decide if it wants to follow natural scroll settings or not
-        bool natural_scroll = settings.is_natural_scroll_enabled (Clutter.InputDeviceType.TOUCHPAD_DEVICE);
+        bool natural_scroll = GestureSettings.is_natural_scroll_enabled (Clutter.InputDeviceType.TOUCHPAD_DEVICE);
         if (natural_scroll) {
             x *= -1;
             y *= -1;

lib/Gestures/ToucheggBackend.vala

@@ -150,18 +150,6 @@ private class Gala.ToucheggBackend : Object, GestureBackend {
         new Thread<void> (null, (owned) run);
     }
 
-    public void stop () {
-        try {
-            reconnection_attempts = MAX_RECONNECTION_ATTEMPTS;
-
-            if (!connection.closed) {
-                connection.close_sync ();
-            }
-        } catch (Error e) {
-            // Ignore this error, the process is being killed as this point
-        }
-    }
-
     [CCode (instance_pos = -1)]
     private void on_new_message (DBusConnection connection, string? sender_name, string object_path,
         string interface_name, string signal_name, Variant parameters) {

lib/Gestures/WorkspaceHideTracker.vala

@@ -0,0 +1,144 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ * SPDX-FileCopyrightText: 2025 elementary, Inc. (https://elementary.io)
+ */
+
+public class Gala.WorkspaceHideTracker : Object {
+    public delegate bool ComputeShouldHideOnWorkspace (Meta.Workspace workspace);
+
+    public signal void switching_workspace_progress_updated (double new_progress);
+    public signal void window_state_changed_progress_updated (double new_progress);
+
+    public Meta.Display display { private get; construct; }
+
+    private ComputeShouldHideOnWorkspace? compute_func = null;
+    private double switch_workspace_progress = 0.0;
+    private bool[] should_hide_on_workspace_cache = {};
+
+    public WorkspaceHideTracker (Meta.Display display, ComputeShouldHideOnWorkspace? compute_func) {
+        Object (display: display);
+        this.compute_func = compute_func;
+    }
+
+    construct {
+        display.list_all_windows ().foreach (setup_window);
+        display.window_created.connect (setup_window);
+
+        unowned var monitor_manager = display.get_context ().get_backend ().get_monitor_manager ();
+        monitor_manager.monitors_changed.connect (recalculate_all_workspaces);
+
+        unowned var workspace_manager = display.get_workspace_manager ();
+        workspace_manager.workspace_added.connect (recalculate_all_workspaces);
+        workspace_manager.workspace_removed.connect (recalculate_all_workspaces);
+
+        recalculate_all_workspaces ();
+    }
+
+    private void setup_window (Meta.Window window) {
+        window.notify["window-type"].connect (on_window_type_changed);
+
+        if (!Utils.get_window_is_normal (window)) {
+            return;
+        }
+
+        if (window.on_all_workspaces) {
+            recalculate_all_workspaces ();
+        } else {
+            recalculate_workspace (window);
+        }
+
+        window.position_changed.connect (recalculate_workspace);
+        window.size_changed.connect (recalculate_workspace);
+        window.workspace_changed.connect (recalculate_all_workspaces);
+        window.focused.connect (recalculate_workspace);
+        window.notify["on-all-workspaces"].connect (recalculate_all_workspaces);
+        window.notify["fullscreen"].connect (recalculate_workspace_pspec);
+        window.notify["minimized"].connect (recalculate_workspace_pspec);
+        window.notify["above"].connect (recalculate_workspace_pspec);
+        window.unmanaged.connect (recalculate_workspace);
+    }
+
+    private void on_window_type_changed (Object obj, ParamSpec pspec) {
+        var window = (Meta.Window) obj;
+
+        window.notify["window-type"].disconnect (on_window_type_changed);
+        window.position_changed.disconnect (recalculate_workspace);
+        window.size_changed.disconnect (recalculate_workspace);
+        window.workspace_changed.disconnect (recalculate_all_workspaces);
+        window.focused.disconnect (recalculate_workspace);
+        window.notify["on-all-workspaces"].disconnect (recalculate_all_workspaces);
+        window.notify["fullscreen"].disconnect (recalculate_workspace_pspec);
+        window.notify["minimized"].disconnect (recalculate_workspace_pspec);
+        window.notify["above"].disconnect (recalculate_workspace_pspec);
+        window.unmanaged.disconnect (recalculate_workspace);
+
+        setup_window (window);
+    }
+
+    /**
+     * Updates progress, it will do nothing if update_type is COMMIT or action is not SWITCH_WORKSPACE.
+     */
+    public void update (GestureTarget.UpdateType update_type, GestureAction action, double progress) {
+        if (action != SWITCH_WORKSPACE || update_type == COMMIT) {
+            return;
+        }
+
+        var new_switch_workspace_progress = progress.abs ();
+
+        // When number of workspaces changes, we get phantom SWITCH_WORKSPACE propagations
+        if (switch_workspace_progress == new_switch_workspace_progress) {
+            return;
+        }
+
+        switch_workspace_progress = new_switch_workspace_progress;
+        switching_workspace_progress_updated (get_hidden_progress ());
+    }
+
+    private double get_hidden_progress () {
+        var n_workspaces = should_hide_on_workspace_cache.length;
+
+        var left_workspace = int.max ((int) Math.floor (switch_workspace_progress), 0);
+        var right_workspace = int.min ((int) Math.ceil (switch_workspace_progress), n_workspaces - 1);
+
+        var relative_progress = switch_workspace_progress - left_workspace;
+
+        return (
+            (int) should_hide_on_workspace_cache[left_workspace] * (1.0 - relative_progress) +
+            (int) should_hide_on_workspace_cache[right_workspace] * relative_progress
+        );
+    }
+
+    public void recalculate_all_workspaces () {
+        unowned var workspace_manager = display.get_workspace_manager ();
+        should_hide_on_workspace_cache = new bool[workspace_manager.n_workspaces];
+        foreach (unowned var workspace in workspace_manager.get_workspaces ()) {
+            internal_recalculate_workspace (workspace, false);
+        }
+
+        window_state_changed_progress_updated (get_hidden_progress ());
+    }
+
+    private void internal_recalculate_workspace (Meta.Workspace? workspace, bool send_signal) {
+        if (
+            workspace == null ||
+            workspace.workspace_index >= should_hide_on_workspace_cache.length ||
+            compute_func == null
+        ) {
+            return;
+        }
+
+        should_hide_on_workspace_cache[workspace.workspace_index] = compute_func (workspace);
+
+        if (send_signal) {
+            window_state_changed_progress_updated (get_hidden_progress ());
+        }
+    }
+
+    private void recalculate_workspace (Meta.Window window) {
+        internal_recalculate_workspace (window.get_workspace (), true);
+    }
+
+    private void recalculate_workspace_pspec (Object obj, ParamSpec pspec) {
+        internal_recalculate_workspace (((Meta.Window) obj).get_workspace (), true);
+    }
+}

lib/meson.build

@@ -37,7 +37,8 @@ gala_lib_sources = files(
     'Gestures/ScrollBackend.vala',
     'Gestures/SpringTimeline.vala',
     'Gestures/ToucheggBackend.vala',
-    'Gestures/TouchpadBackend.vala'
+    'Gestures/TouchpadBackend.vala',
+    'Gestures/WorkspaceHideTracker.vala'
 ) + gala_common_enums
 
 gala_resources = gnome.compile_resources(

plugins/pip/PopupWindow.vala

@@ -118,7 +118,7 @@ public class Gala.Plugins.PIP.PopupWindow : Clutter.Actor {
 
         window_actor.notify["allocation"].connect (on_allocation_changed);
         container.set_position (container_margin, container_margin);
-        update_clone_clip ();
+        on_allocation_changed ();
 
         unowned var window = window_actor.get_meta_window ();
         window.unmanaged.connect (on_close_click_clicked);

src/BackgroundBlurEffect.vala

@@ -224,10 +224,6 @@ public class Gala.BackgroundBlurEffect : Clutter.Effect {
     }
 
     private bool update_actor_fbo (int width, int height, float downscale_factor) {
-        if (width <= 0 || height <= 0) {
-            return false;
-        }
-
         if (
             texture_width == width &&
             texture_height == height &&
@@ -344,7 +340,7 @@ public class Gala.BackgroundBlurEffect : Clutter.Effect {
         var width = (int) actor_box.get_width ();
         var height = (int) actor_box.get_height ();
 
-        if (width < 0 || height < 0) {
+        if (width <= 0 || height <= 0) {
             warning ("BackgroundBlurEffect: Couldn't update framebuffers, incorrect size");
             return false;
         }