extension/dbus: expose target monitor scale in d-bus interface

amezin · amezin · commit d7469b8d001c · 2024-10-01T01:34:25.000+03:00
diff --git a/ddterm/com.github.amezin.ddterm.Extension.xml b/ddterm/com.github.amezin.ddterm.Extension.xml
@@ -7,12 +7,16 @@
         <method name="Activate"/>
         <method name="Hide"/>
         <method name="Service"/>
+
         <method name="GetTargetRect">
             <arg type="i" name="x" direction="out"/>
             <arg type="i" name="y" direction="out"/>
             <arg type="i" name="width" direction="out"/>
             <arg type="i" name="height" direction="out"/>
         </method>
+        <method name="GetTargetMonitorScale">
+            <arg type="d" direction="out"/>
+        </method>
 
         <method name="MissingDependencies">
             <arg type="as" name="packages" direction="in"/>
@@ -25,6 +29,8 @@
         <method name="VersionMismatch"/>
 
         <property type="(iiii)" name="TargetRect" access="read"/>
+        <property type="d" name="TargetMonitorScale" access="read"/>
+
         <property type="s" name="Version" access="read"/>
         <property type="s" name="Revision" access="read"/>
     </interface>
diff --git a/ddterm/shell/dbusapi.js b/ddterm/shell/dbusapi.js
@@ -104,6 +104,15 @@ export const DBusApi = GObject.registerClass({
             GObject.ParamFlags.READWRITE | GObject.ParamFlags.EXPLICIT_NOTIFY,
             Mtk.Rectangle
         ),
+        'target-monitor-scale': GObject.ParamSpec.double(
+            'target-monitor-scale',
+            '',
+            '',
+            GObject.ParamFlags.READWRITE | GObject.ParamFlags.EXPLICIT_NOTIFY,
+            0,
+            100,
+            1
+        ),
     },
     Signals: {
         'missing-dependencies': {
@@ -113,13 +122,14 @@ export const DBusApi = GObject.registerClass({
             param_types: [String, String],
         },
         'version-mismatch': {},
-        'refresh-target-rect': {},
+        'update-target-monitor': {},
     },
 }, class DDTermDBusApi extends GObject.Object {
     _init(params) {
         super._init(params);
 
         this._target_rect = new Mtk.Rectangle({ x: 0, y: 0, width: 0, height: 0 });
+        this._target_monitor_scale = 1;
 
         this.dbus = Gio.DBusExportedObject.wrapJSObject(
             Shell.get_file_contents_utf8_sync(this.xml_file_path),
@@ -156,14 +166,23 @@ export const DBusApi = GObject.registerClass({
     }
 
     GetTargetRect() {
-        this.emit('refresh-target-rect');
+        this.emit('update-target-monitor');
         return meta_rect_to_list(this._target_rect);
     }
 
+    GetTargetMonitorScale() {
+        this.emit('update-target-monitor');
+        return this._target_monitor_scale;
+    }
+
     get TargetRect() {
         return this.GetTargetRect();
     }
 
+    get TargetMonitorScale() {
+        return this.GetTargetMonitorScale();
+    }
+
     get Version() {
         return this.version;
     }
@@ -184,6 +203,19 @@ export const DBusApi = GObject.registerClass({
         this.notify('target-rect');
 
         this.dbus.emit_property_changed('TargetRect', meta_rect_to_variant(value));
-        this.dbus.flush();
+    }
+
+    get target_monitor_scale() {
+        return this._target_monitor_scale;
+    }
+
+    set target_monitor_scale(value) {
+        if (this._target_monitor_scale === value)
+            return;
+
+        this._target_monitor_scale = value;
+        this.notify('target-monitor-scale');
+
+        this.dbus.emit_property_changed('TargetMonitorScale', GLib.Variant.new_double(value));
     }
 });
diff --git a/ddterm/shell/extension.js b/ddterm/shell/extension.js
@@ -95,7 +95,7 @@ function create_dbus_interface(
         app_control,
     });
 
-    dbus_interface.connect('refresh-target-rect', () => {
+    dbus_interface.connect('update-target-monitor', () => {
         /*
          * Don't want to track mouse pointer continuously, so try to update the
          * index manually in multiple places. Also, Meta.CursorTracker doesn't
@@ -114,13 +114,27 @@ function create_dbus_interface(
         notifications.show_version_mismatch();
     });
 
+    window_geometry.bind_property(
+        'monitor-scale',
+        dbus_interface,
+        'target-monitor-scale',
+        GObject.BindingFlags.SYNC_CREATE
+    );
     window_geometry.bind_property(
         'target-rect',
         dbus_interface,
         'target-rect',
         GObject.BindingFlags.SYNC_CREATE
     );
 
+    const flush_handler = window_geometry.connect('updated', () => {
+        dbus_interface.dbus.flush();
+    });
+
+    rollback.push(() => {
+        window_geometry.disconnect(flush_handler);
+    });
+
     dbus_interface.dbus.export(Gio.DBus.session, '/org/gnome/Shell/Extensions/ddterm');
 
     rollback.push(() => {
diff --git a/ddterm/shell/geometry.js b/ddterm/shell/geometry.js
@@ -59,6 +59,15 @@ export const WindowGeometry = GObject.registerClass({
             GLib.MAXINT32,
             0
         ),
+        'monitor-scale': GObject.ParamSpec.double(
+            'monitor-scale',
+            '',
+            '',
+            GObject.ParamFlags.READABLE,
+            0,
+            100,
+            1
+        ),
         'pivot-point': GObject.ParamSpec.boxed(
             'pivot-point',
             '',
@@ -114,12 +123,17 @@ export const WindowGeometry = GObject.registerClass({
             ''
         ),
     },
+    Signals: {
+        'updated': {},
+    },
 }, class DDTermWindowGeometry extends GObject.Object {
     _init(params) {
         super._init(params);
 
-        this._workareas_changed_handler =
-            global.display.connect('workareas-changed', this._update_workarea.bind(this));
+        this._workareas_changed_handler = global.display.connect(
+            'workareas-changed',
+            this._update_workarea.bind(this)
+        );
 
         this.connect('notify::window-size', this._update_target_rect.bind(this));
         this.connect('notify::window-position', this._update_window_position.bind(this));
@@ -180,6 +194,10 @@ export const WindowGeometry = GObject.registerClass({
         return this._monitor_index;
     }
 
+    get monitor_scale() {
+        return this._monitor_scale;
+    }
+
     get pivot_point() {
         return this._pivot_point;
     }
@@ -216,6 +234,14 @@ export const WindowGeometry = GObject.registerClass({
         this.notify('monitor-index');
     }
 
+    _set_monitor_scale(new_monitor_scale) {
+        if (this._monitor_scale === new_monitor_scale)
+            return;
+
+        this._monitor_scale = new_monitor_scale;
+        this.notify('monitor-scale');
+    }
+
     _set_pivot_point(x, y) {
         if (this._pivot_point?.x === x && this._pivot_point?.y === y)
             return;
@@ -254,10 +280,11 @@ export const WindowGeometry = GObject.registerClass({
                 return;
             }
 
+            this._set_monitor_scale(global.display.get_monitor_scale(this._monitor_index));
             this._set_workarea(Main.layoutManager.getWorkAreaForMonitor(this._monitor_index));
             this._update_target_rect();
         } finally {
-            this.thaw_notify();
+            this._thaw_notify_emit_updated();
         }
     }
 
@@ -295,7 +322,7 @@ export const WindowGeometry = GObject.registerClass({
             this._set_monitor_index(this._get_monitor_index());
             this._update_workarea();
         } finally {
-            this.thaw_notify();
+            this._thaw_notify_emit_updated();
         }
     }
 
@@ -323,21 +350,42 @@ export const WindowGeometry = GObject.registerClass({
 
             this._update_target_rect();
         } finally {
-            this.thaw_notify();
+            this._thaw_notify_emit_updated();
         }
     }
 
     _update_target_rect() {
-        if (!this._workarea)
-            return;
+        this.freeze_notify();
 
-        const target_rect = WindowGeometry.get_target_rect(
-            this._workarea,
-            Math.floor(global.display.get_monitor_scale(this._monitor_index)),
-            this.window_size,
-            this.window_position
-        );
+        try {
+            if (!this._workarea)
+                return;
+
+            const target_rect = WindowGeometry.get_target_rect(
+                this._workarea,
+                Math.floor(this._monitor_scale),
+                this.window_size,
+                this.window_position
+            );
+
+            this._set_target_rect(target_rect);
+        } finally {
+            this._thaw_notify_emit_updated();
+        }
+    }
+
+    _thaw_notify_emit_updated() {
+        // 'updated' should ideally be emitted by vfunc_dispatch_properties_changed()
+        // But implementing dispatch_properties_changed() in GJS doesn't seem possible.
+
+        this._notify_emitted = false;
+        this.thaw_notify();
+
+        if (this._notify_emitted)
+            this.emit('updated');
+    }
 
-        this._set_target_rect(target_rect);
+    on_notify() {
+        this._notify_emitted = true;
     }
 });
diff --git a/test/test_wm.py b/test/test_wm.py
@@ -353,20 +353,23 @@ def current_monitor(self, request, shell_test_hook, workareas):
     def workarea(self, workareas, window_monitor):
         return workareas[window_monitor]
 
+    @pytest.fixture
+    def monitor_scale(self, monitor_config, window_monitor):
+        return monitor_config[window_monitor].scale
+
     @pytest.fixture
     def unmaximized_rect(
         self,
         workarea,
         window_size,
         window_position,
-        window_monitor,
-        monitor_config,
+        monitor_scale,
     ):
         return compute_target_rect(
             window_size=window_size,
             window_position=window_position,
             workarea=workarea,
-            round_to=int(monitor_config[window_monitor].scale)
+            round_to=int(monitor_scale)
         )
 
     @pytest.fixture
@@ -405,6 +408,7 @@ def test_show(
         self,
         unmaximized_rect,
         expected_rect,
+        monitor_scale,
         window_maximize,
         window_above,
         window_stick,
@@ -425,6 +429,7 @@ def test_show(
         assert extension_test_hook.HasWindow
         assert unmaximized_rect == extension_dbus_interface.TargetRect
         assert extension_test_hook.ClientType == gdk_backend
+        assert monitor_scale == extension_dbus_interface.TargetMonitorScale
 
         extension_test_hook.wait_property('RenderedFirstFrame', True)
         wait_idle()
@@ -496,6 +501,7 @@ def test_maximize_unmaximize(
         unmaximized_rect,
         expected_rect,
         workarea,
+        monitor_scale,
         window_maximize,
         window_above,
         window_skip_taskbar,
@@ -513,6 +519,7 @@ def test_maximize_unmaximize(
         assert extension_test_hook.HasWindow
         assert unmaximized_rect == extension_dbus_interface.TargetRect
         assert extension_test_hook.ClientType == gdk_backend
+        assert monitor_scale == extension_dbus_interface.TargetMonitorScale
 
         extension_test_hook.wait_property('RenderedFirstFrame', True)
         wait_idle()
@@ -552,8 +559,7 @@ def test_mouse_resize(
         window_size,
         window_size2,
         window_position,
-        window_monitor,
-        monitor_config,
+        monitor_scale,
         extension_dbus_interface,
         extension_test_hook,
         shell_test_hook,
@@ -566,6 +572,7 @@ def test_mouse_resize(
         assert extension_test_hook.HasWindow
         assert unmaximized_rect == extension_dbus_interface.TargetRect
         assert extension_test_hook.ClientType == gdk_backend
+        assert monitor_scale == extension_dbus_interface.TargetMonitorScale
 
         extension_test_hook.wait_property('RenderedFirstFrame', True)
         wait_idle()
@@ -580,7 +587,7 @@ def test_mouse_resize(
             window_size=window_size2,
             window_position=window_position,
             workarea=workarea,
-            round_to=int(monitor_config[window_monitor].scale)
+            round_to=int(monitor_scale)
         )
 
         end = resize_point(expected_rect2, window_position)
@@ -611,8 +618,7 @@ def test_resize_maximize_unmaximize(
         window_size,
         window_size2,
         window_position,
-        window_monitor,
-        monitor_config,
+        monitor_scale,
         extension_dbus_interface,
         extension_test_hook,
         settings_test_hook,
@@ -628,6 +634,7 @@ def test_resize_maximize_unmaximize(
         assert extension_test_hook.HasWindow
         assert unmaximized_rect == extension_dbus_interface.TargetRect
         assert extension_test_hook.ClientType == gdk_backend
+        assert monitor_scale == extension_dbus_interface.TargetMonitorScale
 
         wait_idle()
 
@@ -639,7 +646,7 @@ def test_resize_maximize_unmaximize(
             window_size=window_size2,
             window_position=window_position,
             workarea=workarea,
-            round_to=int(monitor_config[window_monitor].scale)
+            round_to=int(monitor_scale)
         )
 
         settings_test_hook.window_size = window_size2
