@gtkx/react 0.14.0 → 0.16.0

package/dist/nodes/notebook-page.js

@@ -1,18 +1,19 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
-import { scheduleAfterCommit } from "../scheduler.js";
+import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
+import { hasChanged } from "./internal/utils.js";
 import { NotebookPageTabNode } from "./notebook-page-tab.js";
 import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
 export class NotebookPageNode extends SlotNode {
     static priority = 1;
-    position;
-    tabNode;
+    position = null;
+    tabNode = null;
     static matches(type) {
         return type === "NotebookPage";
     }
-    setNotebook(notebook) {
-        this.setParent(notebook);
+    setParent(parent) {
+        super.setParent(parent);
         this.updateTabNode();
     }
     setPosition(position) {
@@ -34,7 +35,7 @@ export class NotebookPageNode extends SlotNode {
             this.tabNode = child;
             scheduleAfterCommit(() => {
                 this.updateTabNode();
-            });
+            }, CommitPriority.NORMAL);
             return;
         }
         if (!(child instanceof WidgetNode)) {
@@ -47,26 +48,31 @@ export class NotebookPageNode extends SlotNode {
                 this.onChildChange(oldChild ?? null);
             }
             this.updateTabNode();
-        });
+        }, CommitPriority.NORMAL);
     }
     removeChild(child) {
         if (child instanceof NotebookPageTabNode) {
-            this.tabNode = undefined;
+            this.tabNode = null;
             return;
         }
-        super.removeChild();
+        super.removeChild(child);
     }
     unmount() {
-        this.tabNode = undefined;
+        this.tabNode = null;
         super.unmount();
     }
     updateProps(oldProps, newProps) {
         super.updateProps(oldProps, newProps);
-        if (!oldProps || oldProps.label !== newProps.label) {
-            if (this.child && this.parent && !this.tabNode?.child) {
-                const tabLabel = this.getNotebook().getTabLabel(this.child);
-                tabLabel.setLabel(newProps.label ?? "");
-            }
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (hasChanged(oldProps, newProps, "label") && this.child && this.parent && !this.tabNode?.child) {
+            const tabLabel = this.getNotebook().getTabLabel(this.child);
+            tabLabel.setLabel(newProps.label ?? "");
+        }
+        const pagePropsChanged = hasChanged(oldProps, newProps, "tabExpand") || hasChanged(oldProps, newProps, "tabFill");
+        if (this.child && this.parent && pagePropsChanged) {
+            this.applyPageProps();
         }
     }
     attachPage() {
@@ -83,9 +89,26 @@ export class NotebookPageNode extends SlotNode {
         }
         if (this.position != null) {
             notebook.insertPage(child, this.position, tabLabel);
+        }
+        else {
+            notebook.appendPage(child, tabLabel);
+        }
+        this.applyPageProps();
+    }
+    applyPageProps() {
+        const child = this.child;
+        if (!child || !this.parent)
             return;
+        const notebook = this.getNotebook();
+        const page = notebook.getPage(child);
+        if (!page)
+            return;
+        if (this.props.tabExpand !== undefined) {
+            page.setTabExpand(this.props.tabExpand);
+        }
+        if (this.props.tabFill !== undefined) {
+            page.setTabFill(this.props.tabFill);
         }
-        notebook.appendPage(child, tabLabel);
     }
     detachPage(childToDetach) {
         const notebook = this.getNotebook();

package/dist/nodes/notebook.js

@@ -12,7 +12,7 @@ class NotebookNode extends WidgetNode {
         if (!(child instanceof NotebookPageNode)) {
             throw new Error(`Cannot append '${child.typeName}' to 'Notebook': expected x.NotebookPage`);
         }
-        child.setNotebook(this.container);
+        child.setParent(this.container);
     }
     insertBefore(child, before) {
         if (!(child instanceof NotebookPageNode) || !(before instanceof NotebookPageNode)) {
@@ -20,7 +20,7 @@ class NotebookNode extends WidgetNode {
         }
         const beforePosition = this.container.pageNum(before.getChild());
         child.setPosition(beforePosition);
-        child.setNotebook(this.container);
+        child.setParent(this.container);
     }
     removeChild(child) {
         if (!(child instanceof NotebookPageNode)) {

package/dist/nodes/overlay-child.js

@@ -1,49 +1,109 @@
-import { batch, isObjectEqual } from "@gtkx/ffi";
+import { isObjectEqual } from "@gtkx/ffi";
 import { registerNodeClass } from "../registry.js";
-import { SlotNode } from "./slot.js";
-class OverlayChildNode extends SlotNode {
+import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+class OverlayChildNode extends VirtualNode {
     static priority = 1;
     static matches(type) {
         return type === "OverlayChild";
     }
-    getOverlay() {
-        if (!this.parent) {
-            throw new Error("Expected parent widget to be set on OverlayChildNode");
+    parent = null;
+    children = new Set();
+    canBeChildOf(parent) {
+        return parent instanceof WidgetNode;
+    }
+    attachTo(parent) {
+        if (parent instanceof WidgetNode) {
+            this.parent = parent.container;
         }
-        return this.parent;
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
-        if (!this.parent || !this.child) {
-            return;
+    detachFrom(_parent) { }
+    unmount() {
+        if (this.parent && this.children.size > 0) {
+            const parent = this.parent;
+            const children = [...this.children];
+            this.children.clear();
+            for (const child of children) {
+                const currentParent = child.getParent();
+                if (currentParent && isObjectEqual(currentParent, parent)) {
+                    parent.removeOverlay(child);
+                }
+            }
         }
-        const overlay = this.getOverlay();
-        if (!oldProps || oldProps.measure !== newProps.measure) {
-            overlay.setMeasureOverlay(this.child, newProps.measure ?? false);
+        this.parent = null;
+        super.unmount();
+    }
+    appendChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to '${this.typeName}': expected Widget`);
         }
-        if (!oldProps || oldProps.clipOverlay !== newProps.clipOverlay) {
-            overlay.setClipOverlay(this.child, newProps.clipOverlay ?? false);
+        const widget = child.container;
+        this.children.add(widget);
+        scheduleAfterCommit(() => {
+            if (this.parent) {
+                this.attachChild(widget);
+            }
+        }, CommitPriority.NORMAL);
+    }
+    insertBefore(child, _before) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot insert '${child.typeName}' into '${this.typeName}': expected Widget`);
         }
+        const widget = child.container;
+        this.children.add(widget);
+        scheduleAfterCommit(() => {
+            if (this.parent) {
+                this.attachChild(widget);
+            }
+        }, CommitPriority.NORMAL);
     }
-    onChildChange(oldChild) {
-        const overlay = this.getOverlay();
-        batch(() => {
-            if (oldChild) {
-                const parent = oldChild.getParent();
-                if (parent && isObjectEqual(parent, overlay)) {
-                    overlay.removeOverlay(oldChild);
+    removeChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot remove '${child.typeName}' from '${this.typeName}': expected Widget`);
+        }
+        const widget = child.container;
+        const parent = this.parent;
+        this.children.delete(widget);
+        scheduleAfterCommit(() => {
+            if (parent) {
+                const currentParent = widget.getParent();
+                if (currentParent && isObjectEqual(currentParent, parent)) {
+                    parent.removeOverlay(widget);
                 }
             }
-            if (this.child) {
-                overlay.addOverlay(this.child);
-                if (this.props.measure !== undefined) {
-                    overlay.setMeasureOverlay(this.child, this.props.measure);
+        }, CommitPriority.HIGH);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        if (!this.parent) {
+            return;
+        }
+        const measureChanged = oldProps?.measure !== newProps.measure;
+        const clipOverlayChanged = oldProps?.clipOverlay !== newProps.clipOverlay;
+        if (measureChanged || clipOverlayChanged) {
+            const parent = this.parent;
+            for (const child of this.children) {
+                if (measureChanged) {
+                    parent.setMeasureOverlay(child, newProps.measure ?? false);
                 }
-                if (this.props.clipOverlay !== undefined) {
-                    overlay.setClipOverlay(this.child, this.props.clipOverlay);
+                if (clipOverlayChanged) {
+                    parent.setClipOverlay(child, newProps.clipOverlay ?? false);
                 }
             }
-        });
+        }
+    }
+    attachChild(widget) {
+        if (!this.parent) {
+            return;
+        }
+        this.parent.addOverlay(widget);
+        if (this.props.measure !== undefined) {
+            this.parent.setMeasureOverlay(widget, this.props.measure);
+        }
+        if (this.props.clipOverlay !== undefined) {
+            this.parent.setClipOverlay(widget, this.props.clipOverlay);
+        }
     }
 }
 registerNodeClass(OverlayChildNode);

package/dist/nodes/pack-child.d.ts

@@ -1,14 +1 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-import { VirtualChildNode } from "./virtual-child.js";
-type PackableWidget = Gtk.Widget & {
-    packStart(child: Gtk.Widget): void;
-    packEnd(child: Gtk.Widget): void;
-    remove(child: Gtk.Widget): void;
-};
-export declare class PackChild extends VirtualChildNode<PackableWidget> {
-    static priority: number;
-    static matches(type: string): boolean;
-    protected getPositionLabel(): string;
-    protected attachChild(parent: PackableWidget, widget: Gtk.Widget): void;
-}
 export {};

package/dist/nodes/pack-child.js

@@ -1,20 +1,22 @@
 import { registerNodeClass } from "../registry.js";
-import { VirtualChildNode } from "./virtual-child.js";
-export class PackChild extends VirtualChildNode {
+import { VirtualContainerNode } from "./abstract/virtual-container.js";
+class PackStartNode extends VirtualContainerNode {
     static priority = 1;
     static matches(type) {
-        return type === "PackStart" || type === "PackEnd";
+        return type === "PackStart";
     }
-    getPositionLabel() {
-        return this.typeName === "PackStart" ? "start" : "end";
+    attachChild(parent, widget) {
+        parent.packStart(widget);
+    }
+}
+class PackEndNode extends VirtualContainerNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "PackEnd";
     }
     attachChild(parent, widget) {
-        if (this.getPositionLabel() === "start") {
-            parent.packStart(widget);
-        }
-        else {
-            parent.packEnd(widget);
-        }
+        parent.packEnd(widget);
     }
 }
-registerNodeClass(PackChild);
+registerNodeClass(PackStartNode);
+registerNodeClass(PackEndNode);

package/dist/nodes/pack.d.ts

@@ -1 +1,6 @@
-export {};
+import type * as Gtk from "@gtkx/ffi/gtk";
+export type PackableWidget = Gtk.Widget & {
+    packStart(child: Gtk.Widget): void;
+    packEnd(child: Gtk.Widget): void;
+    remove(child: Gtk.Widget): void;
+};

package/dist/nodes/pack.js

@@ -1,46 +1,13 @@
 import { PACK_INTERFACE_METHODS } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
+import { PositionalParentNode } from "./abstract/positional-parent.js";
 import { matchesInterface } from "./internal/utils.js";
-import { PackChild } from "./pack-child.js";
-import { SlotNode } from "./slot.js";
-import { WidgetNode } from "./widget.js";
-class PackNode extends WidgetNode {
+class PackNode extends PositionalParentNode {
     static priority = 0;
+    acceptedPositionalChildTypes = new Set(["PackStart", "PackEnd"]);
+    containerTypeName = "Pack";
     static matches(_type, containerOrClass) {
         return matchesInterface(PACK_INTERFACE_METHODS, containerOrClass);
     }
-    appendChild(child) {
-        if (child instanceof PackChild) {
-            child.setParent(this.container);
-            return;
-        }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.appendChild(child);
-            return;
-        }
-        throw new Error(`Cannot append '${child.typeName}' to 'Pack': expected x.PackStart, x.PackEnd, or Widget`);
-    }
-    insertBefore(child, before) {
-        if (child instanceof PackChild) {
-            child.setParent(this.container);
-            return;
-        }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.insertBefore(child, before);
-            return;
-        }
-        throw new Error(`Cannot insert '${child.typeName}' into 'Pack': expected x.PackStart, x.PackEnd, or Widget`);
-    }
-    removeChild(child) {
-        if (child instanceof PackChild) {
-            child.unmount();
-            return;
-        }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.removeChild(child);
-            return;
-        }
-        throw new Error(`Cannot remove '${child.typeName}' from 'Pack': expected x.PackStart, x.PackEnd, or Widget`);
-    }
 }
 registerNodeClass(PackNode);

package/dist/nodes/popover-menu.js

@@ -4,7 +4,7 @@ import { POPOVER_MENU_CLASSES } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
 import { matchesAnyClass } from "./internal/utils.js";
 import { MenuNode } from "./menu.js";
-import { Menu } from "./models/menu.js";
+import { MenuModel } from "./models/menu.js";
 import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
 const ACTION_PREFIX = "menu";
@@ -20,7 +20,7 @@ class PopoverMenuNode extends WidgetNode {
         const actionGroup = new Gio.SimpleActionGroup();
         const prefix = application ? "app" : ACTION_PREFIX;
         this.container.insertActionGroup(prefix, actionGroup);
-        this.menu = new Menu("root", {}, actionGroup, application);
+        this.menu = new MenuModel("root", {}, rootContainer, actionGroup, application);
         this.container.setMenuModel(this.menu.getMenu());
     }
     appendChild(child) {

package/dist/nodes/scale.js

@@ -1,70 +1,27 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
-import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
-import { isContainerType } from "./internal/utils.js";
-import { ScaleMarkNode } from "./scale-mark.js";
-import { SlotNode } from "./slot.js";
-import { WidgetNode } from "./widget.js";
-class ScaleNode extends WidgetNode {
+import { AdjustableNode } from "./adjustable.js";
+import { matchesAnyClass, shallowArrayEqual } from "./internal/utils.js";
+class ScaleNode extends AdjustableNode {
     static priority = 1;
-    markChildren = [];
+    appliedMarks = [];
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.Scale, containerOrClass);
+        return matchesAnyClass([Gtk.Scale], containerOrClass);
     }
-    appendChild(child) {
-        if (child instanceof ScaleMarkNode) {
-            child.setScale(this.container, () => this.scheduleRebuildAllMarks());
-            this.markChildren.push(child);
-            scheduleAfterCommit(() => child.addMark());
-            return;
-        }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.appendChild(child);
-            return;
-        }
-        throw new Error(`Cannot append '${child.typeName}' to 'Scale': expected x.ScaleMark or Widget`);
+    applyOwnProps(oldProps, newProps) {
+        super.applyOwnProps(oldProps, newProps);
+        this.applyMarks(newProps);
     }
-    insertBefore(child, before) {
-        if (child instanceof ScaleMarkNode) {
-            child.setScale(this.container, () => this.scheduleRebuildAllMarks());
-            const beforeIndex = this.markChildren.indexOf(before);
-            if (beforeIndex >= 0) {
-                this.markChildren.splice(beforeIndex, 0, child);
-            }
-            else {
-                this.markChildren.push(child);
-            }
-            this.scheduleRebuildAllMarks();
+    applyMarks(newProps) {
+        const newMarks = newProps.marks ?? [];
+        if (shallowArrayEqual(this.appliedMarks, newMarks)) {
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.insertBefore(child, before);
-            return;
+        this.container.clearMarks();
+        for (const mark of newMarks) {
+            this.container.addMark(mark.value, mark.position ?? Gtk.PositionType.BOTTOM, mark.label);
         }
-        throw new Error(`Cannot insert '${child.typeName}' into 'Scale': expected x.ScaleMark or Widget`);
-    }
-    removeChild(child) {
-        if (child instanceof ScaleMarkNode) {
-            const index = this.markChildren.indexOf(child);
-            if (index >= 0) {
-                this.markChildren.splice(index, 1);
-            }
-            this.scheduleRebuildAllMarks(CommitPriority.HIGH);
-            return;
-        }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.removeChild(child);
-            return;
-        }
-        throw new Error(`Cannot remove '${child.typeName}' from 'Scale': expected x.ScaleMark or Widget`);
-    }
-    scheduleRebuildAllMarks(priority = CommitPriority.NORMAL) {
-        scheduleAfterCommit(() => {
-            this.container.clearMarks();
-            for (const mark of this.markChildren) {
-                mark.addMark();
-            }
-        }, priority);
+        this.appliedMarks = [...newMarks];
     }
 }
 registerNodeClass(ScaleNode);

package/dist/nodes/scrolled-window.js

@@ -1,21 +1,23 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
-import { filterProps, isContainerType } from "./internal/utils.js";
+import { filterProps, hasChanged, matchesAnyClass } from "./internal/utils.js";
 import { WidgetNode } from "./widget.js";
 const PROPS = ["hscrollbarPolicy", "vscrollbarPolicy"];
 class ScrolledWindowNode extends WidgetNode {
     static priority = 2;
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.ScrolledWindow, containerOrClass);
+        return matchesAnyClass([Gtk.ScrolledWindow], containerOrClass);
     }
     updateProps(oldProps, newProps) {
-        if (oldProps?.hscrollbarPolicy !== newProps.hscrollbarPolicy ||
-            oldProps?.vscrollbarPolicy !== newProps.vscrollbarPolicy) {
+        super.updateProps(oldProps ? filterProps(oldProps, PROPS) : null, filterProps(newProps, PROPS));
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (hasChanged(oldProps, newProps, "hscrollbarPolicy") || hasChanged(oldProps, newProps, "vscrollbarPolicy")) {
             const hPolicy = newProps.hscrollbarPolicy ?? Gtk.PolicyType.AUTOMATIC;
             const vPolicy = newProps.vscrollbarPolicy ?? Gtk.PolicyType.AUTOMATIC;
             this.container.setPolicy(hPolicy, vPolicy);
         }
-        super.updateProps(filterProps(oldProps ?? {}, PROPS), filterProps(newProps, PROPS));
     }
 }
 registerNodeClass(ScrolledWindowNode);

package/dist/nodes/search-bar.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/nodes/search-bar.js

@@ -0,0 +1,40 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { filterProps, hasChanged, matchesAnyClass } from "./internal/utils.js";
+import { WidgetNode } from "./widget.js";
+const OWN_PROPS = ["onSearchModeChanged"];
+class SearchBarNode extends WidgetNode {
+    static priority = 1;
+    notifyHandler = null;
+    static matches(_type, containerOrClass) {
+        return matchesAnyClass([Gtk.SearchBar], containerOrClass);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        if (hasChanged(oldProps, newProps, "onSearchModeChanged")) {
+            this.setupNotifyHandler(newProps.onSearchModeChanged);
+        }
+    }
+    setupNotifyHandler(callback) {
+        if (this.notifyHandler) {
+            this.signalStore.set(this, this.container, "notify", undefined);
+            this.notifyHandler = null;
+        }
+        if (callback) {
+            this.notifyHandler = (_searchBar, pspec) => {
+                if (pspec.getName() === "search-mode-enabled") {
+                    callback(this.container.getSearchMode());
+                }
+            };
+            this.signalStore.set(this, this.container, "notify", this.notifyHandler);
+        }
+    }
+    unmount() {
+        if (this.notifyHandler) {
+            this.signalStore.set(this, this.container, "notify", undefined);
+            this.notifyHandler = null;
+        }
+        super.unmount();
+    }
+}
+registerNodeClass(SearchBarNode);

package/dist/nodes/shortcut-controller.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/nodes/shortcut-controller.js

@@ -0,0 +1,90 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { hasChanged } from "./internal/utils.js";
+import { ShortcutNode } from "./shortcut.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+class ShortcutControllerNode extends VirtualNode {
+    static priority = 0;
+    static matches(type) {
+        return type === "GtkShortcutController";
+    }
+    controller = null;
+    parentWidget = null;
+    shortcuts = [];
+    setParent(widget) {
+        if (this.parentWidget && this.controller) {
+            this.parentWidget.removeController(this.controller);
+        }
+        this.parentWidget = widget;
+        if (widget) {
+            this.controller = new Gtk.ShortcutController();
+            this.applyScope();
+            widget.addController(this.controller);
+            for (const shortcut of this.shortcuts) {
+                this.addShortcutToController(shortcut);
+            }
+        }
+        else {
+            this.controller = null;
+        }
+    }
+    appendChild(child) {
+        if (!(child instanceof ShortcutNode)) {
+            throw new Error(`ShortcutController only accepts Shortcut children, got '${child.typeName}'`);
+        }
+        this.shortcuts.push(child);
+        if (this.controller) {
+            this.addShortcutToController(child);
+        }
+    }
+    removeChild(child) {
+        if (!(child instanceof ShortcutNode))
+            return;
+        const index = this.shortcuts.indexOf(child);
+        if (index !== -1) {
+            this.shortcuts.splice(index, 1);
+            if (this.controller && child.shortcut) {
+                this.controller.removeShortcut(child.shortcut);
+            }
+        }
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (hasChanged(oldProps, newProps, "scope")) {
+            this.applyScope();
+        }
+    }
+    unmount() {
+        this.setParent(null);
+        super.unmount();
+    }
+    canBeChildOf(parent) {
+        return parent instanceof WidgetNode;
+    }
+    attachTo(parent) {
+        if (parent instanceof WidgetNode) {
+            this.setParent(parent.container);
+        }
+    }
+    detachFrom(_parent) {
+        this.setParent(null);
+    }
+    applyScope() {
+        if (!this.controller)
+            return;
+        this.controller.setScope(this.props.scope ?? Gtk.ShortcutScope.LOCAL);
+    }
+    addShortcutToController(node) {
+        if (!this.controller)
+            return;
+        node.createShortcut();
+        if (node.shortcut) {
+            this.controller.addShortcut(node.shortcut);
+        }
+    }
+}
+registerNodeClass(ShortcutControllerNode);