@gjsify/adwaita-web 0.64.13-next.283 → 0.64.14

package/src/elements/gtk-menu-button.ts

@@ -9,8 +9,12 @@
 // `normalizeIconName` guard is what keeps a multi-token `icon-name="a b"` from
 // shipping a stray CSS class — for the button icon and for every menu entry's.
 //
-// The `menu-model` attribute is a JSON array in the portable menu model (ADR 0042) —
-// items, sections and submenus, with the same attributes GTK reads. Choosing an item
+// The `menu-model` ATTRIBUTE is a JSON array in the portable menu model (ADR 0042) —
+// items, sections and submenus, with the same attributes GTK reads. The `menuModel`
+// PROPERTY is a real `Gio.MenuModel` (ADR 0128), which is what GTK's own property is:
+// {@link MenuSlot} is the door between the two, and it is what hears a menu mutate
+// after it was handed over; a write of the property or the attribute fires
+// `notify::menu-model` (CustomEvent, bubbles, detail `{ menuModel }`). Choosing an item
 // closes the popover and fires `menu-item-activated` (CustomEvent, bubbles, detail
 // `{ id, label, path }`) with `id` falling back to `label`, matching the NS twin. The
 // rows themselves are `PopoverMenuView`'s, shared with `<adw-split-button>`: the split
@@ -24,19 +28,11 @@
 // Copyright (c) GNOME contributors (libadwaita). LGPLv2.1+.
 // Modifications: Implemented as a Web Component for @gjsify/adwaita-web.
 
-import {
-    ADW_MENU_SURFACE_WEB,
-    assertMenuRenderable,
-    isSplitButtonDirection,
-    menuRefusals,
-    menuButtonPopupDirection,
-    menuItemAt,
-    normalizeMenuModel,
-    parseMenuModel,
-} from '@gjsify/adwaita-core';
+import { isSplitButtonDirection, menuButtonPopupDirection, menuItemAt } from '@gjsify/adwaita-core';
 import { activateElementMenuItem, menuActionsOfElement } from '../application.js';
-import type { AdwMenuActions, AdwMenuInput, AdwMenuModel, SplitButtonDirection } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuModel, SplitButtonDirection } from '@gjsify/adwaita-core';
 
+import { MenuSlot } from './menu-slot.js';
 import { PopoverMenuView } from './popover-menu.js';
 
 // SIDE-EFFECT import, deliberately separate from the type import below: it guarantees
@@ -69,7 +65,10 @@ const POPOVER_POSITIONS = {
 export class GtkMenuButton extends WidgetElement {
     private _buttonEl!: HTMLButtonElement;
     private _popoverEl!: GtkPopover;
-    private _model: AdwMenuModel = [];
+    /** The model, its tree snapshot and its `items-changed` subscription (ADR 0128). */
+    private readonly _slot = new MenuSlot(() => {
+        if (this._initialized) this._renderMenu();
+    });
     private _actions: AdwMenuActions | null = null;
     private _menuTitle = '';
     private _initialized = false;
@@ -84,74 +83,46 @@ export class GtkMenuButton extends WidgetElement {
         return this._popoverEl?.open ?? false;
     }
 
-    /** The menu, normalised (ADR 0042). Setting rebuilds the popover. */
-    get menuModel(): AdwMenuModel {
-        return this._model;
+    /**
+     * The menu this button pops up, BY IDENTITY — the model itself, `null` when there is
+     * none, exactly as `gtk_menu_button_get_menu_model` answers (ADR 0128).
+     *
+     * It no longer answers an array, and `[]` is no longer how "no menu" is spelled: an
+     * EMPTY model is a menu that GTK still builds a popover for, and `null` is the one
+     * spelling of its absence (measured, `MENU_MODEL_DOOR_VECTORS`).
+     */
+    get menuModel(): AdwMenuModel | null {
+        return this._slot.model;
     }
 
     /**
-     * Set the menu from anything the portable model accepts. Refused HERE, at the
-     * assignment, for a `custom` item this surface cannot host — see the split button's
-     * note on the same setter.
+     * Take a real model, a JSON string in the portable spelling, or `null`. Refused HERE,
+     * at the assignment, for a `custom` item this surface cannot host — {@link MenuSlot}
+     * owns both doors and the note on why they refuse differently.
      */
-    set menuModel(value: AdwMenuInput) {
-        this._model = this._acceptMenu(value);
+    set menuModel(value: AdwMenuModel | string | null) {
+        this._slot.write(value);
         if (this._initialized) this._renderMenu();
+        this._notifyModel();
     }
 
     /** `Gtk.MenuButton:menu-model` — the GIR spelling of {@link menuModel}. */
-    get menu_model(): AdwMenuModel {
+    get menu_model(): AdwMenuModel | null {
         return this.menuModel;
     }
 
-    set menu_model(value: AdwMenuInput) {
+    set menu_model(value: AdwMenuModel | string | null) {
         this.menuModel = value;
     }
 
-    get_menu_model(): AdwMenuModel {
+    get_menu_model(): AdwMenuModel | null {
         return this.menuModel;
     }
 
-    set_menu_model(value: AdwMenuInput): void {
+    set_menu_model(value: AdwMenuModel | string | null): void {
         this.menuModel = value;
     }
 
-    /**
-     * Normalise, REFUSE, store — the one door every menu comes through.
-     *
-     * The property setter is not the only way a menu arrives: an attribute is, and the
-     * first cut refused only the setter, so a `custom` item written in markup drew
-     * exactly the row `assertMenuRenderable` exists to prevent — one that reads like a
-     * command and does nothing.
-     *
-     * THE TWO DOORS REFUSE DIFFERENTLY, and the difference is which side can hear it.
-     * A property assignment is a CALL, so it throws and the caller can catch. An
-     * attribute is MARKUP, parsed by the browser: a throw from `connectedCallback` is
-     * not delivered to whoever appended the element, it is reported as an uncaught
-     * page error — measured, it broke `adwaita-upgrade-order.spec.ts`, which counts
-     * exactly those. Nobody can handle it and everybody else pays for it. So the
-     * attribute path REFUSES THE MENU (no menu, and a menu-less dropdown is
-     * insensitive, which is visible) and says why on `console.error`.
-     *
-     * A REFUSAL AND A TYPO ARE STILL DIFFERENT THINGS. `parseMenuModel` is total
-     * because malformed JSON is an author slip and must not stop the element
-     * upgrading; `custom` is well-formed, deliberate, and unhonourable here.
-     */
-    private _acceptMenu(input: AdwMenuInput, strict = true): AdwMenuModel {
-        const model = normalizeMenuModel(input);
-        if (strict) {
-            assertMenuRenderable(model, ADW_MENU_SURFACE_WEB);
-            return model;
-        }
-        const refusals = menuRefusals(model, ADW_MENU_SURFACE_WEB);
-        if (refusals.length === 0) return model;
-        // `console.error` is the browser's own channel for "this is wrong, the page
-        // continues" — and the alternative here is a row that lies.
-        console.error(`${ADW_MENU_SURFACE_WEB.name} cannot render this menu, so it has none:`);
-        for (const refusal of refusals) console.error(`  [${refusal.path.join('.')}] ${refusal.message}`);
-        return [];
-    }
-
     /**
      * What the action group publishes about the actions this menu names — the portable
      * stand-in for a `GActionGroup`, and the only source of a menu's enabled/checked
@@ -212,7 +183,7 @@ export class GtkMenuButton extends WidgetElement {
         this._popoverEl.subscribe((open) => this._onPopoverToggled(open));
 
         this._menuView = new PopoverMenuView(this._popoverEl, 'adw-menu-button', (path) => {
-            const item = menuItemAt(this._model, path);
+            const item = menuItemAt(this._slot.tree, path);
             if (item === null) return;
             this._popoverEl.popdown();
             this._buttonEl.focus();
@@ -229,12 +200,14 @@ export class GtkMenuButton extends WidgetElement {
         this._buttonEl.addEventListener('click', () => {
             if (this.hasAttribute('disabled')) return;
             // Nothing to show is not a menu — never open an empty popover.
-            if (!this._popoverEl.open && this._model.length === 0) return;
+            if (!this._popoverEl.open && this._slot.isEmpty) return;
             this._popoverEl.open = !this._popoverEl.open;
         });
 
-        // Seed the menu from the attribute if the property was not set.
-        if (this._model.length === 0) this._model = this._parseMenuAttr();
+        // Seed the menu from the attribute if the property was not set — and "not set"
+        // is now the ABSENCE of a model, not an empty one, since an empty model is a
+        // menu an author may have handed over deliberately.
+        if (this._slot.model === null) this._slot.writeMarkup(this.getAttribute('menu-model'));
         // The flat default is set only now the DOM exists, so the observed-attribute
         // callback (which renders) never runs before `_buttonEl` is created.
         if (!this.hasAttribute('flat') && !this.hasAttribute('circular')) this.setAttribute('flat', '');
@@ -244,25 +217,14 @@ export class GtkMenuButton extends WidgetElement {
     attributeChangedCallback(name: string) {
         if (!this._initialized || !this._buttonEl) return;
         if (name === 'menu-model') {
-            this._model = this._parseMenuAttr();
+            this._slot.writeMarkup(this.getAttribute('menu-model'));
             this._renderMenu();
+            this._notifyModel();
             return;
         }
         this._render();
     }
 
-    /**
-     * The `menu-model` attribute, through the core parser both elements share.
-     *
-     * The copy this replaces was weaker in a way markup can reach: it kept `id` and
-     * `icon` WHATEVER their runtime type, so `{"label":"Open","id":7}` produced an
-     * entry whose `id` is a number in a field typed `string` — and `id` is what the
-     * activation event reports. The core parser keeps only string-typed attributes.
-     */
-    private _parseMenuAttr(): AdwMenuModel {
-        return this._acceptMenu(parseMenuModel(this.getAttribute('menu-model')), false);
-    }
-
     private _onPopoverToggled(open: boolean): void {
         this.classList.toggle('active', open);
         this._buttonEl.setAttribute('aria-expanded', String(open));
@@ -295,15 +257,31 @@ export class GtkMenuButton extends WidgetElement {
 
     /** The registry's answer, unless the application wrote `actions` itself (ADR 0097 § 2). */
     private _refreshActions(): void {
-        this._menuView.setActions(this._actions ?? menuActionsOfElement(this, this._model));
+        this._menuView.setActions(this._actions ?? menuActionsOfElement(this, this._slot.tree));
         this._menuView.render();
     }
 
+    /**
+     * `gtk_menu_button_set_menu_model` notifies UNCONDITIONALLY — no identity guard, so the
+     * same model written twice notifies twice and `null` over `null` notifies as well
+     * (measured, `MENU_MODEL_NOTIFY_VECTORS`). Its `Adw.SplitButton` sibling guards on
+     * pointer equality, and the two disagree on purpose: a port with one rule for both is
+     * wrong about one of them.
+     *
+     * A MUTATION of the held model is not a write and notifies nothing — it arrives over
+     * `items-changed`, where it redraws the rows and stops.
+     */
+    private _notifyModel(): void {
+        this.dispatchEvent(
+            new CustomEvent('notify::menu-model', { bubbles: true, detail: { menuModel: this._slot.model } }),
+        );
+    }
+
     private _renderMenu(): void {
-        this._menuView.setMenuModel(this._model);
+        this._menuView.setMenuTree(this._slot.tree);
         this._menuView.setTitle(this.getAttribute('menu-title') ?? this._menuTitle);
         this._menuView.render();
-        if (this._model.length === 0) this._popoverEl.popdown();
+        if (this._slot.isEmpty) this._popoverEl.popdown();
     }
 }
 

package/src/elements/gtk-popover-bin.ts

@@ -32,7 +32,8 @@
 //   handle-input  — boolean, default FALSE — GTK's default. When set, a right click and a
 //                   long press open the popover at the pointer.
 // Properties:
-//   menuModel     — the model, normalised (get/set). Setting it REPLACES any popover.
+//   menuModel     — the real `Gio.MenuModel`, or `null` (get/set; ADR 0128). Setting it
+//                   REPLACES any popover.
 //   popoverElement — the `<gtk-popover>` this bin presents (get/set; setting it drops
 //                   the model, as GTK does). `GtkPopoverBin`'s own name for it is `popover`,
 //                   which `HTMLElement` already spells as a string attribute for the DOM
@@ -60,14 +61,9 @@
 // Copyright (c) GNOME contributors (GTK, libadwaita). LGPLv2.1+
 // Modifications: Implemented as a Web Component for @gjsify/adwaita-web.
 
-import {
-    ADW_MENU_SURFACE_WEB,
-    assertMenuRenderable,
-    menuRefusals,
-    normalizeMenuModel,
-    parseMenuModel,
-} from '@gjsify/adwaita-core';
-import type { AdwMenuActions, AdwMenuInput, AdwMenuModel } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuModel } from '@gjsify/adwaita-core';
+
+import { MenuSlot } from './menu-slot.js';
 
 // Both definitions have to be there before this module's own can build them in
 // `connectedCallback`; a combined `import { GtkPopoverMenu }` would be elided, because the
@@ -82,7 +78,14 @@ import { WidgetElement } from '../widget-element.js';
 const LONG_PRESS_MS = 500;
 
 export class GtkPopoverBin extends WidgetElement {
-    private _model: AdwMenuModel = [];
+    /**
+     * The model's door and `items-changed` subscription (ADR 0128), with NOTHING to do
+     * when the menu it holds mutates: this bin draws no rows. The `<gtk-popover-menu>` it
+     * built holds the SAME model and watches it through a slot of its own, so the rows
+     * follow one level down — and GTK sends no `notify::menu-model` for a mutation either
+     * (measured, `MENU_MODEL_NOTIFY_VECTORS`).
+     */
+    private readonly _slot = new MenuSlot(() => undefined);
     private _popover: GtkPopoverMenu | null = null;
     private _actions: AdwMenuActions | null = null;
     private _initialized = false;
@@ -92,9 +95,9 @@ export class GtkPopoverBin extends WidgetElement {
         return ['menu-model', 'handle-input'];
     }
 
-    /** The menu model, normalised (ADR 0042). */
-    get menuModel(): AdwMenuModel {
-        return this._model;
+    /** The menu this bin pops up, by identity, or `null` (ADR 0128). */
+    get menuModel(): AdwMenuModel | null {
+        return this._slot.model;
     }
 
     /**
@@ -102,9 +105,8 @@ export class GtkPopoverBin extends WidgetElement {
      * setters clear each other (gtkpopoverbin.c:474-500, :543-551). A model REPLACES the
      * popover; a popover DROPS the model, and both notify for both properties.
      */
-    set menuModel(value: AdwMenuInput | AdwMenuModel) {
-        this._model = normalizeMenuModel(value as AdwMenuInput);
-        assertMenuRenderable(this._model, ADW_MENU_SURFACE_WEB);
+    set menuModel(value: AdwMenuModel | string | null) {
+        this._slot.write(value);
         this._adoptPopover(this._buildPopover());
         this._notifyModel();
     }
@@ -123,7 +125,7 @@ export class GtkPopoverBin extends WidgetElement {
     }
 
     set popoverElement(value: GtkPopoverMenu | null) {
-        this._model = [];
+        this._slot.write(null);
         this._adoptPopover(value);
         this._notifyModel();
     }
@@ -157,8 +159,8 @@ export class GtkPopoverBin extends WidgetElement {
         this.addEventListener('contextmenu', (event) => this._onContextMenu(event));
         this.addEventListener('keydown', (event) => this._onKeyDown(event));
         this._wireGestures();
-        if (this._model.length === 0) this._model = this._parseMenuAttr();
-        if (this._model.length > 0) this._adoptPopover(this._buildPopover());
+        if (this._slot.model === null) this._slot.writeMarkup(this.getAttribute('menu-model'));
+        this._adoptPopover(this._buildPopover());
     }
 
     disconnectedCallback() {
@@ -176,8 +178,8 @@ export class GtkPopoverBin extends WidgetElement {
             return;
         }
         if (name === 'menu-model') {
-            this._model = this._parseMenuAttr();
-            this._adoptPopover(this._model.length > 0 ? this._buildPopover() : null);
+            this._slot.writeMarkup(this.getAttribute('menu-model'));
+            this._adoptPopover(this._buildPopover());
             this._notifyModel();
         }
     }
@@ -265,14 +267,20 @@ export class GtkPopoverBin extends WidgetElement {
         this.popup();
     }
 
+    /**
+     * The popover follows the PRESENCE of a model, not its length: an empty non-null
+     * `Gio.Menu` at `menu-model` still builds a `GtkPopoverMenu` in GTK and still
+     * dissociates an application-set popover (measured, `MENU_MODEL_DOOR_VECTORS`), and
+     * `null` is the one spelling of "no menu".
+     */
     private _buildPopover(): GtkPopoverMenu | null {
-        if (this._model.length === 0) return null;
+        if (this._slot.model === null) return null;
         const popover = document.createElement('gtk-popover-menu') as GtkPopoverMenu;
         // `gtk_popover_set_position (popover, GTK_POS_BOTTOM)` in the same function
         // (gtkpopoverbin.c:493), on a popover `gtk_popover_menu_new_from_model` made.
         popover.setAttribute('position', 'bottom');
         popover.setAttribute('align', 'start');
-        popover.menuModel = this._model;
+        popover.menuModel = this._slot.model;
         popover.actions = this._actions;
         popover.anchor = this;
         return popover;
@@ -313,24 +321,10 @@ export class GtkPopoverBin extends WidgetElement {
         this.dispatchEvent(
             new CustomEvent('notify::menu-model', {
                 bubbles: true,
-                detail: { menuModel: this._model, popover: this._popover },
+                detail: { menuModel: this._slot.model, popover: this._popover },
             }),
         );
     }
-
-    /**
-     * The `menu-model` ATTRIBUTE through the core parser, refusing a `custom` item the way
-     * every menu-bearing surface here does: markup is parsed by the browser, so a throw from
-     * `connectedCallback` would reach nobody and the menu would be silently empty.
-     */
-    private _parseMenuAttr(): AdwMenuModel {
-        const model = normalizeMenuModel(parseMenuModel(this.getAttribute('menu-model')));
-        const refusals = menuRefusals(model, ADW_MENU_SURFACE_WEB);
-        if (refusals.length === 0) return model;
-        console.error(`${ADW_MENU_SURFACE_WEB.name} cannot render this menu, so it has none:`);
-        for (const refusal of refusals) console.error(`  [${refusal.path.join('.')}] ${refusal.message}`);
-        return [];
-    }
 }
 
 customElements.define('gtk-popover-bin', GtkPopoverBin);

package/src/elements/gtk-popover-menu-bar.ts

@@ -37,7 +37,8 @@
 //   menu-model — the portable menu model as JSON (ADR 0042), whose TOPLEVEL entries must
 //               all be submenus.
 // Properties:
-//   menuModel  — the model, normalised (get/set; a `custom` item throws here).
+//   menuModel  — the real `Gio.MenuModel`, or `null` (get/set; ADR 0128 — a `custom` item
+//               throws here).
 //   actions    — what the action group publishes about the actions the menus name.
 //   activeItem — the focused/selected item's button, or `null`. GTK's `active_item`.
 // Methods:
@@ -57,16 +58,10 @@
 // Copyright (c) GNOME contributors (GTK, libadwaita). LGPLv2.1+
 // Modifications: Implemented as a Web Component for @gjsify/adwaita-web.
 
-import {
-    ADW_MENU_SURFACE_WEB,
-    assertMenuRenderable,
-    menuItemAt,
-    menuLabelText,
-    menuRefusals,
-    normalizeMenuModel,
-    parseMenuModel,
-} from '@gjsify/adwaita-core';
-import type { AdwMenuActions, AdwMenuInput, AdwMenuModel, AdwMenuPath, AdwMenuSubmenu } from '@gjsify/adwaita-core';
+import { buildMenu, menuItemAt, menuLabelText } from '@gjsify/adwaita-core';
+import type { AdwMenuActions, AdwMenuModel, AdwMenuPath, AdwMenuSubmenu } from '@gjsify/adwaita-core';
+
+import { MenuSlot } from './menu-slot.js';
 
 // The definition has to be there before this module's own can build one in
 // `connectedCallback`; a combined `import { GtkPopoverMenu }` would be elided, because the
@@ -88,7 +83,8 @@ interface MenuBarItem {
 }
 
 export class GtkPopoverMenuBar extends WidgetElement {
-    private _model: AdwMenuModel = [];
+    /** The model, its tree snapshot and its `items-changed` subscription (ADR 0128). */
+    private readonly _slot = new MenuSlot(() => this._menuChanged());
     private _actions: AdwMenuActions | null = null;
     private _items: MenuBarItem[] = [];
     private _active: MenuBarItem | null = null;
@@ -98,14 +94,29 @@ export class GtkPopoverMenuBar extends WidgetElement {
         return ['menu-model'];
     }
 
-    /** The menu model, normalised (ADR 0042). */
-    get menuModel(): AdwMenuModel {
-        return this._model;
+    /** The menu this bar draws, by identity, or `null` (ADR 0128). */
+    get menuModel(): AdwMenuModel | null {
+        return this._slot.model;
+    }
+
+    set menuModel(value: AdwMenuModel | string | null) {
+        this._slot.write(value);
+        this._menuChanged();
     }
 
-    set menuModel(value: AdwMenuInput) {
-        this._model = normalizeMenuModel(value);
-        assertMenuRenderable(this._model, ADW_MENU_SURFACE_WEB);
+    /**
+     * The one place a changed menu is answered — from either door AND from a mutation of
+     * the menu the bar is holding, which is why the `console.warn` below is here rather
+     * than beside the attribute parse it used to live in: a toplevel entry that is not a
+     * submenu can arrive by `append_item` just as easily as by markup.
+     */
+    private _menuChanged(): void {
+        for (const [index, node] of this._slot.tree.entries()) {
+            if (node.kind === 'submenu') continue;
+            // A WARNING and not an error, and the distinction is GTK's: `g_warning` is
+            // recoverable, and the submenus beside the offending entry still work.
+            console.warn(`Don't know how to handle this item: top-level entry ${index} is a ${node.kind}.`);
+        }
         if (this._initialized) this._rebuild();
     }
 
@@ -136,14 +147,14 @@ export class GtkPopoverMenuBar extends WidgetElement {
         this.addEventListener('pointerleave', () => {
             if (this._active !== null && !this._active.popover.open) this._setActive(null, false);
         });
-        if (this._model.length === 0) this._model = this._parseMenuAttr();
-        this._rebuild();
+        if (this._slot.model === null) this._slot.writeMarkup(this.getAttribute('menu-model'));
+        this._menuChanged();
     }
 
     attributeChangedCallback(name?: string) {
         if (!this._initialized || name !== 'menu-model') return;
-        this._model = this._parseMenuAttr();
-        this._rebuild();
+        this._slot.writeMarkup(this.getAttribute('menu-model'));
+        this._menuChanged();
     }
 
     /** `gtk_popover_menu_bar_select_first` — activate and OPEN the first item. */
@@ -213,7 +224,7 @@ export class GtkPopoverMenuBar extends WidgetElement {
         this._items = [];
         this._active = null;
         const built: MenuBarItem[] = [];
-        this._model.forEach((node, index) => {
+        this._slot.tree.forEach((node, index) => {
             if (node.kind !== 'submenu') return;
             built.push(this._buildItem(node, [index]));
         });
@@ -237,8 +248,8 @@ export class GtkPopoverMenuBar extends WidgetElement {
     /**
      * One `menubar > item > popover` (the node tree in gtkpopovermenubar.c:38-46).
      *
-     * A toplevel node that is not a submenu is refused by `_parseMenuAttr` with GTK's own
-     * wording rather than drawn: `tracker_insert` builds nothing for it
+     * A toplevel node that is not a submenu is WARNED about by {@link _menuChanged} with
+     * GTK's own wording rather than drawn: `tracker_insert` builds nothing for it
      * (gtkpopovermenubar.c:466), and a row that opens nothing is the same lie in another
      * shape.
      */
@@ -269,9 +280,10 @@ export class GtkPopoverMenuBar extends WidgetElement {
         // (gtkpopovermenubar.c:435-436).
         popover.setAttribute('position', 'bottom');
         popover.setAttribute('align', 'start');
-        // The submenu's OWN items, handed back as they are: `normalizeMenuModel` is
-        // idempotent and explicitly takes an already-normalised node (ADR 0042).
-        popover.menuModel = node.items;
+        // The submenu's OWN items, as a menu OF THEIR OWN: since ADR 0128 the popover takes
+        // a real `Gio.MenuModel`, and `buildMenu` is how a tree becomes one. Handing over
+        // the bar's own model instead would give the popover the whole bar.
+        popover.menuModel = buildMenu(node.items);
         popover.actions = this._actions;
         popover.anchor = button;
         // `gtk_accessible_update_relation (…, LABELLED_BY, item->label, CONTROLS,
@@ -324,7 +336,7 @@ export class GtkPopoverMenuBar extends WidgetElement {
      * row is not the row that opened a submenu (gtkpopovermenu.c:257-259).
      */
     private _activate(item: MenuBarItem, path: AdwMenuPath): void {
-        const target = menuItemAt(this._model, path);
+        const target = menuItemAt(this._slot.tree, path);
         item.popover.popdown();
         item.button.focus();
         if (target === null) return;
@@ -335,23 +347,6 @@ export class GtkPopoverMenuBar extends WidgetElement {
             }),
         );
     }
-
-    private _parseMenuAttr(): AdwMenuModel {
-        const model = normalizeMenuModel(parseMenuModel(this.getAttribute('menu-model')));
-        const refusals = menuRefusals(model, ADW_MENU_SURFACE_WEB);
-        if (refusals.length > 0) {
-            console.error(`${ADW_MENU_SURFACE_WEB.name} cannot render this menu, so it has none:`);
-            for (const refusal of refusals) console.error(`  [${refusal.path.join('.')}] ${refusal.message}`);
-            return [];
-        }
-        for (const [index, node] of model.entries()) {
-            if (node.kind === 'submenu') continue;
-            // A WARNING and not an error, and the distinction is GTK's: `g_warning` is
-            // recoverable, and the submenus beside the offending entry still work.
-            console.warn(`Don't know how to handle this item: top-level entry ${index} is a ${node.kind}.`);
-        }
-        return model;
-    }
 }
 
 customElements.define('gtk-popover-menu-bar', GtkPopoverMenuBar);