@gtkx/react 0.18.9 → 0.19.0

package/src/nodes/drop-down.ts

@@ -1,28 +1,54 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { ReactNode } from "react";
+import type Reconciler from "react-reconciler";
+import { createFiberRoot } from "../fiber-root.js";
 import type { AdwComboRowProps, GtkDropDownProps } from "../jsx.js";
 import type { Node } from "../node.js";
+import { reconciler } from "../reconciler.js";
 import type { DropDownWidget } from "../registry.js";
 import type { Container } from "../types.js";
 import { ContainerSlotNode } from "./container-slot.js";
 import { EventControllerNode } from "./event-controller.js";
+import type { HeaderItemRenderer } from "./internal/header-item-renderer.js";
+import { updateHeaderRenderer } from "./internal/header-renderer-manager.js";
 import { filterProps, hasChanged } from "./internal/props.js";
 import { SimpleListStore } from "./internal/simple-list-store.js";
 import { ListItemNode } from "./list-item.js";
+import { ListSectionNode } from "./list-section.js";
 import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
 
-const OWN_PROPS = ["selectedId", "onSelectionChanged"] as const;
+const OWN_PROPS = ["selectedId", "onSelectionChanged", "renderItem", "renderListItem", "renderHeader"] as const;
 
 type DropDownProps = Pick<GtkDropDownProps | AdwComboRowProps, (typeof OWN_PROPS)[number]>;
 
-type DropDownChild = ListItemNode | EventControllerNode | SlotNode | ContainerSlotNode;
+type DropDownChild = ListItemNode | ListSectionNode | EventControllerNode | SlotNode | ContainerSlotNode;
+
+type RenderItemFn = (item: string | null) => ReactNode;
+
+interface FactoryState {
+    factory: Gtk.SignalListItemFactory;
+    fiberRoots: Map<object, Reconciler.FiberRoot>;
+    tornDown: Set<object>;
+    boundLabels: Map<string, object>;
+}
 
 export class DropDownNode extends WidgetNode<DropDownWidget, DropDownProps, DropDownChild> {
     private store = new SimpleListStore();
     private initialSelectedId: string | null | undefined;
 
+    private itemState: FactoryState | null = null;
+    private renderItemFn: RenderItemFn | null = null;
+
+    private listItemState: FactoryState | null = null;
+    private renderListItemFn: RenderItemFn | null = null;
+
+    private headerRenderer: HeaderItemRenderer | null = null;
+
     public override isValidChild(child: Node): boolean {
         return (
             child instanceof ListItemNode ||
+            child instanceof ListSectionNode ||
             child instanceof EventControllerNode ||
             child instanceof SlotNode ||
             child instanceof ContainerSlotNode
@@ -33,12 +59,12 @@ export class DropDownNode extends WidgetNode<DropDownWidget, DropDownProps, Drop
         super(typeName, props, container, rootContainer);
         this.store.beginBatch();
         this.initialSelectedId = props.selectedId;
-        this.container.setModel(this.store.getModel());
     }
 
     public override finalizeInitialChildren(props: DropDownProps): boolean {
         super.finalizeInitialChildren(props);
         this.store.flushBatch();
+        this.container.setModel(this.store.getModel());
         this.reapplyInitialSelectedId();
         return false;
     }
@@ -54,7 +80,10 @@ export class DropDownNode extends WidgetNode<DropDownWidget, DropDownProps, Drop
 
     public override appendChild(child: DropDownChild): void {
         super.appendChild(child);
-        if (child instanceof ListItemNode) {
+        if (child instanceof ListSectionNode) {
+            this.store.addSection(child.props.id, child.props.value);
+            child.setStore(this.store);
+        } else if (child instanceof ListItemNode) {
             child.setStore(this.store);
             this.store.addItem(child.props.id, child.props.value as string);
         }
@@ -62,15 +91,25 @@ export class DropDownNode extends WidgetNode<DropDownWidget, DropDownProps, Drop
 
     public override insertBefore(child: DropDownChild, before: DropDownChild): void {
         super.insertBefore(child, before);
-        if (child instanceof ListItemNode && before instanceof ListItemNode) {
+        if (child instanceof ListSectionNode) {
+            this.store.addSection(child.props.id, child.props.value);
+            child.setStore(this.store);
+        } else if (child instanceof ListItemNode && before instanceof ListItemNode) {
             child.setStore(this.store);
             this.store.insertItemBefore(child.props.id, before.props.id, child.props.value as string);
+        } else if (child instanceof ListItemNode) {
+            child.setStore(this.store);
+            this.store.addItem(child.props.id, child.props.value as string);
         }
     }
 
     public override removeChild(child: DropDownChild): void {
-        if (child instanceof ListItemNode) {
+        if (child instanceof ListSectionNode) {
+            this.store.removeSection(child.props.id);
+            child.setStore(null);
+        } else if (child instanceof ListItemNode) {
             this.store.removeItem(child.props.id);
+            child.setStore(null);
         }
         super.removeChild(child);
     }
@@ -80,6 +119,15 @@ export class DropDownNode extends WidgetNode<DropDownWidget, DropDownProps, Drop
         this.applyOwnProps(oldProps, newProps);
     }
 
+    public override detachDeletedInstance(): void {
+        this.disposeFactory(this.itemState);
+        this.itemState = null;
+        this.disposeFactory(this.listItemState);
+        this.listItemState = null;
+        this.headerRenderer?.dispose();
+        super.detachDeletedInstance();
+    }
+
     private applyOwnProps(oldProps: DropDownProps | null, newProps: DropDownProps): void {
         if (hasChanged(oldProps, newProps, "onSelectionChanged")) {
             const onSelectionChanged = newProps.onSelectionChanged;
@@ -104,5 +152,133 @@ export class DropDownNode extends WidgetNode<DropDownWidget, DropDownProps, Drop
                 this.container.setSelected(index);
             }
         }
+
+        if (hasChanged(oldProps, newProps, "renderItem")) {
+            if (newProps.renderItem) {
+                if (!this.itemState) {
+                    this.itemState = this.createFactory(
+                        () => this.renderItemFn,
+                        (f) => this.container.setFactory(f),
+                    );
+                }
+                this.renderItemFn = newProps.renderItem;
+                this.rebindAll(this.itemState, this.renderItemFn);
+            } else if (this.itemState) {
+                this.disposeFactory(this.itemState);
+                this.itemState = null;
+                this.container.setFactory(null);
+                this.renderItemFn = null;
+            }
+        }
+
+        if (hasChanged(oldProps, newProps, "renderListItem")) {
+            if (newProps.renderListItem) {
+                if (!this.listItemState) {
+                    this.listItemState = this.createFactory(
+                        () => this.renderListItemFn,
+                        (f) => this.container.setListFactory(f),
+                    );
+                }
+                this.renderListItemFn = newProps.renderListItem;
+                this.rebindAll(this.listItemState, this.renderListItemFn);
+            } else if (this.listItemState) {
+                this.disposeFactory(this.listItemState);
+                this.listItemState = null;
+                this.container.setListFactory(null);
+                this.renderListItemFn = null;
+            }
+        }
+
+        if (hasChanged(oldProps, newProps, "renderHeader")) {
+            this.headerRenderer = updateHeaderRenderer(
+                this.headerRenderer,
+                {
+                    signalStore: this.signalStore,
+                    isEnabled: () => this.store.isSectioned(),
+                    resolveItem: (label) => this.store.getHeaderValueByLabel(label),
+                    setFactory: (factory) => this.container.setHeaderFactory(factory),
+                },
+                newProps.renderHeader,
+            );
+        }
+    }
+
+    private createFactory(
+        getRenderFn: () => RenderItemFn | null,
+        applyFactory: (factory: Gtk.SignalListItemFactory) => void,
+    ): FactoryState {
+        const state: FactoryState = {
+            factory: new Gtk.SignalListItemFactory(),
+            fiberRoots: new Map(),
+            tornDown: new Set(),
+            boundLabels: new Map(),
+        };
+
+        this.signalStore.set(this, state.factory, "setup", (listItem: Gtk.ListItem) => {
+            const box = new Gtk.Box(Gtk.Orientation.HORIZONTAL);
+            box.setValign(Gtk.Align.CENTER);
+            listItem.setChild(box);
+            const fiberRoot = createFiberRoot(box);
+            state.fiberRoots.set(listItem, fiberRoot);
+            const element = getRenderFn()?.(null);
+            reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {});
+        });
+
+        this.signalStore.set(this, state.factory, "bind", (listItem: Gtk.ListItem) => {
+            const fiberRoot = state.fiberRoots.get(listItem);
+            if (!fiberRoot) return;
+            const stringObject = listItem.getItem();
+            const label = stringObject instanceof Gtk.StringObject ? stringObject.getString() : null;
+            if (label !== null) state.boundLabels.set(label, listItem);
+            const element = getRenderFn()?.(label);
+            reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {});
+        });
+
+        this.signalStore.set(this, state.factory, "unbind", (listItem: Gtk.ListItem) => {
+            const stringObject = listItem.getItem();
+            if (stringObject instanceof Gtk.StringObject) {
+                state.boundLabels.delete(stringObject.getString());
+            }
+        });
+
+        this.signalStore.set(this, state.factory, "teardown", (listItem: Gtk.ListItem) => {
+            const fiberRoot = state.fiberRoots.get(listItem);
+            if (fiberRoot) {
+                state.tornDown.add(listItem);
+                reconciler.getInstance().updateContainer(null, fiberRoot, null, () => {});
+                queueMicrotask(() => {
+                    state.fiberRoots.delete(listItem);
+                    state.tornDown.delete(listItem);
+                });
+            }
+        });
+
+        applyFactory(state.factory);
+        return state;
+    }
+
+    private rebindAll(state: FactoryState, renderFn: RenderItemFn): void {
+        for (const [label, listItem] of state.boundLabels) {
+            const fiberRoot = state.fiberRoots.get(listItem);
+            if (!fiberRoot) continue;
+            const element = renderFn(label);
+            reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {});
+        }
+    }
+
+    private disposeFactory(state: FactoryState | null): void {
+        if (!state) return;
+        this.signalStore.set(this, state.factory, "setup", undefined);
+        this.signalStore.set(this, state.factory, "bind", undefined);
+        this.signalStore.set(this, state.factory, "unbind", undefined);
+        this.signalStore.set(this, state.factory, "teardown", undefined);
+        for (const [listItem, fiberRoot] of state.fiberRoots) {
+            if (!state.tornDown.has(listItem)) {
+                reconciler.getInstance().updateContainer(null, fiberRoot, null, () => {});
+            }
+        }
+        state.fiberRoots.clear();
+        state.tornDown.clear();
+        state.boundLabels.clear();
     }
 }

package/src/nodes/event-controller.ts

@@ -1,8 +1,9 @@
 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 { createContainerWithConstructOnly } from "./internal/construct.js";
 import type { SignalHandler } from "./internal/signal-store.js";
 import { WidgetNode } from "./widget.js";
 
@@ -26,8 +27,14 @@ export class EventControllerNode<
 
         const args = (CONSTRUCTOR_PROPS[typeName] ?? []).map((name) => props[name]);
 
-        // biome-ignore lint/suspicious/noExplicitAny: Dynamic constructor invocation
-        return new (containerClass as any)(...args);
+        return createContainerWithConstructOnly(containerClass, props, () => {
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic constructor invocation
+            return new (containerClass as any)(...args);
+        }) as Gtk.EventController;
+    }
+
+    public override isValidChild(child: Node): boolean {
+        return this.container instanceof Gtk.ShortcutController && child.typeName === "Shortcut";
     }
 
     public override isValidParent(parent: Node): boolean {
@@ -63,6 +70,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/grid-view.ts

@@ -7,39 +7,43 @@ import { EventControllerNode } from "./event-controller.js";
 import { GridItemRenderer } from "./internal/grid-item-renderer.js";
 import { filterProps, hasChanged } from "./internal/props.js";
 import { ListItemNode } from "./list-item.js";
-import { GridModel, type GridModelProps } from "./models/grid.js";
+import { ListSectionNode } from "./list-section.js";
+import { ListModel, type ListModelProps } from "./models/list.js";
 import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
 
-const OWN_PROPS = ["renderItem", "estimatedItemHeight"] as const;
+const RENDERER_PROPS = ["renderItem", "estimatedItemHeight"] as const;
+const OWN_PROPS = [...RENDERER_PROPS, "selectionMode", "selected", "onSelectionChanged"] as const;
 
-type GridViewProps = Pick<GtkGridViewProps, (typeof OWN_PROPS)[number]> & GridModelProps;
+type GridViewProps = Pick<GtkGridViewProps, (typeof RENDERER_PROPS)[number]> & ListModelProps;
 
-type GridViewChild = ListItemNode | EventControllerNode | SlotNode | ContainerSlotNode;
+type GridViewChild = ListItemNode | ListSectionNode | EventControllerNode | SlotNode | ContainerSlotNode;
 
 export class GridViewNode extends WidgetNode<Gtk.GridView, GridViewProps, GridViewChild> {
     private itemRenderer: GridItemRenderer;
-    private grid: GridModel;
+    private list: ListModel;
 
     constructor(typeName: string, props: GridViewProps, container: Gtk.GridView, rootContainer: Container) {
         super(typeName, props, container, rootContainer);
-        this.grid = new GridModel(
+        this.list = new ListModel(
             { owner: this, signalStore: this.signalStore },
             {
                 selectionMode: props.selectionMode,
                 selected: props.selected,
                 onSelectionChanged: props.onSelectionChanged,
             },
+            true,
         );
         this.itemRenderer = new GridItemRenderer(this.signalStore);
-        this.itemRenderer.setStore(this.grid.getStore());
-        this.grid.getStore().setOnItemUpdated((id) => this.itemRenderer.rebindItem(id));
+        this.itemRenderer.setStore(this.list.getFlatStore());
+        this.list.setOnItemUpdated((id) => this.itemRenderer.rebindItem(id));
         this.container.setFactory(this.itemRenderer.getFactory());
     }
 
     public override isValidChild(child: Node): boolean {
         if (child instanceof EventControllerNode || child instanceof SlotNode || child instanceof ContainerSlotNode)
             return true;
+        if (child instanceof ListSectionNode) return true;
         if (!(child instanceof ListItemNode)) return false;
         if (child.getChildNodes().length > 0) {
             throw new Error("GtkGridView does not support nested ListItems. Use GtkListView for tree lists.");
@@ -49,21 +53,24 @@ export class GridViewNode extends WidgetNode<Gtk.GridView, GridViewProps, GridVi
 
     public override appendChild(child: GridViewChild): void {
         super.appendChild(child);
-        if (child instanceof ListItemNode) {
-            this.grid.appendChild(child);
+        if (child instanceof ListItemNode || child instanceof ListSectionNode) {
+            this.list.appendChild(child);
         }
     }
 
     public override insertBefore(child: GridViewChild, before: GridViewChild): void {
         super.insertBefore(child, before);
-        if (child instanceof ListItemNode && before instanceof ListItemNode) {
-            this.grid.insertBefore(child, before);
+        if (
+            (child instanceof ListItemNode || child instanceof ListSectionNode) &&
+            (before instanceof ListItemNode || before instanceof ListSectionNode)
+        ) {
+            this.list.insertBefore(child, before);
         }
     }
 
     public override removeChild(child: GridViewChild): void {
-        if (child instanceof ListItemNode) {
-            this.grid.removeChild(child);
+        if (child instanceof ListItemNode || child instanceof ListSectionNode) {
+            this.list.removeChild(child);
         }
         super.removeChild(child);
     }
@@ -80,8 +87,8 @@ export class GridViewNode extends WidgetNode<Gtk.GridView, GridViewProps, GridVi
 
     public override commitMount(): void {
         super.commitMount();
-        this.grid.flushBatch();
-        this.container.setModel(this.grid.getSelectionModel());
+        this.list.flushBatch();
+        this.container.setModel(this.list.getSelectionModel());
     }
 
     public override detachDeletedInstance(): void {
@@ -98,9 +105,12 @@ export class GridViewNode extends WidgetNode<Gtk.GridView, GridViewProps, GridVi
             this.itemRenderer.setEstimatedItemHeight(newProps.estimatedItemHeight ?? null);
         }
 
-        const previousModel = this.grid.getSelectionModel();
-        this.grid.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
-        const currentModel = this.grid.getSelectionModel();
+        const previousModel = this.list.getSelectionModel();
+        this.list.updateProps(
+            oldProps ? filterProps(oldProps, RENDERER_PROPS) : null,
+            filterProps(newProps, RENDERER_PROPS),
+        );
+        const currentModel = this.list.getSelectionModel();
 
         if (previousModel !== currentModel) {
             this.container.setModel(currentModel);

package/src/nodes/internal/accessible.ts

@@ -0,0 +1,156 @@
+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);
+        }
+    }
+};