@gtkx/react 0.15.0 → 0.17.1

package/dist/nodes/column-view.js

@@ -2,24 +2,23 @@ import * as Gtk from "@gtkx/ffi/gtk";
 import { COLUMN_VIEW_CLASSES } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
 import { ColumnViewColumnNode } from "./column-view-column.js";
-import { signalStore } from "./internal/signal-store.js";
 import { filterProps, matchesAnyClass } from "./internal/utils.js";
 import { ListItemNode } from "./list-item.js";
-import { List } from "./models/list.js";
+import { ListModel } from "./models/list.js";
 import { WidgetNode } from "./widget.js";
 const PROP_NAMES = ["sortColumn", "sortOrder", "onSortChanged", "estimatedRowHeight"];
 class ColumnViewNode extends WidgetNode {
     static priority = 1;
-    handleSortChange;
+    handleSortChange = null;
     list;
     columnNodes = new Set();
-    estimatedRowHeight;
+    estimatedRowHeight = null;
     static matches(_type, containerOrClass) {
         return matchesAnyClass(COLUMN_VIEW_CLASSES, containerOrClass);
     }
     constructor(typeName, props, container, rootContainer) {
         super(typeName, props, container, rootContainer);
-        this.list = new List({
+        this.list = new ListModel({ owner: this, signalStore: this.signalStore }, {
             selectionMode: props.selectionMode,
             selected: props.selected,
             onSelectionChanged: props.onSelectionChanged,
@@ -41,9 +40,9 @@ class ColumnViewNode extends WidgetNode {
         if (existingColumn) {
             this.container.removeColumn(existingColumn);
         }
-        this.container.appendColumn(child.column);
         child.setStore(this.list.getStore());
         child.setEstimatedRowHeight(this.estimatedRowHeight);
+        this.container.appendColumn(child.column);
         this.columnNodes.add(child);
     }
     insertBefore(child, before) {
@@ -58,6 +57,8 @@ class ColumnViewNode extends WidgetNode {
         if (existingColumn) {
             this.container.removeColumn(existingColumn);
         }
+        child.setStore(this.list.getStore());
+        child.setEstimatedRowHeight(this.estimatedRowHeight);
         if (before instanceof ColumnViewColumnNode) {
             const beforeIndex = this.getColumnIndex(before.column);
             this.container.insertColumn(beforeIndex, child.column);
@@ -65,8 +66,6 @@ class ColumnViewNode extends WidgetNode {
         else {
             this.container.appendColumn(child.column);
         }
-        child.setStore(this.list.getStore());
-        child.setEstimatedRowHeight(this.estimatedRowHeight);
         this.columnNodes.add(child);
     }
     removeChild(child) {
@@ -81,10 +80,15 @@ class ColumnViewNode extends WidgetNode {
         if (existingColumn) {
             this.container.removeColumn(existingColumn);
         }
-        child.setStore(undefined);
+        child.setStore(null);
         this.columnNodes.delete(child);
     }
     updateProps(oldProps, newProps) {
+        super.updateProps(oldProps ? filterProps(oldProps, PROP_NAMES) : null, filterProps(newProps, PROP_NAMES));
+        this.applyOwnProps(oldProps, newProps);
+        this.list.updateProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
         if (!oldProps || oldProps.onSortChanged !== newProps.onSortChanged) {
             const sorter = this.container.getSorter();
             const onSortChanged = newProps.onSortChanged;
@@ -92,7 +96,7 @@ class ColumnViewNode extends WidgetNode {
                 this.handleSortChange = () => {
                     onSortChanged?.(sorter.getPrimarySortColumn()?.getId() ?? null, sorter.getPrimarySortOrder());
                 };
-                signalStore.set(this, sorter, "changed", this.handleSortChange);
+                this.signalStore.set(this, sorter, "changed", this.handleSortChange);
             }
         }
         if (!oldProps || oldProps.sortColumn !== newProps.sortColumn || oldProps.sortOrder !== newProps.sortOrder) {
@@ -106,51 +110,44 @@ class ColumnViewNode extends WidgetNode {
             }
         }
         if (!oldProps || oldProps.estimatedRowHeight !== newProps.estimatedRowHeight) {
-            this.estimatedRowHeight = newProps.estimatedRowHeight;
+            this.estimatedRowHeight = newProps.estimatedRowHeight ?? null;
             for (const column of this.columnNodes) {
                 column.setEstimatedRowHeight(this.estimatedRowHeight);
             }
         }
-        this.list.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
-        super.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
     }
-    getColumn(columnId) {
+    findColumn(predicate) {
         const columns = this.container.getColumns();
         for (let i = 0; i < columns.getNItems(); i++) {
             const column = columns.getObject(i);
-            if (column.getId() === columnId) {
-                return column;
-            }
+            const result = predicate(column, i);
+            if (result !== null)
+                return result;
         }
-        throw new Error(`Unable to find column '${columnId}' in ColumnView`);
+        return null;
     }
-    getColumnIndex(column) {
-        const index = this.findColumnIndex(column);
-        if (index === -1) {
-            throw new Error(`Unable to find column '${column.getId()}' in ColumnView`);
+    getColumn(columnId) {
+        const column = this.findColumn((col) => (col.getId() === columnId ? col : null));
+        if (!column) {
+            throw new Error(`Unable to find column '${columnId}' in ColumnView`);
         }
-        return index;
+        return column;
     }
-    findColumnIndex(column) {
-        const columns = this.container.getColumns();
-        for (let i = 0; i < columns.getNItems(); i++) {
-            const col = columns.getObject(i);
-            if (col.getId() === column.getId()) {
-                return i;
-            }
+    getColumnIndex(column) {
+        const targetId = column.getId();
+        const index = this.findColumn((col, i) => (col.getId() === targetId ? i : null));
+        if (index === null) {
+            throw new Error(`Unable to find column '${targetId}' in ColumnView`);
         }
-        return -1;
+        return index;
     }
     findColumnInView(column) {
-        const columns = this.container.getColumns();
         const targetId = column.getId();
-        for (let i = 0; i < columns.getNItems(); i++) {
-            const col = columns.getObject(i);
-            if (col.getId() === targetId) {
-                return col;
-            }
-        }
-        return null;
+        return this.findColumn((col) => (col.getId() === targetId ? col : null));
+    }
+    unmount() {
+        this.columnNodes.clear();
+        super.unmount();
     }
 }
 registerNodeClass(ColumnViewNode);

package/dist/nodes/dialog.d.ts

@@ -0,0 +1,11 @@
+import * as Adw from "@gtkx/ffi/adw";
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Container, ContainerClass } from "../types.js";
+import { WidgetNode } from "./widget.js";
+export declare class DialogNode extends WidgetNode<Adw.Dialog> {
+    static priority: number;
+    parent: Gtk.Window | null;
+    static matches(_type: string, containerOrClass?: Container | ContainerClass | null): boolean;
+    mount(): void;
+    unmount(): void;
+}

package/dist/nodes/dialog.js

@@ -0,0 +1,20 @@
+import * as Adw from "@gtkx/ffi/adw";
+import { registerNodeClass } from "../registry.js";
+import { matchesAnyClass } from "./internal/utils.js";
+import { WidgetNode } from "./widget.js";
+export class DialogNode extends WidgetNode {
+    static priority = 1;
+    parent = null;
+    static matches(_type, containerOrClass) {
+        return matchesAnyClass([Adw.Dialog], containerOrClass);
+    }
+    mount() {
+        this.container.present(this.parent ?? undefined);
+        super.mount();
+    }
+    unmount() {
+        this.container.forceClose();
+        super.unmount();
+    }
+}
+registerNodeClass(DialogNode);

package/dist/nodes/drawing-area.js

@@ -1,19 +1,36 @@
 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 = ["onDraw"];
+const OWN_PROPS = ["onDraw"];
 class DrawingAreaNode extends WidgetNode {
     static priority = 1;
+    pendingDrawFunc = null;
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.DrawingArea, containerOrClass);
+        return matchesAnyClass([Gtk.DrawingArea], containerOrClass);
     }
     updateProps(oldProps, newProps) {
-        if (newProps.onDraw && (!oldProps || oldProps.onDraw !== newProps.onDraw)) {
-            this.container.setDrawFunc(newProps.onDraw);
-            this.container.queueDraw();
+        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (hasChanged(oldProps, newProps, "onDraw") && newProps.onDraw) {
+            if (this.container.getRealized()) {
+                this.container.setDrawFunc(newProps.onDraw);
+            }
+            else {
+                this.pendingDrawFunc = newProps.onDraw;
+                this.signalStore.set(this, this.container, "realize", this.onRealize.bind(this));
+            }
+        }
+    }
+    onRealize() {
+        if (this.pendingDrawFunc) {
+            const drawFunc = this.pendingDrawFunc;
+            this.pendingDrawFunc = null;
+            queueMicrotask(() => this.container.setDrawFunc(drawFunc));
         }
-        super.updateProps(filterProps(oldProps ?? {}, PROPS), filterProps(newProps, PROPS));
+        this.signalStore.set(this, this.container, "realize", null);
     }
 }
 registerNodeClass(DrawingAreaNode);

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

@@ -0,0 +1,22 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { Node } from "../node.js";
+import type { Container, Props } from "../types.js";
+import type { Attachable } from "./internal/predicates.js";
+export declare class EventControllerNode<T extends Gtk.EventController = Gtk.EventController> extends Node<T, Props> implements Attachable {
+    static priority: number;
+    static matches(type: string): boolean;
+    static createContainer(props: Props, containerClass: typeof Gtk.EventController): Gtk.EventController;
+    props: Props;
+    protected parentWidget: Gtk.Widget | null;
+    constructor(typeName: string, props: Props, container: T, rootContainer: Container);
+    canBeChildOf(parent: Node): boolean;
+    appendChild(_child: Node): void;
+    removeChild(_child: Node): void;
+    insertBefore(_child: Node, _before: Node): void;
+    attachTo(parent: Node): void;
+    detachFrom(_parent: Node): void;
+    updateProps(oldProps: Props | null, newProps: Props): void;
+    unmount(): void;
+    private applyProps;
+    private setProperty;
+}

package/dist/nodes/event-controller.js

@@ -0,0 +1,96 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { CONTROLLER_CLASSES, CONTROLLER_CONSTRUCTOR_PROPS } from "../generated/internal.js";
+import { Node } from "../node.js";
+import { registerNodeClass } from "../registry.js";
+import { propNameToSignalName, resolvePropMeta, resolveSignal } from "./internal/utils.js";
+import { WidgetNode } from "./widget.js";
+const G_TYPE_INVALID = 0;
+export class EventControllerNode extends Node {
+    static priority = 1;
+    static matches(type) {
+        return type in CONTROLLER_CLASSES;
+    }
+    static createContainer(props, containerClass) {
+        const typeName = containerClass.glibTypeName;
+        if (typeName === "GtkDropTarget") {
+            const actions = props.actions ?? 0;
+            return new Gtk.DropTarget(G_TYPE_INVALID, actions);
+        }
+        const args = (CONTROLLER_CONSTRUCTOR_PROPS[typeName] ?? []).map((name) => props[name]);
+        // biome-ignore lint/suspicious/noExplicitAny: Dynamic constructor invocation
+        return new containerClass(...args);
+    }
+    props;
+    parentWidget = null;
+    constructor(typeName, props, container, rootContainer) {
+        super(typeName, props, container, rootContainer);
+        this.props = props;
+    }
+    canBeChildOf(parent) {
+        return parent instanceof WidgetNode;
+    }
+    appendChild(_child) { }
+    removeChild(_child) { }
+    insertBefore(_child, _before) { }
+    attachTo(parent) {
+        if (parent instanceof WidgetNode) {
+            this.parentWidget = parent.container;
+            parent.container.addController(this.container);
+        }
+    }
+    detachFrom(_parent) {
+        if (this.parentWidget) {
+            this.parentWidget.removeController(this.container);
+        }
+        this.parentWidget = null;
+    }
+    updateProps(oldProps, newProps) {
+        this.props = newProps;
+        this.applyProps(oldProps, newProps);
+    }
+    unmount() {
+        if (this.parentWidget) {
+            this.parentWidget.removeController(this.container);
+        }
+        this.parentWidget = null;
+        super.unmount();
+    }
+    applyProps(oldProps, newProps) {
+        if (!this.container) {
+            throw new Error(`EventControllerNode.applyProps: container is undefined for ${this.typeName}`);
+        }
+        const propNames = new Set([...Object.keys(oldProps ?? {}), ...Object.keys(newProps ?? {})]);
+        for (const name of propNames) {
+            if (name === "children")
+                continue;
+            const oldValue = oldProps?.[name];
+            const newValue = newProps[name];
+            if (oldValue === newValue)
+                continue;
+            const signalName = propNameToSignalName(name);
+            if (resolveSignal(this.container, signalName)) {
+                const handler = typeof newValue === "function" ? newValue : undefined;
+                this.signalStore.set(this, this.container, signalName, handler, { blockable: false });
+            }
+            else if (newValue !== undefined) {
+                this.setProperty(name, newValue);
+            }
+        }
+    }
+    setProperty(name, value) {
+        if (name === "types" && this.container instanceof Gtk.DropTarget) {
+            const types = value;
+            this.container.setGtypes(types.length, types);
+            return;
+        }
+        const propMeta = resolvePropMeta(this.container, name);
+        if (propMeta) {
+            const [, setterName] = propMeta;
+            const setterFn = this.container[setterName];
+            if (typeof setterFn === "function") {
+                setterFn.call(this.container, value);
+            }
+        }
+    }
+}
+registerNodeClass(EventControllerNode);

package/dist/nodes/expander-row-child.d.ts

@@ -1,15 +1 @@
-import type * as Adw from "@gtkx/ffi/adw";
-import type * as Gtk from "@gtkx/ffi/gtk";
-import { VirtualChildNode } from "./virtual-child.js";
-type ExpanderRowWidget = Adw.ExpanderRow & {
-    addRow(child: Gtk.Widget): void;
-    addAction(widget: Gtk.Widget): void;
-    remove(child: Gtk.Widget): void;
-};
-export declare class ExpanderRowChild extends VirtualChildNode<ExpanderRowWidget> {
-    static priority: number;
-    static matches(type: string): boolean;
-    protected getPositionLabel(): string;
-    protected attachChild(parent: ExpanderRowWidget, widget: Gtk.Widget): void;
-}
 export {};

package/dist/nodes/expander-row-child.js

@@ -1,20 +1,30 @@
 import { registerNodeClass } from "../registry.js";
-import { VirtualChildNode } from "./virtual-child.js";
-export class ExpanderRowChild extends VirtualChildNode {
+import { VirtualContainerNode } from "./abstract/virtual-container.js";
+import { matchesInterface } from "./internal/utils.js";
+const EXPANDER_ROW_INTERFACE_METHODS = ["addRow", "addAction", "remove"];
+class ExpanderRowRowNode extends VirtualContainerNode {
     static priority = 1;
     static matches(type) {
-        return type === "ExpanderRowRow" || type === "ExpanderRowAction";
+        return type === "ExpanderRowRow";
     }
-    getPositionLabel() {
-        return this.typeName === "ExpanderRowRow" ? "row" : "action";
+    canBeChildOf(parent) {
+        return matchesInterface(EXPANDER_ROW_INTERFACE_METHODS, parent.container);
     }
     attachChild(parent, widget) {
-        if (this.getPositionLabel() === "row") {
-            parent.addRow(widget);
-        }
-        else {
-            parent.addAction(widget);
-        }
+        parent.addRow(widget);
     }
 }
-registerNodeClass(ExpanderRowChild);
+class ExpanderRowActionNode extends VirtualContainerNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "ExpanderRowAction";
+    }
+    canBeChildOf(parent) {
+        return matchesInterface(EXPANDER_ROW_INTERFACE_METHODS, parent.container);
+    }
+    attachChild(parent, widget) {
+        parent.addAction(widget);
+    }
+}
+registerNodeClass(ExpanderRowRowNode);
+registerNodeClass(ExpanderRowActionNode);

package/dist/nodes/fixed-child.js

@@ -1,53 +1,69 @@
-import { batch, isObjectEqual } from "@gtkx/ffi";
+import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
-import { SlotNode } from "./slot.js";
-class FixedChildNode extends SlotNode {
+import { PositionalChildNode } from "./abstract/positional-child.js";
+import { hasChanged } from "./internal/utils.js";
+class FixedChildNode extends PositionalChildNode {
     static priority = 1;
     static matches(type) {
         return type === "FixedChild";
     }
-    getFixed() {
-        if (!this.parent) {
-            throw new Error("Expected Fixed reference to be set on FixedChildNode");
+    canBeChildOf(parent) {
+        return parent.container instanceof Gtk.Fixed;
+    }
+    onChildChange(oldChild) {
+        super.onChildChange(oldChild);
+        if (this.child) {
+            this.applyTransform();
         }
-        return this.parent;
+    }
+    attachToParent(parent, child) {
+        const fixed = parent;
+        const x = this.props.x ?? 0;
+        const y = this.props.y ?? 0;
+        fixed.put(child, x, y);
+    }
+    detachFromParent(parent, child) {
+        parent.remove(child);
     }
     updateProps(oldProps, newProps) {
         super.updateProps(oldProps, newProps);
-        if (!oldProps || oldProps.x !== newProps.x || oldProps.y !== newProps.y) {
-            if (this.parent && this.child) {
-                this.positionChild();
-            }
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (!this.parent || !this.child) {
+            return;
+        }
+        const positionChanged = hasChanged(oldProps, newProps, "x") || hasChanged(oldProps, newProps, "y");
+        if (positionChanged) {
+            this.repositionChild();
+        }
+        else if (hasChanged(oldProps, newProps, "transform")) {
+            this.applyTransform();
         }
     }
-    positionChild() {
-        const fixed = this.getFixed();
+    repositionChild() {
+        const fixed = this.getTypedParent();
+        const child = this.child;
+        if (!child) {
+            return;
+        }
         const x = this.props.x ?? 0;
         const y = this.props.y ?? 0;
-        if (this.child) {
-            const child = this.child;
-            batch(() => {
-                const currentParent = child.getParent();
-                if (currentParent && isObjectEqual(currentParent, fixed)) {
-                    fixed.remove(child);
-                }
-                fixed.put(child, x, y);
-            });
-        }
+        fixed.remove(child);
+        fixed.put(child, x, y);
+        this.applyTransform();
     }
-    onChildChange(oldChild) {
-        const fixed = this.getFixed();
-        batch(() => {
-            if (oldChild) {
-                const parent = oldChild.getParent();
-                if (parent && isObjectEqual(parent, fixed)) {
-                    fixed.remove(oldChild);
-                }
-            }
-            if (this.child) {
-                this.positionChild();
-            }
-        });
+    applyTransform() {
+        if (!this.child || !this.props.transform) {
+            return;
+        }
+        const fixed = this.getTypedParent();
+        const layoutManager = fixed.getLayoutManager();
+        if (!layoutManager) {
+            return;
+        }
+        const layoutChild = layoutManager.getLayoutChild(this.child);
+        layoutChild.setTransform(this.props.transform);
     }
 }
 registerNodeClass(FixedChildNode);

package/dist/nodes/font-dialog-button.d.ts

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

package/dist/nodes/font-dialog-button.js

@@ -0,0 +1,90 @@
+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 = [
+    "fontDesc",
+    "onFontDescChanged",
+    "title",
+    "modal",
+    "language",
+    "useFont",
+    "useSize",
+    "level",
+];
+class FontDialogButtonNode extends WidgetNode {
+    static priority = 1;
+    dialog;
+    notifyHandler = null;
+    static matches(_type, containerOrClass) {
+        return matchesAnyClass([Gtk.FontDialogButton], containerOrClass);
+    }
+    static createContainer(_props, containerClass) {
+        const dialog = new Gtk.FontDialog();
+        const button = new containerClass(dialog);
+        return button;
+    }
+    constructor(type, props, container, rootContainer) {
+        super(type, props, container, rootContainer);
+        const dialog = container.getDialog();
+        if (!dialog) {
+            throw new Error("FontDialogButton must have a dialog");
+        }
+        this.dialog = dialog;
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (hasChanged(oldProps, newProps, "title") && newProps.title !== undefined) {
+            this.dialog.setTitle(newProps.title);
+        }
+        if (hasChanged(oldProps, newProps, "modal")) {
+            this.dialog.setModal(newProps.modal ?? true);
+        }
+        if (hasChanged(oldProps, newProps, "language") && newProps.language) {
+            this.dialog.setLanguage(newProps.language);
+        }
+        if (hasChanged(oldProps, newProps, "useFont")) {
+            this.container.setUseFont(newProps.useFont ?? false);
+        }
+        if (hasChanged(oldProps, newProps, "useSize")) {
+            this.container.setUseSize(newProps.useSize ?? false);
+        }
+        if (hasChanged(oldProps, newProps, "level")) {
+            this.container.setLevel(newProps.level ?? Gtk.FontLevel.FONT);
+        }
+        if (hasChanged(oldProps, newProps, "fontDesc") && newProps.fontDesc) {
+            this.container.setFontDesc(newProps.fontDesc);
+        }
+        if (hasChanged(oldProps, newProps, "onFontDescChanged")) {
+            this.setupNotifyHandler(newProps.onFontDescChanged);
+        }
+    }
+    setupNotifyHandler(callback) {
+        if (this.notifyHandler) {
+            this.signalStore.set(this, this.container, "notify", undefined);
+            this.notifyHandler = null;
+        }
+        if (callback) {
+            this.notifyHandler = (_button, pspec) => {
+                if (pspec.getName() === "font-desc") {
+                    const fontDesc = this.container.getFontDesc();
+                    if (fontDesc) {
+                        callback(fontDesc);
+                    }
+                }
+            };
+            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(FontDialogButtonNode);