@gtkx/react 0.18.9 → 0.20.0

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

@@ -1,17 +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 { ListItemRenderer } from "./internal/list-item-renderer.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;
     }
@@ -19,150 +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 itemRenderer: ListItemRenderer;
-    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.itemRenderer = new ListItemRenderer(this.signalStore);
-        this.column = new Gtk.ColumnViewColumn();
-        this.column.setFactory(this.itemRenderer.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.itemRenderer.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.itemRenderer.rebindItem(id);
-    }
-
-    public setStore(model: TreeStore | null): void {
-        this.itemRenderer.setStore(model);
-    }
+    public collectBoundItems(flatItems: ListItem[]): BoundItem[] {
+        const { renderCell } = this.props;
+        if (!renderCell) return [];
 
-    public setEstimatedRowHeight(height: number | null): void {
-        this.itemRenderer.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();
+        });
 
-    private applyOwnProps(oldProps: ColumnViewColumnProps | null, newProps: ColumnViewColumnProps): void {
-        if (hasChanged(oldProps, newProps, "renderCell")) {
-            this.itemRenderer.setRenderFn(newProps.renderCell);
-        }
+        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);
+        });
+    }
 
-        if (hasChanged(oldProps, newProps, "title")) {
-            this.column.setTitle(newProps.title);
-        }
+    private setupColumn(props: ColumnViewColumnProps): void {
+        this.column = new Gtk.ColumnViewColumn(props.title, this.columnFactory);
+        this.column.setId(props.id);
 
-        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);
+    private updateHeaderMenu(): void {
+        if (!this.column) return;
+        const menu = this.menu.getMenu();
+        this.column.setHeaderMenu(menu.getNItems() > 0 ? menu : null);
+    }
 
-            if (oldProps && this.menu && this.actionGroup) {
-                this.menu.setActionMap(this.actionGroup, newProps.id);
-            }
+    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,8 +1,8 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { CONSTRUCTOR_PROPS } from "../generated/internal.js";
-import { resolvePropMeta, resolveSignal } from "../metadata.js";
+import { isConstructOnlyProp, resolvePropMeta, resolveSignal } from "../metadata.js";
 import { Node } from "../node.js";
 import type { Props } from "../types.js";
+import { createContainerWithProperties } from "./internal/construct.js";
 import type { SignalHandler } from "./internal/signal-store.js";
 import { WidgetNode } from "./widget.js";
 
@@ -17,17 +17,16 @@ 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 createContainerWithProperties(containerClass, props) as Gtk.EventController;
+    }
 
-        // biome-ignore lint/suspicious/noExplicitAny: Dynamic constructor invocation
-        return new (containerClass as any)(...args);
+    public override isValidChild(child: Node): boolean {
+        return this.container instanceof Gtk.ShortcutController && child.typeName === "Shortcut";
     }
 
     public override isValidParent(parent: Node): boolean {
@@ -63,6 +62,7 @@ export class EventControllerNode<
 
         for (const name of propNames) {
             if (name === "children") continue;
+            if (isConstructOnlyProp(this.container, name)) continue;
 
             const oldValue = oldProps?.[name];
             const newValue = newProps[name];

package/src/nodes/fixed-child.ts

@@ -1,3 +1,5 @@
+import * as Graphene from "@gtkx/ffi/graphene";
+import * as Gsk from "@gtkx/ffi/gsk";
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { FixedChildProps } from "../jsx.js";
 import type { Node } from "../node.js";
@@ -23,7 +25,7 @@ export class FixedChildNode extends VirtualNode<FixedChildProps, WidgetNode<Gtk.
 
         if (parent && this.children[0]) {
             this.attachToParent(parent.container, this.children[0].container);
-            this.applyTransform();
+            this.applyLayoutTransform();
         }
     }
 
@@ -32,7 +34,7 @@ export class FixedChildNode extends VirtualNode<FixedChildProps, WidgetNode<Gtk.
 
         if (this.parent) {
             this.attachToParent(this.parent.container, child.container);
-            this.applyTransform();
+            this.applyLayoutTransform();
         }
     }
 
@@ -51,12 +53,12 @@ export class FixedChildNode extends VirtualNode<FixedChildProps, WidgetNode<Gtk.
             return;
         }
 
-        const positionChanged = hasChanged(oldProps, newProps, "x") || hasChanged(oldProps, newProps, "y");
-
-        if (positionChanged) {
-            this.repositionChild();
-        } else if (hasChanged(oldProps, newProps, "transform")) {
-            this.applyTransform();
+        if (
+            hasChanged(oldProps, newProps, "x") ||
+            hasChanged(oldProps, newProps, "y") ||
+            hasChanged(oldProps, newProps, "transform")
+        ) {
+            this.applyLayoutTransform();
         }
     }
 
@@ -80,29 +82,28 @@ export class FixedChildNode extends VirtualNode<FixedChildProps, WidgetNode<Gtk.
         }
     }
 
-    private repositionChild(): void {
+    private applyLayoutTransform(): void {
         if (!this.parent || !this.children[0]) return;
 
+        const layoutManager = this.parent.container.getLayoutManager();
+        if (!layoutManager) return;
+
+        const layoutChild = layoutManager.getLayoutChild(this.children[0].container) as Gtk.FixedLayoutChild;
+
         const x = this.props.x ?? 0;
         const y = this.props.y ?? 0;
+        const position = new Graphene.Point();
+        position.init(x, y);
 
-        this.parent.container.remove(this.children[0].container);
-        this.parent.container.put(this.children[0].container, x, y);
-        this.applyTransform();
-    }
+        let transform: Gsk.Transform | null = new Gsk.Transform();
+        transform = transform.translate(position);
 
-    private applyTransform(): void {
-        if (!this.parent || !this.children[0] || !this.props.transform) {
-            return;
+        if (this.props.transform && transform) {
+            transform = transform.transform(this.props.transform);
         }
 
-        const layoutManager = this.parent.container.getLayoutManager();
-
-        if (!layoutManager) {
-            return;
+        if (transform) {
+            layoutChild.setTransform(transform);
         }
-
-        const layoutChild = layoutManager.getLayoutChild(this.children[0].container) as Gtk.FixedLayoutChild;
-        layoutChild.setTransform(this.props.transform);
     }
 }

package/src/nodes/font-dialog-button.ts

@@ -10,6 +10,8 @@ const OWN_PROPS = [
     "title",
     "modal",
     "language",
+    "filter",
+    "fontMap",
     "useFont",
     "useSize",
     "level",
@@ -61,6 +63,14 @@ export class FontDialogButtonNode extends WidgetNode<Gtk.FontDialogButton, FontD
             this.dialog.setLanguage(newProps.language);
         }
 
+        if (hasChanged(oldProps, newProps, "filter")) {
+            this.dialog.setFilter(newProps.filter);
+        }
+
+        if (hasChanged(oldProps, newProps, "fontMap")) {
+            this.dialog.setFontMap(newProps.fontMap);
+        }
+
         if (hasChanged(oldProps, newProps, "useFont")) {
             this.container.setUseFont(newProps.useFont ?? false);
         }

package/src/nodes/internal/accessible.ts

@@ -0,0 +1,155 @@
+import type * as GObject from "@gtkx/ffi/gobject";
+import { Value } from "@gtkx/ffi/gobject";
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "../../types.js";
+
+type CreateValue = (jsValue: unknown) => Value;
+
+type PropertyDef = {
+    kind: "property";
+    enumValue: Gtk.AccessibleProperty;
+    createValue: CreateValue;
+};
+
+type StateDef = {
+    kind: "state";
+    enumValue: Gtk.AccessibleState;
+    createValue: CreateValue;
+};
+
+type RelationDef = {
+    kind: "relation";
+    enumValue: Gtk.AccessibleRelation;
+    createValue: CreateValue;
+};
+
+type AccessiblePropDef = PropertyDef | StateDef | RelationDef;
+
+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) => {
+    const widgets = val as Gtk.Accessible[];
+    const list = Gtk.AccessibleList.newFromList(widgets);
+    return Value.newFromBoxed(list);
+};
+
+const prop = (enumValue: Gtk.AccessibleProperty, createValue: CreateValue): PropertyDef => ({
+    kind: "property",
+    enumValue,
+    createValue,
+});
+
+const state = (enumValue: Gtk.AccessibleState, createValue: CreateValue): StateDef => ({
+    kind: "state",
+    enumValue,
+    createValue,
+});
+
+const relation = (enumValue: Gtk.AccessibleRelation, createValue: CreateValue): RelationDef => ({
+    kind: "relation",
+    enumValue,
+    createValue,
+});
+
+const ACCESSIBLE_PROP_MAP: Record<string, AccessiblePropDef> = {
+    accessibleAutocomplete: prop(Gtk.AccessibleProperty.AUTOCOMPLETE, fromInt),
+    accessibleDescription: prop(Gtk.AccessibleProperty.DESCRIPTION, fromString),
+    accessibleHasPopup: prop(Gtk.AccessibleProperty.HAS_POPUP, fromBoolean),
+    accessibleKeyShortcuts: prop(Gtk.AccessibleProperty.KEY_SHORTCUTS, fromString),
+    accessibleLabel: prop(Gtk.AccessibleProperty.LABEL, fromString),
+    accessibleLevel: prop(Gtk.AccessibleProperty.LEVEL, fromInt),
+    accessibleModal: prop(Gtk.AccessibleProperty.MODAL, fromBoolean),
+    accessibleMultiLine: prop(Gtk.AccessibleProperty.MULTI_LINE, fromBoolean),
+    accessibleMultiSelectable: prop(Gtk.AccessibleProperty.MULTI_SELECTABLE, fromBoolean),
+    accessibleOrientation: prop(Gtk.AccessibleProperty.ORIENTATION, fromInt),
+    accessiblePlaceholder: prop(Gtk.AccessibleProperty.PLACEHOLDER, fromString),
+    accessibleReadOnly: prop(Gtk.AccessibleProperty.READ_ONLY, fromBoolean),
+    accessibleRequired: prop(Gtk.AccessibleProperty.REQUIRED, fromBoolean),
+    accessibleRoleDescription: prop(Gtk.AccessibleProperty.ROLE_DESCRIPTION, fromString),
+    accessibleSort: prop(Gtk.AccessibleProperty.SORT, fromInt),
+    accessibleValueMax: prop(Gtk.AccessibleProperty.VALUE_MAX, fromDouble),
+    accessibleValueMin: prop(Gtk.AccessibleProperty.VALUE_MIN, fromDouble),
+    accessibleValueNow: prop(Gtk.AccessibleProperty.VALUE_NOW, fromDouble),
+    accessibleValueText: prop(Gtk.AccessibleProperty.VALUE_TEXT, fromString),
+    accessibleHelpText: prop(Gtk.AccessibleProperty.HELP_TEXT, fromString),
+
+    accessibleBusy: state(Gtk.AccessibleState.BUSY, fromBoolean),
+    accessibleChecked: state(Gtk.AccessibleState.CHECKED, fromInt),
+    accessibleDisabled: state(Gtk.AccessibleState.DISABLED, fromBoolean),
+    accessibleExpanded: state(Gtk.AccessibleState.EXPANDED, fromInt),
+    accessibleHidden: state(Gtk.AccessibleState.HIDDEN, fromBoolean),
+    accessibleInvalid: state(Gtk.AccessibleState.INVALID, fromInt),
+    accessiblePressed: state(Gtk.AccessibleState.PRESSED, fromInt),
+    accessibleSelected: state(Gtk.AccessibleState.SELECTED, fromInt),
+    accessibleVisited: state(Gtk.AccessibleState.VISITED, fromInt),
+
+    accessibleActiveDescendant: relation(Gtk.AccessibleRelation.ACTIVE_DESCENDANT, fromObject),
+    accessibleColCount: relation(Gtk.AccessibleRelation.COL_COUNT, fromInt),
+    accessibleColIndex: relation(Gtk.AccessibleRelation.COL_INDEX, fromInt),
+    accessibleColIndexText: relation(Gtk.AccessibleRelation.COL_INDEX_TEXT, fromString),
+    accessibleColSpan: relation(Gtk.AccessibleRelation.COL_SPAN, fromInt),
+    accessibleControls: relation(Gtk.AccessibleRelation.CONTROLS, fromRefList),
+    accessibleDescribedBy: relation(Gtk.AccessibleRelation.DESCRIBED_BY, fromRefList),
+    accessibleDetails: relation(Gtk.AccessibleRelation.DETAILS, fromRefList),
+    accessibleErrorMessage: relation(Gtk.AccessibleRelation.ERROR_MESSAGE, fromRefList),
+    accessibleFlowTo: relation(Gtk.AccessibleRelation.FLOW_TO, fromRefList),
+    accessibleLabelledBy: relation(Gtk.AccessibleRelation.LABELLED_BY, fromRefList),
+    accessibleOwns: relation(Gtk.AccessibleRelation.OWNS, fromRefList),
+    accessiblePosInSet: relation(Gtk.AccessibleRelation.POS_IN_SET, fromInt),
+    accessibleRowCount: relation(Gtk.AccessibleRelation.ROW_COUNT, fromInt),
+    accessibleRowIndex: relation(Gtk.AccessibleRelation.ROW_INDEX, fromInt),
+    accessibleRowIndexText: relation(Gtk.AccessibleRelation.ROW_INDEX_TEXT, fromString),
+    accessibleRowSpan: relation(Gtk.AccessibleRelation.ROW_SPAN, fromInt),
+    accessibleSetSize: relation(Gtk.AccessibleRelation.SET_SIZE, fromInt),
+};
+
+export const isAccessibleProp = (name: string): boolean => name in ACCESSIBLE_PROP_MAP;
+
+function applyDef(widget: Gtk.Widget, def: AccessiblePropDef, newValue: unknown): void {
+    const gvalue = def.createValue(newValue);
+
+    switch (def.kind) {
+        case "property":
+            widget.updatePropertyValue(1, [def.enumValue], [gvalue]);
+            break;
+        case "state":
+            widget.updateStateValue(1, [def.enumValue], [gvalue]);
+            break;
+        case "relation":
+            widget.updateRelationValue(1, [def.enumValue], [gvalue]);
+            break;
+    }
+}
+
+function resetDef(widget: Gtk.Widget, def: AccessiblePropDef): void {
+    switch (def.kind) {
+        case "property":
+            widget.resetProperty(def.enumValue);
+            break;
+        case "state":
+            widget.resetState(def.enumValue);
+            break;
+        case "relation":
+            widget.resetRelation(def.enumValue);
+            break;
+    }
+}
+
+export const applyAccessibleProps = (widget: Gtk.Widget, oldProps: Props | null, newProps: Props): void => {
+    for (const [name, def] of Object.entries(ACCESSIBLE_PROP_MAP)) {
+        const oldValue = oldProps?.[name];
+        const newValue = newProps[name];
+
+        if (oldValue === newValue) continue;
+
+        if (newValue === undefined) {
+            resetDef(widget, def);
+        } else {
+            applyDef(widget, def, newValue);
+        }
+    }
+};

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

@@ -0,0 +1,60 @@
+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 ConstructionPropMeta = {
+    girName: string;
+    ffiType: Type;
+    constructOnly?: true;
+};
+
+function collectConstructionProps(
+    containerClass: ContainerClass,
+    props: Props,
+): Array<{ girName: string; ffiType: Type; value: unknown }> {
+    const result: Array<{ girName: string; ffiType: Type; value: unknown }> = [];
+    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) {
+                    result.push({
+                        girName: propMeta.girName,
+                        ffiType: propMeta.ffiType,
+                        value: props[camelName],
+                    });
+                }
+            }
+        }
+
+        current = Object.getPrototypeOf(current);
+        if (current === Object || current === Function) break;
+    }
+
+    return result;
+}
+
+export function createContainerWithProperties(containerClass: ContainerClass, props: Props): Container {
+    const gtype = containerClass.getGType();
+    const constructionProps = collectConstructionProps(containerClass, props);
+
+    const names: string[] = [];
+    const values: Value[] = [];
+
+    for (const { girName, ffiType, value } of constructionProps) {
+        names.push(girName);
+        values.push(toValue(ffiType, value));
+    }
+
+    return GObject.newWithProperties(gtype, names, values) as unknown as Container;
+}