@gtkx/react 0.19.0 → 0.20.0

package/src/node.ts

@@ -14,8 +14,6 @@ export class Node<TContainer = any, TProps = any, TParent extends Node = any, TC
     rootContainer: Container;
     parent: TParent | null = null;
     children: TChild[] = [];
-    private childIndices = new Map<TChild, number>();
-    private childrenDirty = false;
 
     constructor(typeName: string, props: TProps, container: TContainer, rootContainer: Container) {
         this.typeName = typeName;
@@ -37,6 +35,7 @@ export class Node<TContainer = any, TProps = any, TParent extends Node = any, TC
         if (parent !== null && !this.isValidParent(parent)) {
             throw new Error(`Cannot add '${this.typeName}' to '${parent.typeName}'`);
         }
+
         this.parent = parent;
     }
 
@@ -45,64 +44,49 @@ export class Node<TContainer = any, TProps = any, TParent extends Node = any, TC
     }
 
     public appendChild(child: TChild): void {
-        if (this.childrenDirty) this.flushChildRemovals();
         if (!this.isValidChild(child)) {
             throw new Error(`Cannot append '${child.typeName}' to '${this.typeName}'`);
         }
-        this.childIndices.set(child, this.children.length);
+
+        const existingIndex = this.children.indexOf(child);
+        if (existingIndex !== -1) {
+            this.children.splice(existingIndex, 1);
+        }
         this.children.push(child);
-        child.setParent(this);
+
+        if (child.parent !== this) {
+            child.setParent(this);
+        }
     }
 
     public removeChild(child: TChild): void {
-        if (!this.childIndices.has(child)) return;
         child.setParent(null);
-        this.childIndices.delete(child);
-        if (!this.childrenDirty) {
-            this.childrenDirty = true;
-            queueMicrotask(() => this.flushChildRemovals());
+        const index = this.children.indexOf(child);
+
+        if (index !== -1) {
+            this.children.splice(index, 1);
         }
     }
 
     public insertBefore(child: TChild, before: TChild): void {
-        if (this.childrenDirty) this.flushChildRemovals();
-
-        const beforeIndex = this.childIndices.get(before);
-        if (beforeIndex === undefined) {
-            throw new Error(`Cannot find 'before' child '${before.typeName}' in '${this.typeName}'`);
+        if (!this.isValidChild(child)) {
+            throw new Error(`Cannot insert '${child.typeName}' into '${this.typeName}'`);
         }
 
-        const existingIndex = this.childIndices.get(child);
-        if (existingIndex !== undefined) {
+        const existingIndex = this.children.indexOf(child);
+        if (existingIndex !== -1) {
             this.children.splice(existingIndex, 1);
-            const adjustedIndex = existingIndex < beforeIndex ? beforeIndex - 1 : beforeIndex;
-            this.children.splice(adjustedIndex, 0, child);
-            this.rebuildChildIndices(Math.min(existingIndex, adjustedIndex));
-            return;
         }
 
-        if (!this.isValidChild(child)) {
-            throw new Error(`Cannot insert '${child.typeName}' into '${this.typeName}'`);
+        const beforeIndex = this.children.indexOf(before);
+        if (beforeIndex === -1) {
+            throw new Error(`Cannot find 'before' child '${before.typeName}' in '${this.typeName}'`);
         }
 
         this.children.splice(beforeIndex, 0, child);
-        this.rebuildChildIndices(beforeIndex);
-        child.setParent(this);
-    }
-
-    private flushChildRemovals(): void {
-        if (!this.childrenDirty) return;
-        this.childrenDirty = false;
-        this.children = this.children.filter((c) => this.childIndices.has(c));
-        this.childIndices.clear();
-        for (let i = 0; i < this.children.length; i++) {
-            this.childIndices.set(this.children[i] as TChild, i);
-        }
-    }
 
-    private rebuildChildIndices(fromIndex: number): void {
-        for (let i = fromIndex; i < this.children.length; i++) {
-            this.childIndices.set(this.children[i] as TChild, i);
+        if (child.parent !== this) {
+            child.setParent(this);
         }
     }
 

package/src/nodes/application.ts

@@ -3,6 +3,7 @@ import { Node } from "../node.js";
 import type { Container, Props } from "../types.js";
 import { MenuNode } from "./menu.js";
 import { MenuModel } from "./models/menu.js";
+import { WindowNode } from "./window.js";
 
 export class ApplicationNode extends Node<Gtk.Application, Props, Node, Node> {
     private menu: MenuModel;
@@ -51,6 +52,10 @@ export class ApplicationNode extends Node<Gtk.Application, Props, Node, Node> {
             return;
         }
 
+        if (child instanceof WindowNode) {
+            child.container.setVisible(false);
+        }
+
         super.removeChild(child);
     }
 }

package/src/nodes/column-view-column.ts

@@ -1,19 +1,34 @@
+import { getNativeId } from "@gtkx/ffi";
 import * as Gio from "@gtkx/ffi/gio";
+import type * as GObject from "@gtkx/ffi/gobject";
 import * as Gtk from "@gtkx/ffi/gtk";
-import type { ColumnViewColumnProps } from "../jsx.js";
+import type { ColumnViewColumnProps, ListItem } from "../jsx.js";
 import type { Node } from "../node.js";
 import type { Container } from "../types.js";
-import { GridItemRenderer } from "./internal/grid-item-renderer.js";
-import { ListItemRenderer } from "./internal/list-item-renderer.js";
-import type { ListStore } from "./internal/list-store.js";
+import type { BoundItem } from "./internal/bound-item.js";
 import { hasChanged } from "./internal/props.js";
-import type { TreeStore } from "./internal/tree-store.js";
 import { MenuNode } from "./menu.js";
 import { MenuModel } from "./models/menu.js";
 import { VirtualNode } from "./virtual.js";
 import { WidgetNode } from "./widget.js";
 
-export class ColumnViewColumnNode extends VirtualNode<ColumnViewColumnProps, WidgetNode<Gtk.ColumnView>, MenuNode> {
+const UNBOUND_POSITION = -1;
+
+export class ColumnViewColumnNode extends VirtualNode<ColumnViewColumnProps, WidgetNode, MenuNode> {
+    private column: Gtk.ColumnViewColumn | null = null;
+    private columnFactory: Gtk.SignalListItemFactory | null = null;
+    private containers = new Map<Gtk.ListItem, number>();
+    private containerKeys = new Map<Gtk.ListItem, string>();
+    private menu: MenuModel;
+    private actionGroup: Gio.SimpleActionGroup;
+
+    constructor(typeName: string, props: ColumnViewColumnProps, container: undefined, rootContainer: Container) {
+        super(typeName, props, container, rootContainer);
+        this.actionGroup = new Gio.SimpleActionGroup();
+        this.menu = new MenuModel("root", {}, rootContainer, this.actionGroup);
+        this.menu.setActionMap(this.actionGroup, props.id);
+    }
+
     public override isValidChild(child: Node): boolean {
         return child instanceof MenuNode;
     }
@@ -21,172 +36,154 @@ export class ColumnViewColumnNode extends VirtualNode<ColumnViewColumnProps, Wid
     public override isValidParent(parent: Node): boolean {
         return parent instanceof WidgetNode && parent.container instanceof Gtk.ColumnView;
     }
-    private column: Gtk.ColumnViewColumn;
-    private treeRenderer: ListItemRenderer | null;
-    private flatRenderer: GridItemRenderer | null = null;
-    private menu: MenuModel | null = null;
-    private actionGroup: Gio.SimpleActionGroup | null = null;
-    private columnView: Gtk.ColumnView | null = null;
 
-    constructor(typeName: string, props: ColumnViewColumnProps, container: undefined, rootContainer: Container) {
-        super(typeName, props, container, rootContainer);
-        this.treeRenderer = new ListItemRenderer(this.signalStore);
-        this.column = new Gtk.ColumnViewColumn();
-        this.column.setFactory(this.treeRenderer.getFactory());
+    public override finalizeInitialChildren(props: ColumnViewColumnProps): boolean {
+        this.setupFactory();
+        this.setupColumn(props);
+        this.updateHeaderMenu();
+        return false;
+    }
+
+    public override commitUpdate(oldProps: ColumnViewColumnProps | null, newProps: ColumnViewColumnProps): void {
+        super.commitUpdate(oldProps, newProps);
+        if (oldProps === null) return;
+        this.applyColumnProps(oldProps, newProps);
     }
 
     public override appendChild(child: MenuNode): void {
-        this.initMenu();
-        this.menu?.appendChild(child);
+        this.menu.appendChild(child);
+        this.updateHeaderMenu();
     }
 
     public override insertBefore(child: MenuNode, before: MenuNode): void {
-        this.initMenu();
-        if (before instanceof MenuNode) {
-            this.menu?.insertBefore(child, before);
-        } else {
-            this.menu?.appendChild(child);
-        }
+        this.menu.insertBefore(child, before);
+        this.updateHeaderMenu();
     }
 
     public override removeChild(child: MenuNode): void {
-        this.menu?.removeChild(child);
-
-        if (this.menu && this.menu.getMenu().getNItems() === 0) {
-            this.cleanupMenu();
-        }
-    }
-
-    public override commitUpdate(oldProps: ColumnViewColumnProps | null, newProps: ColumnViewColumnProps): void {
-        super.commitUpdate(oldProps, newProps);
-        this.applyOwnProps(oldProps, newProps);
+        this.menu.removeChild(child);
+        this.updateHeaderMenu();
     }
 
     public override detachDeletedInstance(): void {
-        this.cleanupMenu();
-        this.treeRenderer?.dispose();
-        this.flatRenderer?.dispose();
         super.detachDeletedInstance();
     }
 
     public getColumn(): Gtk.ColumnViewColumn {
+        if (!this.column) throw new Error("ColumnViewColumn not initialized");
         return this.column;
     }
 
-    public rebindItem(id: string): void {
-        this.treeRenderer?.rebindItem(id);
-        this.flatRenderer?.rebindItem(id);
-    }
-
-    public setStore(model: TreeStore | null): void {
-        this.treeRenderer?.setStore(model);
-    }
-
-    public setFlatStore(store: ListStore): void {
-        if (this.treeRenderer) {
-            this.treeRenderer.dispose();
-            this.treeRenderer = null;
-        }
-        if (!this.flatRenderer) {
-            this.flatRenderer = new GridItemRenderer(this.signalStore);
-            this.flatRenderer.setRenderFn(this.props.renderCell);
-            this.column.setFactory(this.flatRenderer.getFactory());
-        }
-        this.flatRenderer.setStore(store);
-    }
+    public collectBoundItems(flatItems: ListItem[]): BoundItem[] {
+        const { renderCell } = this.props;
+        if (!renderCell) return [];
 
-    public setEstimatedRowHeight(height: number | null): void {
-        this.treeRenderer?.setEstimatedItemHeight(height);
-        this.flatRenderer?.setEstimatedItemHeight(height);
-    }
+        const items: BoundItem[] = [];
 
-    public attachToColumnView(columnView: Gtk.ColumnView): void {
-        this.columnView = columnView;
+        for (const [container, position] of this.containers) {
+            if (position === UNBOUND_POSITION) continue;
 
-        if (this.actionGroup) {
-            this.columnView.insertActionGroup(this.props.id, this.actionGroup);
-        }
-    }
+            const key = this.containerKeys.get(container);
+            if (!key) continue;
 
-    public detachFromColumnView(): void {
-        if (this.columnView && this.actionGroup) {
-            this.columnView.insertActionGroup(this.props.id, null);
+            const item = flatItems[position];
+            if (!item) continue;
+            const content = renderCell(item.value);
+            items.push([content, container, key]);
         }
 
-        this.columnView = null;
+        return items;
     }
 
-    private initMenu(): void {
-        if (this.menu) return;
-
-        this.actionGroup = new Gio.SimpleActionGroup();
-        this.menu = new MenuModel("root", {}, this.rootContainer);
-        this.menu.setActionMap(this.actionGroup, this.props.id);
-        this.column.setHeaderMenu(this.menu.getMenu());
+    public installActionGroup(widget: Gtk.Widget): void {
+        widget.insertActionGroup(this.props.id, this.actionGroup);
+    }
 
-        if (this.columnView) {
-            this.columnView.insertActionGroup(this.props.id, this.actionGroup);
-        }
+    public uninstallActionGroup(widget: Gtk.Widget): void {
+        widget.insertActionGroup(this.props.id, null);
     }
 
-    private cleanupMenu(): void {
-        if (!this.menu) return;
+    private setupFactory(): void {
+        this.columnFactory = new Gtk.SignalListItemFactory();
 
-        this.column.setHeaderMenu(null);
+        this.columnFactory.connect("setup", (_self: GObject.Object, obj: GObject.Object) => {
+            const listItem = obj as unknown as Gtk.ListItem;
+            const key = String(getNativeId(listItem.handle));
+            const placeholder = new Gtk.Box();
+            const { width, height } = this.getParentEstimatedItemSize();
+            placeholder.setSizeRequest(width, height);
+            listItem.setChild(placeholder);
+            this.containers.set(listItem, UNBOUND_POSITION);
+            this.containerKeys.set(listItem, key);
+        });
 
-        if (this.columnView && this.actionGroup) {
-            this.columnView.insertActionGroup(this.props.id, null);
-        }
+        this.columnFactory.connect("bind", (_self: GObject.Object, obj: GObject.Object) => {
+            const listItem = obj as unknown as Gtk.ListItem;
+            this.containers.set(listItem, listItem.getPosition());
+            this.scheduleParentUpdate();
+        });
 
-        this.menu = null;
-        this.actionGroup = null;
+        this.columnFactory.connect("unbind", (_self: GObject.Object, obj: GObject.Object) => {
+            const listItem = obj as unknown as Gtk.ListItem;
+            this.containers.set(listItem, UNBOUND_POSITION);
+            this.scheduleParentUpdate();
+        });
+
+        this.columnFactory.connect("teardown", (_self: GObject.Object, obj: GObject.Object) => {
+            const listItem = obj as unknown as Gtk.ListItem;
+            this.containers.delete(listItem);
+            this.containerKeys.delete(listItem);
+            listItem.setChild(null);
+        });
     }
 
-    private applyOwnProps(oldProps: ColumnViewColumnProps | null, newProps: ColumnViewColumnProps): void {
-        if (hasChanged(oldProps, newProps, "renderCell")) {
-            this.treeRenderer?.setRenderFn(newProps.renderCell);
-            this.flatRenderer?.setRenderFn(newProps.renderCell);
-        }
+    private setupColumn(props: ColumnViewColumnProps): void {
+        this.column = new Gtk.ColumnViewColumn(props.title, this.columnFactory);
+        this.column.setId(props.id);
 
-        if (hasChanged(oldProps, newProps, "title")) {
-            this.column.setTitle(newProps.title);
-        }
-
-        if (hasChanged(oldProps, newProps, "expand")) {
-            this.column.setExpand(newProps.expand ?? false);
-        }
+        if (props.expand !== undefined) this.column.setExpand(props.expand);
+        if (props.resizable !== undefined) this.column.setResizable(props.resizable);
+        if (props.fixedWidth !== undefined) this.column.setFixedWidth(props.fixedWidth);
+        if (props.visible !== undefined) this.column.setVisible(props.visible);
+        if (props.sortable) this.column.setSorter(new Gtk.Sorter());
+    }
 
-        if (hasChanged(oldProps, newProps, "resizable")) {
-            this.column.setResizable(newProps.resizable ?? false);
-        }
+    private applyColumnProps(oldProps: ColumnViewColumnProps, newProps: ColumnViewColumnProps): void {
+        if (!this.column) return;
 
-        if (hasChanged(oldProps, newProps, "fixedWidth")) {
-            this.column.setFixedWidth(newProps.fixedWidth ?? -1);
+        if (hasChanged(oldProps, newProps, "title")) this.column.setTitle(newProps.title);
+        if (hasChanged(oldProps, newProps, "expand")) this.column.setExpand(newProps.expand ?? false);
+        if (hasChanged(oldProps, newProps, "resizable")) this.column.setResizable(newProps.resizable ?? false);
+        if (hasChanged(oldProps, newProps, "fixedWidth")) this.column.setFixedWidth(newProps.fixedWidth ?? -1);
+        if (hasChanged(oldProps, newProps, "visible")) this.column.setVisible(newProps.visible ?? true);
+        if (hasChanged(oldProps, newProps, "sortable")) {
+            this.column.setSorter(newProps.sortable ? new Gtk.Sorter() : null);
         }
+        if (hasChanged(oldProps, newProps, "renderCell")) this.scheduleParentUpdate();
+    }
 
-        if (hasChanged(oldProps, newProps, "id")) {
-            if (this.columnView && this.actionGroup && oldProps?.id) {
-                this.columnView.insertActionGroup(oldProps.id, null);
-                this.columnView.insertActionGroup(newProps.id, this.actionGroup);
-            }
-
-            this.column.setId(newProps.id);
-
-            if (oldProps && this.menu && this.actionGroup) {
-                this.menu.setActionMap(this.actionGroup, newProps.id);
-            }
-        }
+    private updateHeaderMenu(): void {
+        if (!this.column) return;
+        const menu = this.menu.getMenu();
+        this.column.setHeaderMenu(menu.getNItems() > 0 ? menu : null);
+    }
 
-        if (hasChanged(oldProps, newProps, "visible")) {
-            this.column.setVisible(newProps.visible ?? true);
+    private getParentEstimatedItemSize(): { width: number; height: number } {
+        if (this.parent && "getEstimatedItemSize" in this.parent) {
+            return (
+                this.parent as { getEstimatedItemSize(): { width: number; height: number } }
+            ).getEstimatedItemSize();
         }
+        return { width: -1, height: -1 };
+    }
 
-        if (hasChanged(oldProps, newProps, "sortable")) {
-            if (newProps.sortable) {
-                this.column.setSorter(new Gtk.StringSorter());
-            } else {
-                this.column.setSorter(null);
-            }
+    private scheduleParentUpdate(): void {
+        if (
+            this.parent &&
+            "scheduleBoundItemsUpdate" in this.parent &&
+            typeof this.parent.scheduleBoundItemsUpdate === "function"
+        ) {
+            (this.parent as { scheduleBoundItemsUpdate(): void }).scheduleBoundItemsUpdate();
         }
     }
 }

package/src/nodes/event-controller.ts

@@ -1,9 +1,8 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { CONSTRUCTOR_PROPS } from "../generated/internal.js";
 import { isConstructOnlyProp, resolvePropMeta, resolveSignal } from "../metadata.js";
 import { Node } from "../node.js";
 import type { Props } from "../types.js";
-import { createContainerWithConstructOnly } from "./internal/construct.js";
+import { createContainerWithProperties } from "./internal/construct.js";
 import type { SignalHandler } from "./internal/signal-store.js";
 import { WidgetNode } from "./widget.js";
 
@@ -18,19 +17,12 @@ export class EventControllerNode<
         props: Props,
         containerClass: typeof Gtk.EventController,
     ): Gtk.EventController {
-        const typeName = containerClass.glibTypeName;
-
-        if (typeName === "GtkDropTarget") {
+        if (containerClass.glibTypeName === "GtkDropTarget") {
             const actions = (props.actions as number | undefined) ?? 0;
             return new Gtk.DropTarget(G_TYPE_INVALID, actions);
         }
 
-        const args = (CONSTRUCTOR_PROPS[typeName] ?? []).map((name) => props[name]);
-
-        return createContainerWithConstructOnly(containerClass, props, () => {
-            // biome-ignore lint/suspicious/noExplicitAny: Dynamic constructor invocation
-            return new (containerClass as any)(...args);
-        }) as Gtk.EventController;
+        return createContainerWithProperties(containerClass, props) as Gtk.EventController;
     }
 
     public override isValidChild(child: Node): boolean {

package/src/nodes/internal/accessible.ts

@@ -29,7 +29,6 @@ const fromString: CreateValue = (val) => Value.newFromString(val as string);
 const fromBoolean: CreateValue = (val) => Value.newFromBoolean(val as boolean);
 const fromInt: CreateValue = (val) => Value.newFromInt(val as number);
 const fromDouble: CreateValue = (val) => Value.newFromDouble(val as number);
-
 const fromObject: CreateValue = (val) => Value.newFromObject((val as GObject.Object) ?? null);
 
 const fromRefList: CreateValue = (val) => {

package/src/nodes/internal/bound-item.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from "react";
+import type { Container } from "../../types.js";
+
+export type BoundItem = [ReactNode, Container, string];

package/src/nodes/internal/construct.ts

@@ -1,90 +1,60 @@
-import { type Arg, call, type NativeHandle, registerNativeObject, setInstantiating, type Type } from "@gtkx/ffi";
-import { typeFromName } from "@gtkx/ffi/gobject";
-import { CONSTRUCT_ONLY_PROPS, CONSTRUCTOR_PROPS } from "../../generated/internal.js";
+import type { NativeClass, Type } from "@gtkx/ffi";
+import { Object as GObject, toValue, type Value } from "@gtkx/ffi/gobject";
+import { CONSTRUCTION_META } from "../../generated/internal.js";
 import type { Container, ContainerClass, Props } from "../../types.js";
 
-type ConstructOnlyPropInfo = { girName: string; ffiType: Type };
+type ConstructionPropMeta = {
+    girName: string;
+    ffiType: Type;
+    constructOnly?: true;
+};
 
-/**
- * Collects construct-only property metadata by walking the class hierarchy.
- * Returns all active construct-only props (those with values set in the initial props)
- * that are NOT already handled by the designated constructor parameters.
- */
-function collectActiveConstructOnlyProps(
+function collectConstructionProps(
     containerClass: ContainerClass,
     props: Props,
 ): Array<{ girName: string; ffiType: Type; value: unknown }> {
     const result: Array<{ girName: string; ffiType: Type; value: unknown }> = [];
-    const constructorParams = new Set(CONSTRUCTOR_PROPS[containerClass.glibTypeName] ?? []);
-
-    // biome-ignore lint/suspicious/noExplicitAny: Walking static prototype chain
-    let current: any = containerClass;
-    while (current?.glibTypeName) {
-        const propsForType: Record<string, ConstructOnlyPropInfo> | undefined =
-            CONSTRUCT_ONLY_PROPS[current.glibTypeName as string];
-        if (propsForType) {
-            for (const [camelName, meta] of Object.entries(propsForType)) {
-                if (constructorParams.has(camelName)) continue;
+    const seen = new Set<string>();
+
+    // biome-ignore lint/complexity/noBannedTypes: Walking prototype chain requires Function type
+    let current: Function | null = containerClass;
+    while (current) {
+        const typeName = (current as NativeClass).glibTypeName;
+        if (!typeName) break;
+
+        const meta: Record<string, ConstructionPropMeta> | undefined = CONSTRUCTION_META[typeName];
+        if (meta) {
+            for (const [camelName, propMeta] of Object.entries(meta)) {
+                if (seen.has(camelName)) continue;
+                seen.add(camelName);
                 if (props[camelName] !== undefined) {
-                    const rawValue = props[camelName];
-                    const value =
-                        meta.ffiType.type === "gobject" &&
-                        rawValue &&
-                        typeof rawValue === "object" &&
-                        "handle" in rawValue
-                            ? (rawValue as { handle: NativeHandle }).handle
-                            : rawValue;
-                    result.push({ girName: meta.girName, ffiType: meta.ffiType, value });
+                    result.push({
+                        girName: propMeta.girName,
+                        ffiType: propMeta.ffiType,
+                        value: props[camelName],
+                    });
                 }
             }
         }
+
         current = Object.getPrototypeOf(current);
+        if (current === Object || current === Function) break;
     }
 
     return result;
 }
 
-/**
- * Creates a container (widget or controller) with construct-only properties.
- *
- * When construct-only props are present that aren't handled by the designated
- * constructor, uses `g_object_new` to set them during object construction.
- * Otherwise falls back to the normal constructor.
- */
-export function createContainerWithConstructOnly(
-    containerClass: ContainerClass,
-    props: Props,
-    normalConstructor: () => Container,
-): Container {
-    const constructOnlyArgs = collectActiveConstructOnlyProps(containerClass, props);
-
-    if (constructOnlyArgs.length === 0) {
-        return normalConstructor();
-    }
-
-    const typeName = containerClass.glibTypeName;
-    const gtype = typeFromName(typeName);
+export function createContainerWithProperties(containerClass: ContainerClass, props: Props): Container {
+    const gtype = containerClass.getGType();
+    const constructionProps = collectConstructionProps(containerClass, props);
 
-    const args: Arg[] = [{ type: { type: "int", size: 64, unsigned: true }, value: gtype, optional: false }];
+    const names: string[] = [];
+    const values: Value[] = [];
 
-    for (const { girName, ffiType, value } of constructOnlyArgs) {
-        args.push({ type: { type: "string", ownership: "borrowed" }, value: girName, optional: false });
-        args.push({ type: ffiType, value, optional: false });
+    for (const { girName, ffiType, value } of constructionProps) {
+        names.push(girName);
+        values.push(toValue(ffiType, value));
     }
 
-    args.push({ type: { type: "null" }, value: null, optional: false });
-
-    const handle = call("libgobject-2.0.so.0", "g_object_new", args, {
-        type: "gobject",
-        ownership: "full",
-    }) as NativeHandle;
-
-    setInstantiating(true);
-    // biome-ignore lint/suspicious/noExplicitAny: Dynamic instantiation with isInstantiating flag
-    const instance = new (containerClass as any)() as Container & { handle: NativeHandle };
-    setInstantiating(false);
-    instance.handle = handle;
-    registerNativeObject(instance);
-
-    return instance;
+    return GObject.newWithProperties(gtype, names, values) as unknown as Container;
 }

package/src/nodes/internal/widget.ts

@@ -14,6 +14,8 @@ export function detachChild(child: Gtk.Widget, container: Gtk.Widget): void {
         container.setChild(null);
     } else if (isRemovable(container)) {
         container.remove(child);
+    } else {
+        child.unparent();
     }
 }
 
@@ -27,7 +29,7 @@ export function attachChild(child: Gtk.Widget, container: Gtk.Widget): void {
     } else if (isSingleChild(container)) {
         container.setChild(child);
     } else {
-        throw new Error(`Cannot attach child to '${container.constructor.name}': container does not support children`);
+        child.setParent(container);
     }
 }