initial commit

.local/share/gnome-shell/extensions/dynamic-panel-transparency@rockon999.github.io/events.js

@@ -0,0 +1,231 @@
+/* exported init, cleanup, get_current_maximized_window */
+
+const Mainloop = imports.mainloop;
+
+const GLib = imports.gi.GLib;
+const Gio = imports.gi.Gio;
+const Shell = imports.gi.Shell;
+
+const Main = imports.ui.main;
+
+const Me = imports.misc.extensionUtils.getCurrentExtension();
+
+const Convenience = Me.imports.convenience;
+const Extension = Me.imports.extension;
+const Intellifade = Me.imports.intellifade;
+const Settings = Me.imports.settings;
+const Util = Me.imports.util;
+
+const Theming = Me.imports.theming;
+const Transitions = Me.imports.transitions;
+
+/**
+ * Signal Connections
+ * js/ui/overview.js/hidden: occurs after the overview is hidden
+ * js/ui/overview.js/shown: occurs after the overview is open
+ * MetaScreen/restacked: occurs when the window Z-ordering changes
+ * window_group/actor-added: occurs when a window actor is added
+ * window_group/actor-removed: occurs when a window actor is removed
+ * wm/switch-workspace: occurs after a workspace is switched
+ */
+
+/**
+ * Intialize.
+ *
+ */
+function init() {
+    this._wm_tracker = Shell.WindowTracker.get_default();
+
+    this._overviewHidingSig = Main.overview.connect('hiding', Util.strip_args(Intellifade.syncCheck).bind(this));
+
+    if (Settings.transition_with_overview()) {
+        this._overviewShownSig = Main.overview.connect('showing', _overviewShown.bind(this));
+    } else {
+        this._overviewShownSig = Main.overview.connect('shown', _overviewShown.bind(this));
+    }
+
+    let windows = global.get_window_actors();
+
+    for (let window_actor of windows) {
+        /* Simulate window creation event, null container because _windowActorAdded doesn't utilize containers */
+        _windowActorAdded(null, window_actor, false);
+    }
+
+    this._workspaceSwitchSig = global.window_manager.connect_after('switch-workspace', _workspaceSwitched.bind(this));
+
+    const screen = global.screen || global.display;
+
+    if (screen) {
+        this._windowRestackedSig = screen.connect_after('restacked', _windowRestacked.bind(this));
+    } else {
+        log('[Dynamic Panel Transparency] Error could not register \'restacked\' event.');
+    }
+
+    this._windowActorAddedSig = global.window_group.connect('actor-added', _windowActorAdded.bind(this));
+    this._windowActorRemovedSig = global.window_group.connect('actor-removed', _windowActorRemoved.bind(this));
+
+    this._appFocusedSig = this._wm_tracker.connect_after('notify::focus-app', _windowRestacked.bind(this));
+}
+
+function disconnect(obj, sig) {
+    try {
+        if (sig != null && obj) {
+            obj.disconnect(sig);
+        }
+    } catch (error) {
+        log('[Dynamic Panel Transparency] Failed to disconnect signal: ' + error);
+    }
+}
+
+/**
+ * Don't want to hold onto anything that isn't ours.
+ *
+ */
+function cleanup() {
+    /* Disconnect Signals */
+    if (this._windowUnminimizeSig) {
+        disconnect(global.window_manager, this._windowUnminimizeSig);
+    }
+
+    disconnect(Main.overview, this._overviewShownSig);
+    disconnect(Main.overview, this._overviewHidingSig);
+
+    disconnect(global.window_manager, this._workspaceSwitchSig);
+
+    disconnect(global.window_group, this._windowActorAddedSig);
+    disconnect(global.window_group, this._windowActorRemovedSig);
+
+    const screen = global.screen || global.display;
+
+    if (screen) {
+        disconnect(screen, this._windowRestackedSig);
+    } else {
+        log('[Dynamic Panel Transparency] Error could not disconnect \'restacked\' event.');
+    }
+
+    disconnect(this._wm_tracker, this._appFocusedSig);
+
+    let windows = global.get_window_actors();
+
+    for (let window_actor of windows) {
+        if (typeof (window_actor._dpt_signals) !== 'undefined') {
+            for (let signalId of window_actor._dpt_signals) {
+                disconnect(window_actor, signalId);
+            }
+        }
+
+        delete window_actor._dpt_signals;
+        delete window_actor._dpt_tracking;
+    }
+
+    /* Cleanup Signals */
+    this._windowRestackedSig = null;
+    this._overviewShownSig = null;
+    this._overviewHidingSig = null;
+    this._windowActorRemovedSig = null;
+    this._workspaceSwitchSig = null;
+    this._windowActorAddedSig = null;
+
+    this._wm_tracker = null;
+}
+
+/* Event Handlers */
+
+/**
+ * Called whenever the overview is shown.
+ *
+ */
+function _overviewShown() {
+    if (!Transitions.get_transparency_status().is_blank()) {
+        Transitions.blank_fade_out();
+    }
+
+    if (Settings.get_enable_text_color() && (Settings.get_enable_maximized_text_color() || Settings.get_enable_overview_text_color())) {
+        if (Settings.get_enable_overview_text_color()) {
+            Theming.remove_text_color();
+            Theming.set_text_color('maximized');
+        } else {
+            Theming.remove_text_color('maximized');
+            Theming.set_text_color();
+        }
+    }
+}
+
+/**
+ * Called whenever a window actor is removed.
+ *
+ */
+function _windowActorRemoved(container, window_actor) {
+    if (typeof (window_actor._dpt_tracking) === 'undefined') {
+        return;
+    }
+
+    /* Remove our tracking variable. */
+    delete window_actor._dpt_tracking;
+
+    if (typeof (window_actor._dpt_signals) !== 'undefined') {
+        for (let signalId of window_actor._dpt_signals) {
+            window_actor.disconnect(signalId);
+        }
+    }
+
+    delete window_actor._dpt_signals;
+
+    Intellifade.asyncCheck();
+}
+
+const { major, minor } = Util.get_shell_version();
+
+/**
+ * Called whenever a window is created in the shell.
+ *
+ */
+function _windowActorAdded(window_group, window_actor, force = true) {
+    if (window_actor && (force || typeof (window_actor._dpt_tracking) === 'undefined')) {
+        window_actor._dpt_tracking = true;
+
+        let ac_wId = -1;
+
+        if (major >= 40 || minor > 36) {
+            ac_wId = window_actor.connect('notify::allocation', (function() {
+                Intellifade.asyncCheck();
+            }).bind(this));
+        } else {
+            ac_wId = window_actor.connect('allocation-changed', (function() {
+                Intellifade.asyncCheck();
+            }).bind(this));
+        }
+
+        const v_wId = window_actor.connect('notify::visible', (function() {
+            Intellifade.asyncCheck();
+        }).bind(this));
+        window_actor._dpt_signals = [ac_wId, v_wId];
+
+        Intellifade.asyncCheck();
+    }
+}
+
+/**
+ * SPECIAL_CASE: Only update if we're using per-app settings or is desktop icons are enabled.
+ *
+ */
+function _windowRestacked() {
+    /* Don't allow restacks while the overview is transitioning. */
+    if (!Main.overview.visible) {
+        /* Detect if desktop icons are enabled. */
+        if (Settings.gs_show_desktop()) {
+            Intellifade.asyncCheck();
+        }
+    }
+}
+
+/**
+ * SPECIAL_CASE: Update logic requires the workspace that we'll be switching to.
+ *
+ */
+function _workspaceSwitched(wm, from, to, direction) {
+    /* Detect if desktop icons are enabled. */
+    if (!Settings.gs_show_desktop()) {
+        Intellifade.syncCheck();
+    }
+}