@gtkx/react 0.18.0 → 0.18.2

package/src/nodes/internal/base-item-renderer.ts

@@ -0,0 +1,108 @@
+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 { reconciler } from "../../reconciler.js";
+import type { SignalStore } from "./signal-store.js";
+
+export abstract class BaseItemRenderer<TStore = unknown> {
+    protected factory: Gtk.SignalListItemFactory;
+    protected fiberRoots = new Map<Gtk.ListItem, Reconciler.FiberRoot>();
+    protected tornDown = new Set<Gtk.ListItem>();
+    protected estimatedItemHeight: number | null = null;
+    private store: TStore | null = null;
+    protected signalStore: SignalStore;
+
+    constructor(signalStore: SignalStore) {
+        this.signalStore = signalStore;
+        this.factory = new Gtk.SignalListItemFactory();
+        this.initializeFactory();
+    }
+
+    public getFactory(): Gtk.SignalListItemFactory {
+        return this.factory;
+    }
+
+    public setEstimatedItemHeight(height: number | null): void {
+        this.estimatedItemHeight = height;
+    }
+
+    public setStore(store: TStore | null): void {
+        this.store = store;
+    }
+
+    protected getStore(): TStore {
+        if (!this.store) {
+            throw new Error(`Expected store to be set on ${this.constructor.name}`);
+        }
+        return this.store;
+    }
+
+    public dispose(): void {
+        this.signalStore.clear(this);
+        this.fiberRoots.clear();
+        this.tornDown.clear();
+    }
+
+    protected abstract renderItem(listItem: Gtk.ListItem): ReactNode;
+    protected abstract onSetup(listItem: Gtk.ListItem): Gtk.Widget;
+    protected abstract onBind(listItem: Gtk.ListItem, fiberRoot: Reconciler.FiberRoot): void;
+    protected abstract onUnbind(listItem: Gtk.ListItem): void;
+
+    protected onSetupComplete(_listItem: Gtk.ListItem): void {}
+    protected onTeardown(_listItem: Gtk.ListItem): void {}
+
+    protected createBox(): Gtk.Box {
+        const box = new Gtk.Box(Gtk.Orientation.HORIZONTAL);
+        box.setValign(Gtk.Align.CENTER);
+
+        if (this.estimatedItemHeight !== null) {
+            box.setSizeRequest(-1, this.estimatedItemHeight);
+        }
+
+        return box;
+    }
+
+    protected clearBoxSizeRequest(box: Gtk.Widget): void {
+        if (box instanceof Gtk.Box) {
+            box.setSizeRequest(-1, -1);
+        }
+    }
+
+    private initializeFactory(): void {
+        this.signalStore.set(this, this.factory, "setup", (listItem: Gtk.ListItem) => {
+            const container = this.onSetup(listItem);
+            const fiberRoot = createFiberRoot(container);
+            this.fiberRoots.set(listItem, fiberRoot);
+            const element = this.renderItem(listItem);
+            reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {
+                if (this.tornDown.has(listItem)) return;
+                this.onSetupComplete(listItem);
+            });
+        });
+
+        this.signalStore.set(this, this.factory, "bind", (listItem: Gtk.ListItem) => {
+            const fiberRoot = this.fiberRoots.get(listItem);
+            if (!fiberRoot) return;
+            this.onBind(listItem, fiberRoot);
+        });
+
+        this.signalStore.set(this, this.factory, "unbind", (listItem: Gtk.ListItem) => {
+            this.onUnbind(listItem);
+        });
+
+        this.signalStore.set(this, this.factory, "teardown", (listItem: Gtk.ListItem) => {
+            const fiberRoot = this.fiberRoots.get(listItem);
+
+            if (fiberRoot) {
+                this.tornDown.add(listItem);
+                this.onTeardown(listItem);
+                reconciler.getInstance().updateContainer(null, fiberRoot, null, () => {});
+                queueMicrotask(() => {
+                    this.fiberRoots.delete(listItem);
+                    this.tornDown.delete(listItem);
+                });
+            }
+        });
+    }
+}

package/src/nodes/internal/grid-item-renderer.ts

@@ -0,0 +1,71 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { ReactNode } from "react";
+import type Reconciler from "react-reconciler";
+import { reconciler } from "../../reconciler.js";
+import { BaseItemRenderer } from "./base-item-renderer.js";
+import type { ListStore } from "./list-store.js";
+
+export type GridRenderItemFn<T> = (item: T | null) => ReactNode;
+
+export class GridItemRenderer extends BaseItemRenderer<ListStore> {
+    private renderFn: GridRenderItemFn<unknown> | null = () => null;
+    private boundItems = new Map<string, Gtk.ListItem>();
+
+    public setRenderFn(renderFn: GridRenderItemFn<unknown> | null): void {
+        this.renderFn = renderFn;
+    }
+
+    public rebindItem(id: string): void {
+        const listItem = this.boundItems.get(id);
+        if (!listItem) return;
+
+        const fiberRoot = this.fiberRoots.get(listItem);
+        if (!fiberRoot) return;
+
+        const item = this.getStore().getItem(id);
+        const element = this.renderFn?.(item);
+
+        reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {});
+    }
+
+    protected override renderItem(_listItem: Gtk.ListItem): ReactNode {
+        return this.renderFn?.(null);
+    }
+
+    private getItemFromListItem(listItem: Gtk.ListItem): string | null {
+        const stringObject = listItem.getItem();
+        if (!(stringObject instanceof Gtk.StringObject)) return null;
+        return stringObject.getString();
+    }
+
+    protected override onSetup(listItem: Gtk.ListItem): Gtk.Widget {
+        const box = this.createBox();
+        listItem.setChild(box);
+        return box;
+    }
+
+    protected override onBind(listItem: Gtk.ListItem, fiberRoot: Reconciler.FiberRoot): void {
+        const id = this.getItemFromListItem(listItem);
+        if (id !== null) {
+            this.boundItems.set(id, listItem);
+        }
+
+        const item = id !== null ? this.getStore().getItem(id) : null;
+        const element = this.renderFn?.(item);
+
+        reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {
+            if (this.tornDown.has(listItem)) return;
+            if (this.estimatedItemHeight !== null) return;
+            const currentFiberRoot = this.fiberRoots.get(listItem);
+            if (!currentFiberRoot) return;
+            this.clearBoxSizeRequest(currentFiberRoot.containerInfo);
+        });
+    }
+
+    protected override onUnbind(listItem: Gtk.ListItem): void {
+        const id = this.getItemFromListItem(listItem);
+        if (id !== null) {
+            this.boundItems.delete(id);
+        }
+    }
+}

package/src/nodes/internal/list-item-renderer.ts

@@ -0,0 +1,155 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { ReactNode } from "react";
+import type Reconciler from "react-reconciler";
+import { reconciler } from "../../reconciler.js";
+import { BaseItemRenderer } from "./base-item-renderer.js";
+import type { TreeStore } from "./tree-store.js";
+
+export type RenderItemFn<T> = (item: T | null, row: Gtk.TreeListRow | null) => ReactNode;
+
+type PendingBind = {
+    treeListRow: Gtk.TreeListRow;
+    expander: Gtk.TreeExpander;
+    id: string;
+};
+
+export class ListItemRenderer extends BaseItemRenderer<TreeStore> {
+    private expanders = new Map<Gtk.ListItem, Gtk.TreeExpander>();
+    private setupComplete = new Set<Gtk.ListItem>();
+    private pendingBinds = new Map<Gtk.ListItem, PendingBind>();
+    private renderFn: RenderItemFn<unknown> | null = () => null;
+    private boundItems = new Map<string, { listItem: Gtk.ListItem; treeListRow: Gtk.TreeListRow }>();
+
+    public setRenderFn(renderFn: RenderItemFn<unknown> | null): void {
+        this.renderFn = renderFn;
+    }
+
+    public rebindItem(id: string): void {
+        const binding = this.boundItems.get(id);
+        if (!binding) return;
+
+        const fiberRoot = this.fiberRoots.get(binding.listItem);
+        if (!fiberRoot) return;
+
+        const expander = this.expanders.get(binding.listItem);
+        if (!expander) return;
+
+        this.renderBind(binding.listItem, expander, binding.treeListRow, id, fiberRoot);
+    }
+
+    public override dispose(): void {
+        super.dispose();
+        this.expanders.clear();
+        this.setupComplete.clear();
+        this.pendingBinds.clear();
+        this.boundItems.clear();
+    }
+
+    protected override renderItem(_listItem: Gtk.ListItem): ReactNode {
+        return this.renderFn?.(null, null);
+    }
+
+    protected override onSetup(listItem: Gtk.ListItem): Gtk.Widget {
+        const expander = new Gtk.TreeExpander();
+        const box = this.createBox();
+        expander.setChild(box);
+        listItem.setChild(expander);
+        this.expanders.set(listItem, expander);
+        return box;
+    }
+
+    protected override onSetupComplete(listItem: Gtk.ListItem): void {
+        this.setupComplete.add(listItem);
+        this.processPendingBind(listItem);
+    }
+
+    protected override onBind(listItem: Gtk.ListItem, fiberRoot: Reconciler.FiberRoot): void {
+        const expander = this.expanders.get(listItem);
+        if (!expander) return;
+
+        const treeListRow = listItem.getItem();
+        if (!(treeListRow instanceof Gtk.TreeListRow)) return;
+
+        expander.setListRow(treeListRow);
+
+        const stringObject = treeListRow.getItem();
+        if (!(stringObject instanceof Gtk.StringObject)) return;
+
+        const id = stringObject.getString();
+        this.boundItems.set(id, { listItem, treeListRow });
+
+        if (!this.setupComplete.has(listItem)) {
+            this.pendingBinds.set(listItem, { treeListRow, expander, id });
+            return;
+        }
+
+        this.renderBind(listItem, expander, treeListRow, id, fiberRoot);
+    }
+
+    protected override onUnbind(listItem: Gtk.ListItem): void {
+        const expander = listItem.getChild();
+        if (expander instanceof Gtk.TreeExpander) {
+            expander.setListRow(null);
+            const treeListRow = listItem.getItem();
+            if (treeListRow instanceof Gtk.TreeListRow) {
+                const stringObject = treeListRow.getItem();
+                if (stringObject instanceof Gtk.StringObject) {
+                    this.boundItems.delete(stringObject.getString());
+                }
+            }
+        }
+    }
+
+    protected override onTeardown(listItem: Gtk.ListItem): void {
+        this.expanders.delete(listItem);
+        this.setupComplete.delete(listItem);
+        this.pendingBinds.delete(listItem);
+    }
+
+    private processPendingBind(listItem: Gtk.ListItem): void {
+        const pending = this.pendingBinds.get(listItem);
+        if (!pending) return;
+
+        this.pendingBinds.delete(listItem);
+        const fiberRoot = this.fiberRoots.get(listItem);
+        if (fiberRoot) {
+            this.renderBind(listItem, pending.expander, pending.treeListRow, pending.id, fiberRoot);
+        }
+    }
+
+    private renderBind(
+        listItem: Gtk.ListItem,
+        expander: Gtk.TreeExpander,
+        treeListRow: Gtk.TreeListRow,
+        id: string,
+        fiberRoot: Reconciler.FiberRoot,
+    ): void {
+        const itemData = this.getStore().getItem(id);
+
+        if (itemData) {
+            expander.setIndentForDepth(itemData.indentForDepth ?? true);
+            expander.setHideExpander(itemData.hideExpander ?? false);
+
+            if (itemData.indentForIcon !== undefined) {
+                expander.setIndentForIcon(itemData.indentForIcon);
+            } else {
+                expander.setIndentForIcon(treeListRow.isExpandable());
+            }
+        } else {
+            expander.setIndentForIcon(treeListRow.isExpandable());
+        }
+
+        const element = this.renderFn?.(itemData?.value ?? null, treeListRow);
+
+        reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {
+            if (this.tornDown.has(listItem)) return;
+            if (this.estimatedItemHeight !== null) return;
+            const currentExpander = this.expanders.get(listItem);
+            if (!currentExpander) return;
+            const box = currentExpander.getChild();
+            if (box) {
+                this.clearBoxSizeRequest(box);
+            }
+        });
+    }
+}

package/src/nodes/internal/list-store.ts

@@ -0,0 +1,105 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+
+export type ItemUpdatedCallback = (id: string) => void;
+
+export class ListStore {
+    private model = new Gtk.StringList();
+    private ids: string[] = [];
+    private idToIndex = new Map<string, number>();
+    private items = new Map<string, unknown>();
+    private onItemUpdated: ItemUpdatedCallback | null = null;
+    private pendingBatch: string[] | null = null;
+
+    public setOnItemUpdated(callback: ItemUpdatedCallback | null): void {
+        this.onItemUpdated = callback;
+    }
+
+    public beginBatch(): void {
+        this.pendingBatch = [];
+    }
+
+    public flushBatch(): void {
+        const batch = this.pendingBatch;
+        this.pendingBatch = null;
+        if (batch && batch.length > 0) {
+            this.model.splice(0, 0, batch);
+        }
+    }
+
+    public addItem(id: string, item: unknown): void {
+        this.items.set(id, item);
+
+        const existingIndex = this.idToIndex.get(id);
+        if (existingIndex !== undefined) {
+            this.model.remove(existingIndex);
+            this.ids.splice(existingIndex, 1);
+            this.rebuildIndices(existingIndex);
+        }
+
+        this.idToIndex.set(id, this.ids.length);
+        this.ids.push(id);
+
+        if (this.pendingBatch) {
+            this.pendingBatch.push(id);
+        } else {
+            this.model.append(id);
+        }
+    }
+
+    public removeItem(id: string): void {
+        const index = this.idToIndex.get(id);
+        if (index === undefined) return;
+
+        this.model.remove(index);
+        this.ids.splice(index, 1);
+        this.idToIndex.delete(id);
+        this.rebuildIndices(index);
+        this.items.delete(id);
+    }
+
+    public insertItemBefore(id: string, beforeId: string, item: unknown): void {
+        this.items.set(id, item);
+
+        const existingIndex = this.idToIndex.get(id);
+        if (existingIndex !== undefined) {
+            this.model.remove(existingIndex);
+            this.ids.splice(existingIndex, 1);
+            this.idToIndex.delete(id);
+            this.rebuildIndices(existingIndex);
+        }
+
+        const beforeIndex = this.idToIndex.get(beforeId);
+        if (beforeIndex === undefined) {
+            this.idToIndex.set(id, this.ids.length);
+            this.ids.push(id);
+            this.model.append(id);
+        } else {
+            this.ids.splice(beforeIndex, 0, id);
+            this.rebuildIndices(beforeIndex);
+            this.model.splice(beforeIndex, 0, [id]);
+        }
+    }
+
+    public updateItem(id: string, item: unknown): void {
+        if (this.items.has(id)) {
+            this.items.set(id, item);
+            this.onItemUpdated?.(id);
+        } else {
+            this.addItem(id, item);
+        }
+    }
+
+    public getItem(id: string): unknown {
+        return this.items.get(id);
+    }
+
+    public getModel(): Gtk.StringList {
+        return this.model;
+    }
+
+    private rebuildIndices(fromIndex: number): void {
+        for (let i = fromIndex; i < this.ids.length; i++) {
+            this.idToIndex.set(this.ids[i] as string, i);
+        }
+    }
+}

package/src/nodes/internal/predicates.ts

@@ -0,0 +1,80 @@
+/**
+ * Runtime type predicates for GTK widget capability detection.
+ *
+ * These predicates check for specific APIs that widgets may or may not expose.
+ * GTK widgets don't have a consistent interface - different widgets support
+ * different child management APIs - so runtime checking is necessary.
+ */
+import * as Gtk from "@gtkx/ffi/gtk";
+
+type AppendableWidget = Gtk.Widget & { append: (child: Gtk.Widget) => void };
+type AddableWidget = Gtk.Widget & { add: (child: Gtk.Widget) => void };
+type ContentWidget = Gtk.Widget & { setContent: (content?: Gtk.Widget | null) => void };
+type SingleChildWidget = Gtk.Widget & { setChild: (child: Gtk.Widget | null) => void };
+type RemovableWidget = Gtk.Widget & { remove: (child: Gtk.Widget) => void };
+
+export type ReorderableWidget = Gtk.Widget & {
+    reorderChildAfter: (child: Gtk.Widget, sibling?: Gtk.Widget) => void;
+    insertChildAfter: (child: Gtk.Widget, sibling?: Gtk.Widget) => void;
+};
+
+export type InsertableWidget = Gtk.Widget & {
+    insert: (child: Gtk.Widget, position: number) => void;
+    getFirstChild: () => Gtk.Widget | null;
+};
+
+type EditableWidget = Gtk.Widget & {
+    getPosition: () => number;
+    setPosition: (position: number) => void;
+    getText: () => string;
+};
+
+type BufferedWidget = Gtk.Widget & {
+    getBuffer: () => Gtk.TextBuffer;
+    setBuffer: (buffer?: Gtk.TextBuffer | null) => void;
+};
+
+export const isAppendable = (obj: unknown): obj is AppendableWidget =>
+    obj instanceof Gtk.Widget && "append" in obj && typeof obj.append === "function";
+
+export const isAddable = (obj: unknown): obj is AddableWidget =>
+    obj instanceof Gtk.Widget && "add" in obj && typeof obj.add === "function";
+
+export const isContentWidget = (obj: unknown): obj is ContentWidget =>
+    obj instanceof Gtk.Widget && "setContent" in obj && typeof obj.setContent === "function";
+
+export const isSingleChild = (obj: unknown): obj is SingleChildWidget =>
+    obj instanceof Gtk.Widget && "setChild" in obj && typeof obj.setChild === "function";
+
+export const isRemovable = (obj: unknown): obj is RemovableWidget =>
+    obj instanceof Gtk.Widget && "remove" in obj && typeof obj.remove === "function";
+
+export const isReorderable = (obj: unknown): obj is ReorderableWidget =>
+    obj instanceof Gtk.Widget &&
+    "reorderChildAfter" in obj &&
+    typeof obj.reorderChildAfter === "function" &&
+    "insertChildAfter" in obj &&
+    typeof obj.insertChildAfter === "function";
+
+export const isInsertable = (obj: unknown): obj is InsertableWidget =>
+    obj instanceof Gtk.Widget &&
+    "insert" in obj &&
+    typeof obj.insert === "function" &&
+    "getFirstChild" in obj &&
+    typeof obj.getFirstChild === "function";
+
+export const isEditable = (obj: unknown): obj is EditableWidget =>
+    obj instanceof Gtk.Widget &&
+    "getPosition" in obj &&
+    typeof obj.getPosition === "function" &&
+    "setPosition" in obj &&
+    typeof obj.setPosition === "function" &&
+    "getText" in obj &&
+    typeof obj.getText === "function";
+
+export const isBuffered = (obj: unknown): obj is BufferedWidget =>
+    obj instanceof Gtk.Widget &&
+    "getBuffer" in obj &&
+    typeof obj.getBuffer === "function" &&
+    "setBuffer" in obj &&
+    typeof obj.setBuffer === "function";

package/src/nodes/internal/props.ts

@@ -0,0 +1,51 @@
+import type { Props } from "../../types.js";
+
+export const filterProps = <T extends Props>(props: T, excludeKeys: readonly string[]): T => {
+    const result: Props = {};
+
+    for (const key of Object.keys(props)) {
+        if (!excludeKeys.includes(key)) {
+            result[key] = props[key];
+        }
+    }
+
+    return result as T;
+};
+
+export const hasChanged = <T>(oldProps: T | null, newProps: T, key: keyof T): boolean =>
+    !oldProps || oldProps[key] !== newProps[key];
+
+export const shallowArrayEqual = <T extends Record<string, unknown>>(a: T[], b: T[]): boolean => {
+    if (a.length !== b.length) return false;
+
+    for (let i = 0; i < a.length; i++) {
+        const itemA = a[i];
+        const itemB = b[i];
+        if (!itemA || !itemB) return false;
+
+        const keysA = Object.keys(itemA);
+        const keysB = Object.keys(itemB);
+        if (keysA.length !== keysB.length) return false;
+
+        for (const key of keysA) {
+            if (itemA[key] !== itemB[key]) return false;
+        }
+    }
+
+    return true;
+};
+
+export const primitiveArrayEqual = <T extends string | number | boolean>(
+    a: T[] | null | undefined,
+    b: T[] | null | undefined,
+): boolean => {
+    if (a === b) return true;
+    if (!a || !b) return false;
+    if (a.length !== b.length) return false;
+
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) return false;
+    }
+
+    return true;
+};

package/src/nodes/internal/selection-model-controller.ts

@@ -0,0 +1,115 @@
+import type * as Gio from "@gtkx/ffi/gio";
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { GtkListViewProps } from "../../jsx.js";
+import type { SignalStore } from "./signal-store.js";
+
+type SelectionModel = Gtk.NoSelection | Gtk.SingleSelection | Gtk.MultiSelection;
+
+export type SelectionModelConfig = Pick<GtkListViewProps, "selectionMode" | "selected" | "onSelectionChanged"> & {
+    owner: object;
+    signalStore: SignalStore;
+};
+
+export class SelectionModelController {
+    private owner: object;
+    private signalStore: SignalStore;
+    private selectionModel: SelectionModel;
+    private getSelection: () => string[];
+    private resolveSelectionIndices: (ids: string[]) => Gtk.Bitset;
+    private getItemCount: () => number;
+
+    constructor(
+        config: SelectionModelConfig,
+        model: Gio.ListModel,
+        getSelection: () => string[],
+        resolveSelectionIndices: (ids: string[]) => Gtk.Bitset,
+        getItemCount: () => number,
+    ) {
+        this.owner = config.owner;
+        this.signalStore = config.signalStore;
+        this.selectionModel = this.createSelectionModel(config.selectionMode, model);
+        this.selectionModel.setModel(model);
+        this.getSelection = getSelection;
+        this.resolveSelectionIndices = resolveSelectionIndices;
+        this.getItemCount = getItemCount;
+        this.initSelectionHandler(config.onSelectionChanged);
+        this.setSelection(config.selected);
+    }
+
+    public getSelectionModel(): SelectionModel {
+        return this.selectionModel;
+    }
+
+    public update(
+        oldProps: SelectionModelConfig | null,
+        newProps: SelectionModelConfig,
+        model: Gio.ListModel,
+    ): SelectionModel {
+        if (oldProps && oldProps.selectionMode !== newProps.selectionMode) {
+            this.signalStore.set(this.owner, this.selectionModel, "selection-changed", null);
+            this.selectionModel = this.createSelectionModel(newProps.selectionMode, model);
+            this.selectionModel.setModel(model);
+            this.initSelectionHandler(newProps.onSelectionChanged);
+            this.setSelection(newProps.selected);
+            return this.selectionModel;
+        }
+
+        if (!oldProps || oldProps.onSelectionChanged !== newProps.onSelectionChanged) {
+            this.initSelectionHandler(newProps.onSelectionChanged);
+        }
+
+        if (!oldProps || oldProps.selected !== newProps.selected) {
+            this.setSelection(newProps.selected);
+        }
+
+        return this.selectionModel;
+    }
+
+    private initSelectionHandler(onSelectionChanged?: ((ids: string[]) => void) | null): void {
+        if (!onSelectionChanged) {
+            this.signalStore.set(this.owner, this.selectionModel, "selection-changed", null);
+            return;
+        }
+
+        const handler = () => {
+            onSelectionChanged(this.getSelection());
+        };
+
+        this.signalStore.set(this.owner, this.selectionModel, "selection-changed", handler);
+    }
+
+    private createSelectionModel(mode: Gtk.SelectionMode | null | undefined, model: Gio.ListModel): SelectionModel {
+        const selectionMode = mode ?? Gtk.SelectionMode.SINGLE;
+
+        if (selectionMode === Gtk.SelectionMode.NONE) {
+            return new Gtk.NoSelection(model);
+        }
+
+        if (selectionMode === Gtk.SelectionMode.MULTIPLE) {
+            return new Gtk.MultiSelection(model);
+        }
+
+        const selectionModel = new Gtk.SingleSelection(model);
+        selectionModel.setAutoselect(selectionMode === Gtk.SelectionMode.BROWSE);
+        selectionModel.setCanUnselect(selectionMode !== Gtk.SelectionMode.BROWSE);
+
+        return selectionModel;
+    }
+
+    public reapplySelection(ids?: string[] | null): void {
+        this.setSelection(ids);
+    }
+
+    private setSelection(ids?: string[] | null): void {
+        const nItems = this.getItemCount();
+        const selected = ids ? this.resolveSelectionIndices(ids) : new Gtk.Bitset();
+        const mask = Gtk.Bitset.newRange(0, nItems);
+
+        if (this.selectionModel instanceof Gtk.SingleSelection) {
+            const position = selected.getSize() > 0 ? selected.getNth(0) : Gtk.INVALID_LIST_POSITION;
+            this.selectionModel.setSelected(position);
+        } else {
+            this.selectionModel.setSelection(selected, mask);
+        }
+    }
+}