Add focused window D-Bus Signal

[flxzt]

In addition to the current FocusedWindow.Get D-Bus method it would be very nice to be able to subscribe to a signal that gets emitted whenever the current focused window changes.

[musjj]

Would love to see this feature too!

[TheOddPirate]

It will need some changes and some testing but while trying to modify this to extend kiot to work on gnome, i may have added signals to it. could be used as a base to create what you want

Remember this is untested, so it might need to be fixed and modified to work perfectly, but it should send a signal atm

import { Extension, gettext as _ } from 'resource:///org/gnome/shell/extensions/extension.js';
import Gio from 'gi://Gio';
import GLib from 'gi://GLib';
import Meta from 'gi://Meta';
import Shell from 'gi://Shell';

const DBUS_SCHEMA = `
<node>
  <interface name="org.gnome.shell.extensions.FocusedWindow">
    <method name="Get">
      <arg type="s" direction="out" name="window" />
    </method>
    <signal name="WindowChanged">
      <arg type="s" name="attributes" />
    </signal>
  </interface>
</node>`;

const KIOT_DBUS_SCHEMA = `
<node>
  <interface name="org.davidedmundson.kiot.ActiveWindow">
    <method name="UpdateAttributes">
      <arg type="a{sv}" direction="in" name="attributes" />
    </method>
  </interface>
</node>`;

export default class FocusedWindowDbus extends Extension {
    constructor(metadata) {
        super(metadata);
        this._dbus = null;
        this._kiotProxy = null;
        this._windowTracker = null;
        this._lastWindow = null;
        this._lastAttributes = null;
        this._signals = [];
    }

    Get() {
        let window = this._getFocusedWindow();
        if (!window) {
            return "{}";
        }
        
        let attributes = this._getWindowAttributes(window);
        return JSON.stringify(attributes);
    }

    _getFocusedWindow() {
        let windowList = global.get_window_actors();
        for (let i = 0; i < windowList.length; i++) {
            let window = windowList[i];
            if (window.meta_window.has_focus()) {
                return window;
            }
        }
        return null;
    }

    _getWindowAttributes(window) {
        if (!window) {
            return {};
        }
        
        let metaWindow = window.meta_window;
        let workspaceManager = global.workspace_manager;
        let currentMonitor = global.display.get_current_monitor();
        
        let attributes = {
            title: metaWindow.get_title() || '',
            wm_class: metaWindow.get_wm_class() || '',
            wm_class_instance: metaWindow.get_wm_class_instance() || '',
            pid: metaWindow.get_pid(),
            id: metaWindow.get_id(),
            width: window.get_width(),
            height: window.get_height(),
            x: window.get_x(),
            y: window.get_y(),
            focus: metaWindow.has_focus(),
            in_current_workspace: metaWindow.located_on_workspace(
                workspaceManager.get_active_workspace()
            ),
            moveable: metaWindow.allows_move(),
            resizeable: metaWindow.allows_resize(),
            canclose: metaWindow.can_close(),
            canmaximize: metaWindow.can_maximize(),
            maximized: metaWindow.is_maximized(),
            canminimize: metaWindow.can_minimize(),
            minimized: metaWindow.is_minimized(),
            display: metaWindow.get_display().get_name() || '',
            frame_type: metaWindow.get_frame_type(),
            window_type: metaWindow.get_window_type(),
            layer: metaWindow.get_layer(),
            monitor: metaWindow.get_monitor(),
            role: metaWindow.get_role() || '',
            resourceClass: metaWindow.get_wm_class() || '',
            fullscreen: metaWindow.is_fullscreen().toString(),
            screen: this._getMonitorName(currentMonitor)
        };
        
        // Add work area information
        let workArea = metaWindow.get_work_area_current_monitor();
        if (workArea) {
            attributes.area = {
                x: workArea.x,
                y: workArea.y,
                width: workArea.width,
                height: workArea.height
            };
        }
        
        return attributes;
    }

    _getMonitorName(monitorIndex) {
        let monitor = global.display.get_monitor(monitorIndex);
        if (monitor) {
            return monitor.get_manufacturer() || `Monitor ${monitorIndex}`;
        }
        return `Monitor ${monitorIndex}`;
    }

    _onWindowFocusChanged(window) {
        if (window && window.meta_window.has_focus()) {
            this._lastWindow = window;
            let attributes = this._getWindowAttributes(window);
            this._lastAttributes = attributes;
            
            // Send signal on our DBus interface
            if (this._dbus) {
                this._dbus.emit_signal('WindowChanged', 
                    new GLib.Variant('(s)', [JSON.stringify(attributes)])
                );
            }
            
            // Also send to kiot DBus service if available
            this._sendToKiot(attributes);
        }
    }

    _sendToKiot(attributes) {
        try {
            if (!this._kiotProxy) {
                this._kiotProxy = Gio.DBusProxy.makeProxyWrapper(KIOT_DBUS_SCHEMA);
                this._kiotProxy = new this._kiotProxy(
                    Gio.DBus.session,
                    'org.davidedmundson.kiot.ActiveWindow',
                    '/ActiveWindow'
                );
            }
            
            // Convert attributes to GVariant
            let builder = new GLib.VariantBuilder(GLib.VariantType.new('a{sv}'));
            
            for (let key in attributes) {
                let value = attributes[key];
                let variantValue;
                
                if (typeof value === 'string') {
                    variantValue = new GLib.Variant('s', value);
                } else if (typeof value === 'number') {
                    if (Number.isInteger(value)) {
                        variantValue = new GLib.Variant('i', value);
                    } else {
                        variantValue = new GLib.Variant('d', value);
                    }
                } else if (typeof value === 'boolean') {
                    variantValue = new GLib.Variant('b', value);
                } else if (value === null || value === undefined) {
                    variantValue = new GLib.Variant('s', '');
                } else if (typeof value === 'object') {
                    variantValue = new GLib.Variant('s', JSON.stringify(value));
                } else {
                    variantValue = new GLib.Variant('s', String(value));
                }
                
                builder.add('{sv}', key, variantValue);
            }
            
            let variantDict = builder.end();
            
            this._kiotProxy.UpdateAttributesSync(variantDict);
        } catch (e) {
            // kiot service might not be running yet, that's OK
            log(`Failed to send to kiot: ${e.message}`);
        }
    }

    _connectWindowSignals(window) {
        if (!window) return;
        
        let metaWindow = window.meta_window;
        
        // Connect to window property changes
        let signals = [
            metaWindow.connect('notify::title', () => this._onWindowChanged(window)),
            metaWindow.connect('notify::fullscreen', () => this._onWindowChanged(window)),
            metaWindow.connect('size-changed', () => this._onWindowChanged(window)),
            metaWindow.connect('position-changed', () => this._onWindowChanged(window))
        ];
        
        this._signals.push(...signals);
    }

    _disconnectWindowSignals() {
        if (this._lastWindow && this._lastWindow.meta_window) {
            for (let signalId of this._signals) {
                this._lastWindow.meta_window.disconnect(signalId);
            }
        }
        this._signals = [];
    }

    _onWindowChanged(window) {
        if (window && window.meta_window.has_focus()) {
            let attributes = this._getWindowAttributes(window);
            this._lastAttributes = attributes;
            
            // Send signal on our DBus interface
            if (this._dbus) {
                this._dbus.emit_signal('WindowChanged', 
                    new GLib.Variant('(s)', [JSON.stringify(attributes)])
                );
            }
            
            // Also send to kiot DBus service
            this._sendToKiot(attributes);
        }
    }

    enable() {
        // Export DBus interface
        this._dbus = Gio.DBusExportedObject.wrapJSObject(DBUS_SCHEMA, this);
        this._dbus.export(
            Gio.DBus.session,
            "/org/gnome/shell/extensions/FocusedWindow"
        );
        
        // Track window focus changes
        this._windowTracker = Shell.WindowTracker.get_default();
        this._focusChangedId = this._windowTracker.connect(
            'notify::focus-app',
            () => {
                this._disconnectWindowSignals();
                let window = this._getFocusedWindow();
                this._connectWindowSignals(window);
                this._onWindowFocusChanged(window);
            }
        );
        
        // Get initial focused window and connect signals
        let initialWindow = this._getFocusedWindow();
        this._connectWindowSignals(initialWindow);
        this._onWindowFocusChanged(initialWindow);
        
        log('FocusedWindow extension enabled');
    }

    disable() {
        this._disconnectWindowSignals();
        
        if (this._focusChangedId && this._windowTracker) {
            this._windowTracker.disconnect(this._focusChangedId);
            this._focusChangedId = null;
        }
        
        if (this._dbus) {
            this._dbus.flush();
            this._dbus.unexport();
            delete this._dbus;
        }
        
        this._windowTracker = null;
        this._lastWindow = null;
        this._lastAttributes = null;
        this._kiotProxy = null;
        
        log('FocusedWindow extension disabled');
    }
}