isa/gnome-shell
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
5e93791708
gnome-shell/tests/unit/signalTracker.js

116 lines
2.6 KiB
JavaScript
Raw Normal View History

signalTracker: Provide monkey-patching for (dis)connectObject() The module exports a `addObjectSignalMethods()` method that extends the provided prototype with `connectObject()` and `disconnectObject()` methods. In its simplest form, `connectObject()` looks like the regular `connect()` method, except for an additional parameter: ```js this._button.connectObject('clicked', () => this._onButtonClicked(), this); ``` The additional object can be used to disconnect all handlers on the instance that were connected with that object, similar to `g_signal_handlers_disconnect_by_data()` (which cannot be used from introspection). For objects that are subclasses of Clutter.Actor, that will happen automatically when the actor is destroyed, similar to `g_signal_connect_object()`. Finally, `connectObject()` allows to conveniently connect multiple signals at once, similar to `g_object_connect()`: ```js this._toggleButton.connect( 'clicked', () => this._onClicked(), 'notify::checked', () => this._onChecked(), this); ``` Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1953>
2021-08-15 22:01:40 +00:00
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
// Test cases for version comparison
js: Split gi imports to be on new lines to prepare for ES modules Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/2794>
2023-06-08 04:52:46 +00:00
const GObject = imports.gi.GObject;
signalTracker: Provide monkey-patching for (dis)connectObject() The module exports a `addObjectSignalMethods()` method that extends the provided prototype with `connectObject()` and `disconnectObject()` methods. In its simplest form, `connectObject()` looks like the regular `connect()` method, except for an additional parameter: ```js this._button.connectObject('clicked', () => this._onButtonClicked(), this); ``` The additional object can be used to disconnect all handlers on the instance that were connected with that object, similar to `g_signal_handlers_disconnect_by_data()` (which cannot be used from introspection). For objects that are subclasses of Clutter.Actor, that will happen automatically when the actor is destroyed, similar to `g_signal_connect_object()`. Finally, `connectObject()` allows to conveniently connect multiple signals at once, similar to `g_object_connect()`: ```js this._toggleButton.connect( 'clicked', () => this._onClicked(), 'notify::checked', () => this._onChecked(), this); ``` Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1953>
2021-08-15 22:01:40 +00:00
const JsUnit = imports.jsUnit;
Adopt EventEmitter class instead of injecting Signal methods Introduce a new class, EventEmitter, which implements signal handling for pure JavaScript classes. EventEmitter still utilizes GJS' addSignalMethods internally. EventEmitter allows static typechecking to understand the structure of event-emitting JS classes and makes creating child classes simpler. The name 'EventEmitter' mirrors a common name for this pattern in Node and in JS libraries. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/2043>
2022-07-04 22:30:44 +00:00
const Signals = imports.misc.signals;
signalTracker: Provide monkey-patching for (dis)connectObject() The module exports a `addObjectSignalMethods()` method that extends the provided prototype with `connectObject()` and `disconnectObject()` methods. In its simplest form, `connectObject()` looks like the regular `connect()` method, except for an additional parameter: ```js this._button.connectObject('clicked', () => this._onButtonClicked(), this); ``` The additional object can be used to disconnect all handlers on the instance that were connected with that object, similar to `g_signal_handlers_disconnect_by_data()` (which cannot be used from introspection). For objects that are subclasses of Clutter.Actor, that will happen automatically when the actor is destroyed, similar to `g_signal_connect_object()`. Finally, `connectObject()` allows to conveniently connect multiple signals at once, similar to `g_object_connect()`: ```js this._toggleButton.connect( 'clicked', () => this._onClicked(), 'notify::checked', () => this._onChecked(), this); ``` Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1953>
2021-08-15 22:01:40 +00:00
const Environment = imports.ui.environment;
signalTracker: Explicitly register destroyable types We currently assume that any '::destroy' signal on a GObject type has the semantics of the ClutterActor/GtkWidget signal, and should therefore result in all signals being disconnected. But we already have a case where the assumption doesn't hold: ShellWM uses '::destroy' for the closing animation of windows, and the ShellWM object itself remains very valid after the emission. So rather than making assumptions about '::destroy', check objects against a list of destroyable types that are explicitly registered as such. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/2226>
2022-03-05 23:30:16 +00:00
const { TransientSignalHolder, registerDestroyableType } = imports.misc.signalTracker;
signalTracker: Add TransientSignalHolder class There are cases where we want to connect to a number of signals for the lifetime of an object, but also other signals for a limited period (say: between show and hide). It is currently not possible to use disconnectObject() for the latter, because it will disconnect all signals. To address this use case, add a small class that can be used as a transient signal holder, while still benefiting from autocleanup by proxying the real owner. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/2221>
2022-03-04 22:32:24 +00:00
signalTracker: Provide monkey-patching for (dis)connectObject() The module exports a `addObjectSignalMethods()` method that extends the provided prototype with `connectObject()` and `disconnectObject()` methods. In its simplest form, `connectObject()` looks like the regular `connect()` method, except for an additional parameter: ```js this._button.connectObject('clicked', () => this._onButtonClicked(), this); ``` The additional object can be used to disconnect all handlers on the instance that were connected with that object, similar to `g_signal_handlers_disconnect_by_data()` (which cannot be used from introspection). For objects that are subclasses of Clutter.Actor, that will happen automatically when the actor is destroyed, similar to `g_signal_connect_object()`. Finally, `connectObject()` allows to conveniently connect multiple signals at once, similar to `g_object_connect()`: ```js this._toggleButton.connect( 'clicked', () => this._onClicked(), 'notify::checked', () => this._onChecked(), this); ``` Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1953>
2021-08-15 22:01:40 +00:00
Environment.init();
const Destroyable = GObject.registerClass({
Signals: { 'destroy': {} },
}, class Destroyable extends GObject.Object {});
signalTracker: Explicitly register destroyable types We currently assume that any '::destroy' signal on a GObject type has the semantics of the ClutterActor/GtkWidget signal, and should therefore result in all signals being disconnected. But we already have a case where the assumption doesn't hold: ShellWM uses '::destroy' for the closing animation of windows, and the ShellWM object itself remains very valid after the emission. So rather than making assumptions about '::destroy', check objects against a list of destroyable types that are explicitly registered as such. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/2226>
2022-03-05 23:30:16 +00:00
registerDestroyableType(Destroyable);
signalTracker: Provide monkey-patching for (dis)connectObject() The module exports a `addObjectSignalMethods()` method that extends the provided prototype with `connectObject()` and `disconnectObject()` methods. In its simplest form, `connectObject()` looks like the regular `connect()` method, except for an additional parameter: ```js this._button.connectObject('clicked', () => this._onButtonClicked(), this); ``` The additional object can be used to disconnect all handlers on the instance that were connected with that object, similar to `g_signal_handlers_disconnect_by_data()` (which cannot be used from introspection). For objects that are subclasses of Clutter.Actor, that will happen automatically when the actor is destroyed, similar to `g_signal_connect_object()`. Finally, `connectObject()` allows to conveniently connect multiple signals at once, similar to `g_object_connect()`: ```js this._toggleButton.connect( 'clicked', () => this._onClicked(), 'notify::checked', () => this._onChecked(), this); ``` Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1953>
2021-08-15 22:01:40 +00:00
const GObjectEmitter = GObject.registerClass({
Signals: { 'signal': {} },
}, class GObjectEmitter extends Destroyable {});
Adopt EventEmitter class instead of injecting Signal methods Introduce a new class, EventEmitter, which implements signal handling for pure JavaScript classes. EventEmitter still utilizes GJS' addSignalMethods internally. EventEmitter allows static typechecking to understand the structure of event-emitting JS classes and makes creating child classes simpler. The name 'EventEmitter' mirrors a common name for this pattern in Node and in JS libraries. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/2043>
2022-07-04 22:30:44 +00:00
const emitter1 = new Signals.EventEmitter();
signalTracker: Provide monkey-patching for (dis)connectObject() The module exports a `addObjectSignalMethods()` method that extends the provided prototype with `connectObject()` and `disconnectObject()` methods. In its simplest form, `connectObject()` looks like the regular `connect()` method, except for an additional parameter: ```js this._button.connectObject('clicked', () => this._onButtonClicked(), this); ``` The additional object can be used to disconnect all handlers on the instance that were connected with that object, similar to `g_signal_handlers_disconnect_by_data()` (which cannot be used from introspection). For objects that are subclasses of Clutter.Actor, that will happen automatically when the actor is destroyed, similar to `g_signal_connect_object()`. Finally, `connectObject()` allows to conveniently connect multiple signals at once, similar to `g_object_connect()`: ```js this._toggleButton.connect( 'clicked', () => this._onClicked(), 'notify::checked', () => this._onChecked(), this); ``` Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1953>
2021-08-15 22:01:40 +00:00
const emitter2 = new GObjectEmitter();
const tracked1 = new Destroyable();
const tracked2 = {};
let count = 0;
const handler = () => count++;
emitter1.connectObject('signal', handler, tracked1);
emitter2.connectObject('signal', handler, tracked1);
emitter1.connectObject('signal', handler, tracked2);
emitter2.connectObject('signal', handler, tracked2);
JsUnit.assertEquals(count, 0);
emitter1.emit('signal');
emitter2.emit('signal');
JsUnit.assertEquals(count, 4);
tracked1.emit('destroy');
emitter1.emit('signal');
emitter2.emit('signal');
JsUnit.assertEquals(count, 6);
emitter1.disconnectObject(tracked2);
emitter2.emit('destroy');
emitter1.emit('signal');
emitter2.emit('signal');
JsUnit.assertEquals(count, 6);
emitter1.connectObject(
'signal', handler,
'signal', handler, GObject.ConnectFlags.AFTER,
tracked1);
emitter2.connectObject(
'signal', handler,
'signal', handler, GObject.ConnectFlags.AFTER,
tracked1);
emitter1.emit('signal');
emitter2.emit('signal');
JsUnit.assertEquals(count, 10);
tracked1.emit('destroy');
emitter1.emit('signal');
emitter2.emit('signal');
JsUnit.assertEquals(count, 10);
signalTracker: Add TransientSignalHolder class There are cases where we want to connect to a number of signals for the lifetime of an object, but also other signals for a limited period (say: between show and hide). It is currently not possible to use disconnectObject() for the latter, because it will disconnect all signals. To address this use case, add a small class that can be used as a transient signal holder, while still benefiting from autocleanup by proxying the real owner. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/2221>
2022-03-04 22:32:24 +00:00
emitter1.connectObject('signal', handler, tracked1);
emitter2.connectObject('signal', handler, tracked1);
transientHolder = new TransientSignalHolder(tracked1);
emitter1.connectObject('signal', handler, transientHolder);
emitter2.connectObject('signal', handler, transientHolder);
emitter1.emit('signal');
emitter2.emit('signal');
JsUnit.assertEquals(count, 14);
transientHolder.destroy();
emitter1.emit('signal');
emitter2.emit('signal');
JsUnit.assertEquals(count, 16);
transientHolder = new TransientSignalHolder(tracked1);
emitter1.connectObject('signal', handler, transientHolder);
emitter2.connectObject('signal', handler, transientHolder);
emitter1.emit('signal');
emitter2.emit('signal');
JsUnit.assertEquals(count, 20);
tracked1.emit('destroy');
emitter1.emit('signal');
emitter2.emit('signal');
JsUnit.assertEquals(count, 20);
Reference in New Issue Copy Permalink