@gjsify/adwaita-web 0.64.1-next.240 → 0.64.1-next.243

package/src/elements/gtk-image.ts

@@ -1,14 +1,17 @@
-// <gtk-image> — the symbolic icon node as an element. Every icon in this package is a
-// CSS-masked box whose glyph comes from a generated `.adw-icon--<name>` class and
-// whose colour is `currentColor`, so it themes with whatever contains it. The name
-// derivation and its guard live once in `@gjsify/adwaita-core`'s
-// {@link normalizeIconName}, the markup once here.
+// <gtk-image> — the icon node as an element. A symbolic icon is a CSS-masked box whose
+// glyph comes from a generated `.adw-icon--<name>` class and whose colour is
+// `currentColor`, so it themes with whatever contains it. A full-colour icon registered
+// through `registerColorIcon` is the same box with the image as its background and no
+// mask. Which of the two a name reaches is decided once, in `../icon-theme.ts`, in the
+// order GTK's own theme tries them; the symbolic name derivation and its guard live once
+// in `@gjsify/adwaita-core`'s {@link normalizeIconName}, the markup once here.
 //
 // Attributes:
-//   icon-name — symbolic name, with or without the `-symbolic` suffix. A name that is
-//               not a single CSS token (a space, a quote, a reverse-DNS application
-//               id) never reaches a class — it draws {@link MISSING_ICON_NAME}, which
-//               is what GTK draws for it, rather than injecting markup.
+//   icon-name — icon name, `-symbolic` suffix optional. A name that is neither a
+//               registered colour icon nor a single CSS token (a space, a quote, an
+//               unregistered reverse-DNS application id) never reaches a class — it
+//               draws {@link MISSING_ICON_NAME}, which is what GTK draws for it, rather
+//               than injecting markup.
 //   size      — rendered edge length in px. Absent leaves the stylesheet's 16px in
 //               charge; a context that sizes its own icons through CSS
 //               (`.adw-about-dialog-icon`, the split button's 14px arrows) keeps doing
@@ -30,7 +33,9 @@
 // Modifications: Implemented as a Web Component for @gjsify/adwaita-web; the
 //   name derivation composed from @gjsify/adwaita-core.
 
-import { normalizeIconName, stringIsNotEmpty } from '@gjsify/adwaita-core';
+import { normalizeIconName } from '@gjsify/adwaita-core';
+
+import { lookupIcon, onIconThemeChanged } from '../icon-theme.js';
 
 /**
  * The generated mask-class prefix — the one place the `--` spelling appears. `icon-registry`
@@ -46,6 +51,13 @@ export const MASK_CLASS_PREFIX = 'adw-icon--';
  */
 export const MISSING_ICON_NAME = 'image-missing';
 
+/**
+ * The modifier a colour icon carries. Deliberately NOT under {@link MASK_CLASS_PREFIX}: the
+ * stale-class sweep below and `.adw-icon:not([class*='adw-icon--'])` both read that prefix
+ * as "a mask is applied", and a colour icon has none.
+ */
+export const COLOR_ICON_CLASS = 'adw-icon-color';
+
 export class GtkImage extends HTMLElement {
     static get observedAttributes() {
         return ['icon-name', 'size'];
@@ -62,9 +74,10 @@ export class GtkImage extends HTMLElement {
     }
 
     /**
-     * The name that actually reached the mask class — `''` when the icon-name is
-     * absent, empty, or not usable as one CSS token. Consumers that need to know
-     * whether the DECLARED name is drawable ask this, not the raw attribute.
+     * The name the SYMBOLIC lookup works with — `''` when the icon-name is absent, empty,
+     * or not usable as one CSS token. A registered colour icon can still draw for a name
+     * that answers `''` here (`org.gnome.Builder`); whether a name draws anything but
+     * `image-missing` is `isIconAvailable`'s question.
      *
      * `''` does NOT mean the box draws nothing: an unusable name that was given still
      * draws {@link MISSING_ICON_NAME}. Whether an icon was ASKED FOR is the raw
@@ -85,10 +98,18 @@ export class GtkImage extends HTMLElement {
         else this.setAttribute('size', String(value));
     }
 
+    private _unsubscribe: (() => void) | null = null;
+
     connectedCallback() {
+        this._unsubscribe ??= onIconThemeChanged(() => this._render());
         this._render();
     }
 
+    disconnectedCallback() {
+        this._unsubscribe?.();
+        this._unsubscribe = null;
+    }
+
     attributeChangedCallback() {
         this._render();
     }
@@ -102,20 +123,30 @@ export class GtkImage extends HTMLElement {
         // would skip the entry after each hit.
         const stale = [...this.classList].filter((existing) => existing.startsWith(MASK_CLASS_PREFIX));
         this.classList.remove(...stale);
-        const name = this.resolvedIconName;
-        if (name !== '') {
-            this.classList.add(`${MASK_CLASS_PREFIX}${name}`);
-        } else if (stringIsNotEmpty(this.getAttribute('icon-name'))) {
-            // A name was GIVEN and cannot be one CSS token (a space, a quote, a reverse-DNS
-            // application id). GTK has no such state: `gtk_icon_theme_lookup_icon` never
-            // returns NULL, it returns the always-available `image-missing`
-            // (refs/gtk/gtk/gtkicontheme.c — `gtk_icon_paintable_get_icon_name`'s own docs
-            // say so). So the same glyph is drawn here rather than an invisible 16px hole,
-            // which is what `<adw-button-row start-icon-name="a b">` reserved and showed.
+        const found = lookupIcon(this.getAttribute('icon-name'));
+        this.classList.toggle(COLOR_ICON_CLASS, found?.kind === 'color');
+        if (found?.kind === 'color') {
+            // Drawn as-is: `_icon.scss` drops the mask and the `currentColor` fill for this
+            // modifier, so only the image paints. `url` is a data-URI or a resolved href;
+            // the quote and backslash escapes keep it one CSS string either way.
+            this.style.backgroundImage = `url("${found.url.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}")`;
+        } else {
+            this.style.removeProperty('background-image');
+        }
+        if (found?.kind === 'symbolic') {
+            this.classList.add(`${MASK_CLASS_PREFIX}${found.name}`);
+        } else if (found?.kind === 'missing') {
+            // A name was GIVEN and nothing answers it — not a colour icon, and not one CSS
+            // token (a space, a quote, an unregistered reverse-DNS application id). GTK has
+            // no such state: `gtk_icon_theme_lookup_icon` never returns NULL, it returns the
+            // always-available `image-missing` (refs/gtk/gtk/gtkicontheme.c —
+            // `gtk_icon_paintable_get_icon_name`'s own docs say so). So the same glyph is
+            // drawn here rather than an invisible 16px hole, which is what
+            // `<adw-button-row start-icon-name="a b">` reserved and showed.
             this.classList.add(`${MASK_CLASS_PREFIX}${MISSING_ICON_NAME}`);
         }
 
-        // A masked box has no text, so assistive tech has nothing to announce — the
+        // An icon box has no text, so assistive tech has nothing to announce — the
         // accessible name belongs to the control that HOSTS the icon.
         this.setAttribute('aria-hidden', 'true');
 

package/src/elements/gtk-scrolled-window.ts

@@ -394,6 +394,36 @@ export class GtkScrolledWindow extends HTMLElement {
         return this._bars?.vertical ?? null;
     }
 
+    /** `Gtk.ScrolledWindow:child` — the widget inside the viewport, or the one waiting to be adopted. */
+    get child(): Element | null {
+        return this._built ? this._viewport.firstElementChild : this.firstElementChild;
+    }
+
+    set child(value: Element | null) {
+        this.set_child(value);
+    }
+
+    get_child(): Element | null {
+        return this.child;
+    }
+
+    /**
+     * `gtk_scrolled_window_set_child`: replace the child, which sits in the viewport. Before the
+     * first connect there is no viewport yet, so the child waits in the light DOM where
+     * `connectedCallback` adopts it the way it adopts a declared one.
+     */
+    set_child(child: Element | null): void {
+        const current = this.child;
+        if (child === current) return;
+        if (this._built) {
+            this._viewport.replaceChildren(...(child === null ? [] : [child]));
+        } else {
+            current?.remove();
+            if (child !== null) this.appendChild(child);
+        }
+        this.dispatchEvent(new CustomEvent('notify::child', { bubbles: true, detail: { child } }));
+    }
+
     /** The `<gtk-viewport>` the child sits in — the one GTK's `set_child` builds for itself. */
     get viewport(): GtkViewport {
         return this._viewport;
@@ -408,7 +438,13 @@ export class GtkScrolledWindow extends HTMLElement {
             horizontal.setAttribute('orientation', 'horizontal');
             vertical.setAttribute('orientation', 'vertical');
             this._bars = { horizontal, vertical };
-            bindSlottedChildren(this, [{ into: this._viewport }]).install(this._viewport, vertical, horizontal);
+            // `Gtk.ScrolledWindow:child` is a widget PROPERTY, so an authored `child: …` names the
+            // slot by that name; the bare child is the default. Both land in the viewport.
+            bindSlottedChildren(this, [{ name: 'child', into: this._viewport }, { into: this._viewport }]).install(
+                this._viewport,
+                vertical,
+                horizontal,
+            );
             this.setAttribute('role', 'generic');
             // A bar is a VIEW of the viewport's adjustment, so the viewport's
             // `value-changed` is what moves the content and a bar's is what moves the

package/src/elements/gtk-window.ts

@@ -73,6 +73,13 @@
 //                    maximize its browser window. `is_maximized()` reads it.
 //   `present()`    — un-hides the frame; a page cannot raise or focus a window it does not own.
 //
+// THE GOBJECT DOOR (ADR 0096 § 3, ADR 0098 Amendment 3): `connect` / `disconnect` / `emit` /
+// `notify` / `get_property` / `set_property` come from `installElementApi`, over the events in
+// `static signals`; an undeclared signal throws. A `close-request` handler that returns true is
+// `preventDefault()` and stops later listeners. `emit('close-request')` throws: the signal is
+// `close()`'s, which also runs the default handler. `is_active` and `focus_widget` are PROPERTIES,
+// as in GJS and `@girs/gtk-4.0` (GTK 4 has no `gtk_window_is_active()`); `is_active()` is gone.
+//
 // Events: `notify::<prop>` (CustomEvent, bubbles, detail `{ <prop>: value }`) on every real
 // change, and `close-request` (CustomEvent, bubbles, CANCELLABLE, no detail), which is
 // `Gtk.Window::close-request`: a listener that calls `preventDefault()` is a GTK handler that
@@ -85,6 +92,8 @@
 
 import { CloseRequestState, WindowMemberState, type WindowMemberProperty } from '@gjsify/adwaita-core';
 
+import { installElementApi } from '../gobject-elements.js';
+import type { DispatchedSignals } from '../signals.js';
 import { bindSlottedChildren, type AdwSlot } from '../slotted-children.js';
 
 // Registers <gtk-window-controls>: a frame with no titlebar of its own draws the two of them
@@ -120,6 +129,64 @@ export class GtkWindow extends HTMLElement {
         this._members.reportFocus(null);
     };
 
+    /**
+     * The GObject door (ADR 0096 § 3): `connect` / `disconnect` / `emit` / `notify` / `get_property` /
+     * `set_property` over these events, the same ones every element declares in `static signals`.
+     * A `close-request` handler that returns true is `preventDefault()`.
+     */
+    static readonly signals: DispatchedSignals = {
+        'close-request': 'close-request',
+        ...Object.fromEntries(
+            [
+                'decorated',
+                'default-height',
+                'default-width',
+                'deletable',
+                'focus-widget',
+                'fullscreened',
+                'hide-on-close',
+                'icon-name',
+                'is-active',
+                'maximized',
+                'modal',
+                'resizable',
+                'title',
+                'transient-for',
+            ].map((name) => [`notify::${name}`, `notify::${name}`]),
+        ),
+    };
+
+    /** `GObject.Object.connect`: installed per instance by `installElementApi`; refuses an undeclared signal. */
+    declare connect: (signal: string, handler: (emitter: this, ...args: any[]) => unknown) => number;
+    /** `GObject.Object.disconnect`: throws for an id that is not connected. */
+    declare disconnect: (id: number) => void;
+    /** `GObject.Object.emit`; `close-request` is refused, call `close()`. */
+    declare emit: (signal: string, ...args: unknown[]) => void;
+    /** `GObject.Object.notify`. */
+    declare notify: (name: string) => void;
+    /** `GObject.Object.get_property`, by GTK's dashed name. */
+    declare get_property: (name: string) => unknown;
+    /** `GObject.Object.set_property`; a read-only property throws. */
+    declare set_property: (name: string, value: unknown) => void;
+
+    constructor() {
+        super();
+        installElementApi(this);
+        // `Gtk.Window::close-request` is emitted by `close()`, which also runs the default handler
+        // (hide or destroy). Emitting it bare would be a different thing under the same name.
+        const emit = (this as unknown as { emit: (signal: string, ...args: unknown[]) => void }).emit;
+        Object.defineProperty(this, 'emit', {
+            configurable: true,
+            writable: true,
+            value: (signal: string, ...args: unknown[]): void => {
+                if (signal === 'close-request') {
+                    throw new Error("<gtk-window>.emit('close-request') is not supported; call close()");
+                }
+                emit(signal, ...args);
+            },
+        });
+    }
+
     static get observedAttributes() {
         return [
             'decorated',
@@ -460,13 +527,16 @@ export class GtkWindow extends HTMLElement {
         this.hidden = false;
     }
 
-    /** `Gtk.Window:is-active` — see the header: the document's focus, while this frame is shown. */
+    /**
+     * `Gtk.Window:is-active` — see the header: the document's focus, while this frame is shown.
+     * A PROPERTY, as in GJS and `@girs/gtk-4.0`: GTK 4 has no `gtk_window_is_active`, so
+     * `window.is_active` is the value and `window.is_active()` does not exist.
+     */
     get isActive(): boolean {
         return this._members.active;
     }
 
-    /** `gtk_window_is_active`. */
-    is_active(): boolean {
+    get is_active(): boolean {
         return this._members.active;
     }
 
@@ -475,6 +545,15 @@ export class GtkWindow extends HTMLElement {
         return this.get_focus();
     }
 
+    /** `Gtk.Window:focus-widget` under its GJS spelling; writing it is `set_focus`. */
+    get focus_widget(): Element | null {
+        return this.get_focus();
+    }
+
+    set focus_widget(widget: Element | null) {
+        this.set_focus(widget);
+    }
+
     /** `gtk_window_get_focus`: the element inside the frame that has focus, or `null`. */
     get_focus(): Element | null {
         const active = document.activeElement;

package/src/gobject-door.spec.ts

@@ -62,6 +62,34 @@ GObject.registerClass(
     GoWebHexdump as never,
 );
 
+const SensitiveTemplate = tree(`template $GoWebSensitive : Adw.Bin {
+    child: Gtk.Box {
+        Gtk.Button btn { sensitive: bind template.enabled; }
+        Gtk.Switch sw { sensitive: bind template.enabled inverted; }
+        Gtk.Label lbl { sensitive: bind template.enabled; }
+    };
+}`);
+
+class GoWebSensitive extends Adw.Bin {
+    declare _btn: HTMLButtonElement;
+    declare _sw: HTMLElement & { disabled: boolean };
+    declare _lbl: HTMLElement;
+    declare enabled: boolean;
+    constructor(params?: Record<string, unknown>) {
+        // @ts-expect-error the element's own constructor takes none; the registered class's takes the params
+        super(params);
+    }
+}
+GObject.registerClass(
+    {
+        GTypeName: 'GoWebSensitive',
+        Template: SensitiveTemplate,
+        InternalChildren: ['btn', 'sw', 'lbl'],
+        Properties: { enabled: GObject.ParamSpec.boolean('enabled', '', '', GObject.ParamFlags.READWRITE, true) },
+    },
+    GoWebSensitive as never,
+);
+
 export const GObjectDoorTest = async () => {
     await driveGObjectVectors(subject, { describe, it, expect }, GOBJECT_VECTORS);
     await describe('adwaita-web: GObject.registerClass end to end (ADR 0096)', async () => {
@@ -116,4 +144,20 @@ export const GObjectDoorTest = async () => {
             });
         }
     });
+    await describe('adwaita-web: Gtk.Widget:sensitive in a template bind', async () => {
+        await it('binds sensitive to a template property, following it both ways of the flag', () => {
+            const el = new GoWebSensitive();
+            expect(el._btn.hasAttribute('disabled')).toBe(false);
+            expect(el._lbl.getAttribute('aria-disabled')).toBe(null);
+            el.enabled = false;
+            expect(el._btn.hasAttribute('disabled')).toBe(true);
+            expect((el._btn as unknown as { sensitive: boolean }).sensitive).toBe(false);
+            expect(el._lbl.getAttribute('aria-disabled')).toBe('true');
+            expect(el._sw.hasAttribute('disabled')).toBe(false);
+            el.enabled = true;
+            expect(el._btn.hasAttribute('disabled')).toBe(false);
+            expect(el._lbl.getAttribute('aria-disabled')).toBe(null);
+            expect(el._sw.hasAttribute('disabled')).toBe(true);
+        });
+    });
 };

package/src/gobject-elements.ts

@@ -113,7 +113,13 @@ export function listenElement(el: HTMLElement, signal: string, handler: Handler)
     const listener = (domEvent: Event) => {
         // A notification bubbles, and a parent must not hear its child's property as its own.
         if (notification && domEvent.target !== el) return;
-        handler(el, ...(EMITTED.has(domEvent) ? ((domEvent as CustomEvent).detail as unknown[]) : []));
+        const handled = handler(el, ...(EMITTED.has(domEvent) ? ((domEvent as CustomEvent).detail as unknown[]) : []));
+        // A GTK handler of a boolean-handled signal (`close-request`) returns true to take it over,
+        // which on a cancelable DOM event is `preventDefault()`; the handlers after it do not run.
+        if (handled === true && domEvent.cancelable) {
+            domEvent.preventDefault();
+            domEvent.stopImmediatePropagation();
+        }
     };
     el.addEventListener(event, listener);
     return () => el.removeEventListener(event, listener);
@@ -126,6 +132,28 @@ export function dispatchElement(el: HTMLElement, signal: string, args: readonly
     el.dispatchEvent(domEvent);
 }
 
+/**
+ * `Gtk.Widget:sensitive` for an element that has no member of that name. The DOM spells it
+ * `disabled` on a form control and `aria-disabled` on anything else (`adw-action-row.ts` reads
+ * both), so the accessor writes the spelling the element understands. An element that already
+ * declares `sensitive` (`<adw-toggle-group>`) keeps its own.
+ */
+export function installSensitive(el: HTMLElement): void {
+    if ('sensitive' in el) return;
+    const observed = (el.constructor as { observedAttributes?: string[] }).observedAttributes ?? [];
+    const form = 'disabled' in el || observed.includes('disabled');
+    Object.defineProperty(el, 'sensitive', {
+        configurable: true,
+        enumerable: false,
+        get: () => (form ? !el.hasAttribute('disabled') : el.getAttribute('aria-disabled') !== 'true'),
+        set: (value: boolean) => {
+            if (form) el.toggleAttribute('disabled', !value);
+            else if (value) el.removeAttribute('aria-disabled');
+            else el.setAttribute('aria-disabled', 'true');
+        },
+    });
+}
+
 /** Gives `el` the instance API of a registered class, over the events it declares. */
 export function installElementApi(el: HTMLElement): void {
     // A registered class already has the core's four methods on its prototype.
@@ -148,13 +176,26 @@ export function installElementApi(el: HTMLElement): void {
     });
     define('emit', (signal: string, ...args: unknown[]): void => dispatchElement(el, signal, args));
     define('notify', (name: string): void => notifyElement(el, name));
+    define('get_property', (name: string): unknown => {
+        eventOf(el, `notify::${name}`);
+        return (el as unknown as Record<string, unknown>)[propertyOf(name)];
+    });
+    define('set_property', (name: string, value: unknown): void => {
+        eventOf(el, `notify::${name}`);
+        const member = propertyOf(name);
+        const descriptor = inheritedDescriptor(el, member);
+        if (descriptor !== undefined && descriptor.get !== undefined && descriptor.set === undefined) {
+            throw new Error(`Property '${name}' of <${el.localName}> is read-only`);
+        }
+        (el as unknown as Record<string, unknown>)[member] = value;
+    });
     // The `Gtk.Widget` CSS-class calls a template's TypeScript makes on its children.
     define('add_css_class', (name: string): void => el.classList.add(name));
     define('remove_css_class', (name: string): void => el.classList.remove(name));
     define('has_css_class', (name: string): boolean => el.classList.contains(name));
 }
 
-const API_MEMBERS = new Set(['connect', 'disconnect', 'emit', 'notify']);
+const API_MEMBERS = new Set(['connect', 'disconnect', 'emit', 'notify', 'get_property', 'set_property']);
 
 /**
  * The end of a bind the core's engine drives. An element speaks camelCase members where a `.blp`

package/src/gtk-scrolled-window.spec.ts

@@ -91,6 +91,80 @@ export const GtkScrolledWindowTest = async () => {
         });
     });
 
+    await describe('<gtk-scrolled-window> its child, before and after connect', async () => {
+        const detached = (): { el: GtkScrolledWindow; host: HTMLElement } => {
+            const host = document.createElement('div');
+            host.style.height = '100px';
+            const el = document.createElement('gtk-scrolled-window') as GtkScrolledWindow;
+            host.appendChild(el);
+            return { el, host };
+        };
+        const label = (slot?: string): HTMLElement => {
+            const child = document.createElement('gtk-label');
+            if (slot !== undefined) child.setAttribute('slot', slot);
+            return child;
+        };
+
+        await it('adopts a slot="child" child appended BEFORE the element connects', async () => {
+            const host = document.createElement('div');
+            const el = document.createElement('gtk-scrolled-window') as GtkScrolledWindow;
+            const child = label('child');
+            el.appendChild(child);
+            host.appendChild(el);
+            document.body.appendChild(host);
+            await settle();
+            expect(el.viewport.contains(child)).toBe(true);
+            host.remove();
+        });
+
+        await it('adopts a slot="child" child appended AFTER the element connects', async () => {
+            const { el, host } = mount();
+            const child = label('child');
+            el.appendChild(child);
+            await settle();
+            expect(el.viewport.contains(child)).toBe(true);
+            host.remove();
+        });
+
+        await it('adopts a default-slot child appended before connect', async () => {
+            const host = document.createElement('div');
+            const el = document.createElement('gtk-scrolled-window') as GtkScrolledWindow;
+            const child = label();
+            el.appendChild(child);
+            host.appendChild(el);
+            document.body.appendChild(host);
+            await settle();
+            expect(el.viewport.contains(child)).toBe(true);
+            host.remove();
+        });
+
+        await it('set_child before connect is adopted on connect', async () => {
+            const { el, host } = detached();
+            const child = label();
+            el.set_child(child);
+            expect(el.get_child()).toBe(child);
+            document.body.appendChild(host);
+            await settle();
+            expect(el.viewport.contains(child)).toBe(true);
+            expect(el.child).toBe(child);
+            host.remove();
+        });
+
+        await it('set_child after connect replaces the child inside the viewport', async () => {
+            const { el, host } = mount();
+            const first = label();
+            const second = label();
+            el.set_child(first);
+            expect(el.viewport.contains(first)).toBe(true);
+            el.set_child(second);
+            expect(el.viewport.contains(first)).toBe(false);
+            expect(el.viewport.contains(second)).toBe(true);
+            el.set_child(null);
+            expect(el.child).toBe(null);
+            host.remove();
+        });
+    });
+
     await describe('<gtk-scrolled-window> the policies', async () => {
         await it('shows an automatic bar only while the content is longer than the window', async () => {
             const { el, host } = mount();

package/src/gtk-window.spec.ts

@@ -262,6 +262,102 @@ export const GtkWindowTest = async () => {
     await driveWindowVectors(webSubject, { describe, it, expect }, WINDOW_VECTORS);
     dispose();
 
+    await describe('<gtk-window> GObject door', async () => {
+        await it('a close-request handler returning true is preventDefault', async () => {
+            const { el, host } = mount();
+            let later = 0;
+            el.connect('close-request', () => true);
+            el.addEventListener('close-request', () => void later++);
+            expect(el.close()).toBe(false);
+            expect(el.isConnected).toBe(true);
+            expect(later).toBe(0);
+            host.remove();
+        });
+
+        await it('a handler that returns nothing lets the default run', async () => {
+            const { el, host } = mount();
+            let seen = 0;
+            el.connect('close-request', () => void seen++);
+            expect(el.close()).toBe(true);
+            expect(seen).toBe(1);
+            expect(el.isConnected).toBe(false);
+            host.remove();
+        });
+
+        await it('connect hands the window to the handler and disconnect removes it', async () => {
+            const { el, host } = mount();
+            let seen: unknown[] = [];
+            const id = el.connect('notify::title', (emitter) => void seen.push(emitter));
+            el.title = 'a';
+            expect(seen).toStrictEqual([el]);
+            el.disconnect(id);
+            el.title = 'b';
+            expect(seen.length).toBe(1);
+            host.remove();
+        });
+
+        await it('notify::is-active and notify::maximized are connectable', async () => {
+            const { el, host } = mount();
+            let maximized = 0;
+            el.connect('notify::is-active', () => {});
+            el.connect('notify::maximized', () => void maximized++);
+            el.maximize();
+            expect(maximized).toBe(1);
+            host.remove();
+        });
+
+        await it('an undeclared signal is refused by name', async () => {
+            const { el, host } = mount();
+            let message = '';
+            try {
+                el.connect('map', () => {});
+            } catch (error) {
+                message = (error as Error).message;
+            }
+            expect(message.includes("'map'")).toBe(true);
+            host.remove();
+        });
+
+        await it("emit('close-request') is refused, close() is the way", async () => {
+            const { el, host } = mount();
+            let message = '';
+            try {
+                el.emit('close-request');
+            } catch (error) {
+                message = (error as Error).message;
+            }
+            expect(message.includes('close()')).toBe(true);
+            host.remove();
+        });
+
+        await it('is_active and focus_widget are properties, as in GJS', async () => {
+            const { el, host } = mount();
+            const button = document.createElement('button');
+            el.append(button);
+            await Promise.resolve();
+            expect(typeof el.is_active).toBe('boolean');
+            expect(el.get_property('is-active')).toBe(el.is_active);
+            el.focus_widget = button;
+            expect(el.focus_widget).toBe(button);
+            expect(el.get_property('focus-widget')).toBe(button);
+            el.set_property('title', 'x');
+            expect(el.title).toBe('x');
+            host.remove();
+        });
+
+        await it('is-active is read-only through set_property', async () => {
+            const { el, host } = mount();
+            let message = '';
+            try {
+                el.set_property('is-active', true);
+            } catch (error) {
+                message = (error as Error).message;
+            }
+            expect(message.includes('read-only')).toBe(true);
+            host.remove();
+        });
+    });
+
     await describe('<gtk-window> state members', async () => {
         await it('a frame that was never connected is not realized: close() does nothing', async () => {
             const el = document.createElement('gtk-window') as GtkWindow;
@@ -278,7 +374,7 @@ export const GtkWindowTest = async () => {
             const before = el.isActive;
             expect(before).toBe(document.hasFocus());
             el.hidden = true;
-            expect(el.is_active()).toBe(false);
+            expect(el.is_active).toBe(false);
             el.present();
             expect(el.isActive).toBe(document.hasFocus());
             // Every transition above is one notification at most, and none repeats a value.