@gtkx/components 0.21.0

package/src/utils/position-only-model.ts

@@ -0,0 +1,115 @@
+import * as Gio from "@gtkx/gi/gio";
+import type * as GObject from "@gtkx/gi/gobject";
+import * as Gtk from "@gtkx/gi/gtk";
+import type { ListItem } from "../types.js";
+import type { RowValue } from "./item-resolver.js";
+import { treeItemMetadata } from "./list-item-flatten.js";
+
+const emptyStrings = (count: number): string[] => new Array<string>(Math.max(0, count)).fill("");
+
+export const retagRows = <T, S>(
+    items: ListItem<T, S>[],
+    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
+    placeholdersById: Map<string, GObject.Object>,
+): void => {
+    const walk = (list: ListItem<T, S>[]): void => {
+        for (const item of list) {
+            const placeholder = placeholdersById.get(item.id);
+            if (placeholder !== undefined) {
+                rowValues.set(placeholder, {
+                    id: item.id,
+                    value: item.value,
+                    isHeader: item.section === true,
+                    metadata: treeItemMetadata(item),
+                });
+            }
+            if (item.children !== undefined && item.children.length > 0) walk(item.children);
+        }
+    };
+    walk(items);
+};
+
+export const createFlatModel = (count: number): Gtk.StringList => Gtk.StringList.new(emptyStrings(count));
+
+export const resizeFlatModel = (model: Gtk.StringList, count: number): void => {
+    const target = Math.max(0, count);
+    const current = model.getNItems();
+    if (current === target) return;
+    if (target > current) {
+        model.splice(current, 0, emptyStrings(target - current));
+        return;
+    }
+    model.splice(target, current - target, null);
+};
+
+const createTaggedRow = <T, S>(
+    row: RowValue<T, S>,
+    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
+    placeholdersById?: Map<string, GObject.Object>,
+): GObject.Object => {
+    const placeholder = Gtk.StringObject.new("");
+    rowValues.set(placeholder, row);
+    if (placeholdersById !== undefined) placeholdersById.set(row.id, placeholder);
+    return placeholder;
+};
+
+const childModelOf = <T, S>(
+    children: ListItem<T, S>[],
+    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
+    placeholdersById: Map<string, GObject.Object>,
+): Gio.ListStore => {
+    const store = Gio.ListStore.new(Gtk.StringObject.prototype.__gtype__);
+    for (const child of children) {
+        store.append(
+            createTaggedRow(
+                { id: child.id, value: child.value, isHeader: false, metadata: treeItemMetadata(child) },
+                rowValues,
+                placeholdersById,
+            ),
+        );
+    }
+    return store;
+};
+
+export const createTreeModel = <T, S>(
+    items: ListItem<T, S>[],
+    autoexpand: boolean,
+    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
+    placeholdersById: Map<string, GObject.Object>,
+): Gtk.TreeListModel => {
+    const childrenByRow = new WeakMap<GObject.Object, ListItem<T, S>[]>();
+    const root = Gio.ListStore.new(Gtk.StringObject.prototype.__gtype__);
+    for (const item of items) {
+        const placeholder = createTaggedRow(
+            { id: item.id, value: item.value, isHeader: item.section === true, metadata: treeItemMetadata(item) },
+            rowValues,
+            placeholdersById,
+        );
+        if (item.children !== undefined && item.children.length > 0) {
+            childrenByRow.set(placeholder, item.children);
+        }
+        root.append(placeholder);
+    }
+    const createFunc = (rowItem: GObject.Object): Gio.ListModel | null => {
+        const children = childrenByRow.get(rowItem);
+        if (children === undefined) return null;
+        const store = childModelOf(children, rowValues, placeholdersById);
+        for (let index = 0; index < children.length; index++) {
+            const child = children[index];
+            if (child !== undefined && child.children !== undefined && child.children.length > 0) {
+                const placeholder = store.getItem(index);
+                if (placeholder !== null) childrenByRow.set(placeholder, child.children);
+            }
+        }
+        return store;
+    };
+    return Gtk.TreeListModel.new(root, false, autoexpand, createFunc);
+};
+
+export const createSectionModel = <T, S>(items: ListItem<T, S>[]): Gtk.FlattenListModel => {
+    const sections = Gio.ListStore.new(Gtk.StringList.prototype.__gtype__);
+    for (const section of items) {
+        sections.append(Gtk.StringList.new(emptyStrings(section.children?.length ?? 0)));
+    }
+    return Gtk.FlattenListModel.new(sections);
+};

package/src/utils/realized-slot-store.ts

@@ -0,0 +1,126 @@
+import type * as GObject from "@gtkx/gi/gobject";
+import type * as Gtk from "@gtkx/gi/gtk";
+
+export interface SlotEntry {
+    container: GObject.Object;
+    position: number;
+    treeRow: Gtk.TreeListRow | null;
+    item: GObject.Object | null;
+}
+
+let nextKey = 0;
+
+export class RealizedSlotStore {
+    private entries = new Map<GObject.Object, SlotEntry>();
+
+    private published = new Map<GObject.Object, SlotEntry>();
+
+    private setListeners = new Set<() => void>();
+
+    private positionListeners = new Map<GObject.Object, Set<() => void>>();
+
+    private positionFlushers = new Map<GObject.Object, () => void>();
+
+    private keys = new WeakMap<GObject.Object, string>();
+
+    private snapshot: GObject.Object[] = [];
+
+    subscribeSet = (onChange: () => void): (() => void) => {
+        this.setListeners.add(onChange);
+        return () => {
+            this.setListeners.delete(onChange);
+        };
+    };
+
+    getSlotsSnapshot = (): GObject.Object[] => this.snapshot;
+
+    subscribePosition = (container: GObject.Object, onChange: () => void): (() => void) => {
+        let listeners = this.positionListeners.get(container);
+        if (listeners === undefined) {
+            listeners = new Set();
+            this.positionListeners.set(container, listeners);
+        }
+        listeners.add(onChange);
+        return () => {
+            const current = this.positionListeners.get(container);
+            if (current === undefined) return;
+            current.delete(onChange);
+            if (current.size === 0) this.positionListeners.delete(container);
+        };
+    };
+
+    getPosition = (container: GObject.Object): SlotEntry => {
+        let entry = this.published.get(container);
+        if (entry === undefined) {
+            entry = { container, position: -1, treeRow: null, item: null };
+            this.published.set(container, entry);
+        }
+        return entry;
+    };
+
+    keyFor = (container: GObject.Object): string => {
+        const existing = this.keys.get(container);
+        if (existing !== undefined) return existing;
+        const key = `slot-${nextKey++}`;
+        this.keys.set(container, key);
+        return key;
+    };
+
+    addContainer = (container: GObject.Object): void => {
+        if (this.entries.has(container)) return;
+        this.entries.set(container, { container, position: -1, treeRow: null, item: null });
+        this.notifySet();
+    };
+
+    bind = (
+        container: GObject.Object,
+        position: number,
+        treeRow: Gtk.TreeListRow | null,
+        item: GObject.Object | null,
+    ): void => {
+        if (!this.entries.has(container)) {
+            this.entries.set(container, { container, position, treeRow, item });
+            this.notifySet();
+            return;
+        }
+        this.entries.set(container, { container, position, treeRow, item });
+        this.notifyPosition(container);
+    };
+
+    unbind = (container: GObject.Object): void => {
+        if (!this.entries.has(container)) return;
+        this.entries.set(container, { container, position: -1, treeRow: null, item: null });
+        this.notifyPosition(container);
+    };
+
+    removeContainer = (container: GObject.Object): void => {
+        if (!this.entries.delete(container)) return;
+        this.published.delete(container);
+        this.positionFlushers.delete(container);
+        this.notifySet();
+    };
+
+    private flushSet = (): void => {
+        this.snapshot = [...this.entries.keys()];
+        for (const listener of [...this.setListeners]) listener();
+    };
+
+    private notifySet(): void {
+        this.flushSet();
+    }
+
+    private notifyPosition(container: GObject.Object): void {
+        let flush = this.positionFlushers.get(container);
+        if (flush === undefined) {
+            flush = (): void => {
+                const live = this.entries.get(container);
+                if (live !== undefined) this.published.set(container, live);
+                const listeners = this.positionListeners.get(container);
+                if (listeners === undefined) return;
+                for (const listener of [...listeners]) listener();
+            };
+            this.positionFlushers.set(container, flush);
+        }
+        flush();
+    }
+}