@gtkx/react 0.19.0 → 0.21.0

package/dist/nodes/list.js

@@ -0,0 +1,950 @@
+import { getNativeId } from "@gtkx/ffi";
+import * as Adw from "@gtkx/ffi/adw";
+import * as Gio from "@gtkx/ffi/gio";
+import * as Gtk from "@gtkx/ffi/gtk";
+import { ColumnViewColumnNode } from "./column-view-column.js";
+import { ContainerSlotNode } from "./container-slot.js";
+import { EventControllerNode } from "./event-controller.js";
+import { filterProps, hasChanged } from "./internal/props.js";
+import { SlotNode } from "./slot.js";
+import { WidgetNode } from "./widget.js";
+const OWN_PROPS = [
+    "items",
+    "renderItem",
+    "renderListItem",
+    "renderHeader",
+    "renderCell",
+    "autoexpand",
+    "selected",
+    "onSelectionChanged",
+    "selectionMode",
+    "selectedId",
+    "sortColumn",
+    "sortOrder",
+    "onSortChanged",
+    "estimatedItemHeight",
+    "estimatedItemWidth",
+    "estimatedRowHeight",
+    "__boundItemsRef",
+    "__rerender",
+    "__headerBoundItemsRef",
+];
+const UNBOUND_POSITION = -1;
+function resizeStringList(model, newSize) {
+    const oldSize = model.getNItems();
+    if (newSize > oldSize) {
+        model.splice(oldSize, 0, new Array(newSize - oldSize).fill(""));
+    }
+    else if (newSize < oldSize) {
+        model.splice(newSize, oldSize - newSize, []);
+    }
+}
+export class ListNode extends WidgetNode {
+    model = null;
+    selectionModel = null;
+    treeModel = null;
+    factory = null;
+    headerFactory = null;
+    listFactory = null;
+    containers = new Map();
+    containerKeys = new Map();
+    headerContainers = new Map();
+    headerContainerKeys = new Map();
+    listContainers = new Map();
+    listContainerKeys = new Map();
+    treeExpanders = new Map();
+    disposed = false;
+    boundItemsUpdateScheduled = false;
+    syncScheduled = false;
+    sectionModels = [];
+    sectionStore = null;
+    flattenModel = null;
+    treeChildModels = new Map();
+    queriedLeaves = new Set();
+    rootItemIds = [];
+    isValidChild(child) {
+        return (child instanceof ColumnViewColumnNode ||
+            child instanceof EventControllerNode ||
+            child instanceof SlotNode ||
+            child instanceof ContainerSlotNode);
+    }
+    appendChild(child) {
+        const isMove = child instanceof ColumnViewColumnNode && this.children.includes(child);
+        super.appendChild(child);
+        if (child instanceof ColumnViewColumnNode) {
+            const columnView = this.container;
+            if (isMove) {
+                columnView.removeColumn(child.getColumn());
+            }
+            else {
+                child.installActionGroup(columnView);
+            }
+            columnView.appendColumn(child.getColumn());
+        }
+    }
+    removeChild(child) {
+        if (child instanceof ColumnViewColumnNode) {
+            const columnView = this.container;
+            columnView.removeColumn(child.getColumn());
+            child.uninstallActionGroup(columnView);
+        }
+        super.removeChild(child);
+    }
+    insertBefore(child, before) {
+        const isMove = child instanceof ColumnViewColumnNode && this.children.includes(child);
+        super.insertBefore(child, before);
+        if (child instanceof ColumnViewColumnNode) {
+            const columnView = this.container;
+            if (isMove) {
+                columnView.removeColumn(child.getColumn());
+            }
+            else {
+                child.installActionGroup(columnView);
+            }
+            const position = this.getColumnPosition(child);
+            columnView.insertColumn(position, child.getColumn());
+        }
+    }
+    finalizeInitialChildren(props) {
+        this.commitUpdate(null, props);
+        this.setupModel();
+        this.setupFactory();
+        if (this.props.renderHeader && !this.isDropDown()) {
+            this.setupHeaderFactory();
+        }
+        this.setupSelectionModel(props);
+        this.assignModelToWidget();
+        this.assignFactoryToWidget();
+        this.syncModel();
+        return true;
+    }
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.props = newProps;
+        if (oldProps === null)
+            return;
+        this.applyOwnProps(oldProps, newProps);
+    }
+    commitMount() {
+        this.connectSelectionSignal();
+        this.connectSortSignal();
+        this.applySelection(this.props.selected ?? null);
+        this.applySelectedId(this.props.selectedId ?? null);
+    }
+    detachDeletedInstance() {
+        this.disposed = true;
+        this.treeChildModels.clear();
+        this.queriedLeaves.clear();
+        this.treeExpanders.clear();
+        this.rootItemIds = [];
+        super.detachDeletedInstance();
+    }
+    getItems() {
+        return this.props.items ?? [];
+    }
+    collectFlatItems() {
+        const items = this.getItems();
+        const flat = [];
+        for (const item of items) {
+            if (item.section && item.children) {
+                for (const child of item.children) {
+                    flat.push(child);
+                }
+            }
+            else {
+                flat.push(item);
+            }
+        }
+        return flat;
+    }
+    collectSections() {
+        const items = this.getItems();
+        const sections = [];
+        for (const item of items) {
+            if (item.section) {
+                sections.push(item);
+            }
+        }
+        return sections;
+    }
+    collectRootItems() {
+        return this.getItems().filter((item) => !item.section);
+    }
+    isDropDown() {
+        return this.container instanceof Gtk.DropDown || this.container instanceof Adw.ComboRow;
+    }
+    isColumnView() {
+        return this.container instanceof Gtk.ColumnView;
+    }
+    detectMode() {
+        const items = this.getItems();
+        for (const item of items) {
+            if (item.section)
+                return "sections";
+            if (item.children && item.children.length > 0)
+                return "tree";
+        }
+        return "flat";
+    }
+    hasSections() {
+        return this.getItems().some((item) => item.section);
+    }
+    isTreeMode() {
+        const items = this.getItems();
+        for (const item of items) {
+            if (!item.section && item.children && item.children.length > 0)
+                return true;
+        }
+        return false;
+    }
+    setupModel() {
+        this.model = new Gtk.StringList();
+    }
+    setupFactory() {
+        if (this.isColumnView())
+            return;
+        this.factory = new Gtk.SignalListItemFactory();
+        const isTree = this.isTreeMode();
+        this.factory.connect("setup", (_self, obj) => {
+            const listItem = obj;
+            if (isTree) {
+                const expander = new Gtk.TreeExpander();
+                listItem.setChild(expander);
+                this.containers.set(expander, UNBOUND_POSITION);
+                this.containerKeys.set(expander, String(getNativeId(expander.handle)));
+                this.treeExpanders.set(listItem, expander);
+            }
+            else {
+                const { width, height } = this.getEstimatedItemSize();
+                if (width !== -1 || height !== -1) {
+                    const placeholder = new Gtk.Box();
+                    placeholder.setSizeRequest(width, height);
+                    listItem.setChild(placeholder);
+                }
+                this.containers.set(listItem, UNBOUND_POSITION);
+                this.containerKeys.set(listItem, String(getNativeId(listItem.handle)));
+            }
+        });
+        this.factory.connect("bind", (_self, obj) => {
+            if (this.disposed)
+                return;
+            const listItem = obj;
+            const position = listItem.getPosition();
+            if (isTree) {
+                const expander = this.treeExpanders.get(listItem);
+                const row = listItem.getItem();
+                expander.setListRow(row);
+                this.applyEstimatedItemSize(expander);
+                const treeItem = this.resolveTreeItem(row);
+                if (treeItem) {
+                    this.applyTreeExpanderProps(expander, treeItem);
+                }
+                this.containers.set(expander, position);
+            }
+            else {
+                this.containers.set(listItem, position);
+            }
+            this.scheduleBoundItemsUpdate();
+        });
+        this.factory.connect("unbind", (_self, obj) => {
+            if (this.disposed)
+                return;
+            const listItem = obj;
+            if (isTree) {
+                const expander = this.treeExpanders.get(listItem);
+                this.containers.set(expander, UNBOUND_POSITION);
+                expander.setListRow(null);
+            }
+            else {
+                this.containers.set(listItem, UNBOUND_POSITION);
+            }
+            this.scheduleBoundItemsUpdate();
+        });
+        this.factory.connect("teardown", (_self, obj) => {
+            if (this.disposed)
+                return;
+            const listItem = obj;
+            if (isTree) {
+                const expander = this.treeExpanders.get(listItem);
+                if (expander) {
+                    this.containers.delete(expander);
+                    this.containerKeys.delete(expander);
+                }
+                this.treeExpanders.delete(listItem);
+            }
+            else {
+                this.containers.delete(listItem);
+                this.containerKeys.delete(listItem);
+            }
+            listItem.setChild(null);
+        });
+        if (this.props.renderListItem && this.isDropDown()) {
+            this.setupListFactory();
+        }
+    }
+    setupListFactory() {
+        this.listFactory = new Gtk.SignalListItemFactory();
+        this.listFactory.connect("setup", (_self, obj) => {
+            const listItem = obj;
+            this.listContainers.set(listItem, UNBOUND_POSITION);
+            this.listContainerKeys.set(listItem, String(getNativeId(listItem.handle)));
+        });
+        this.listFactory.connect("bind", (_self, obj) => {
+            const listItem = obj;
+            this.listContainers.set(listItem, listItem.getPosition());
+            this.scheduleBoundItemsUpdate();
+        });
+        this.listFactory.connect("unbind", (_self, obj) => {
+            const listItem = obj;
+            this.listContainers.set(listItem, UNBOUND_POSITION);
+            this.scheduleBoundItemsUpdate();
+        });
+        this.listFactory.connect("teardown", (_self, obj) => {
+            const listItem = obj;
+            this.listContainers.delete(listItem);
+            this.listContainerKeys.delete(listItem);
+            listItem.setChild(null);
+        });
+    }
+    setupHeaderFactory() {
+        this.headerFactory = new Gtk.SignalListItemFactory();
+        this.headerFactory.connect("setup", (_self, obj) => {
+            const listHeader = obj;
+            this.headerContainers.set(listHeader, UNBOUND_POSITION);
+            this.headerContainerKeys.set(listHeader, String(getNativeId(listHeader.handle)));
+        });
+        this.headerFactory.connect("bind", (_self, obj) => {
+            const listHeader = obj;
+            this.headerContainers.set(listHeader, listHeader.getStart());
+            this.scheduleBoundItemsUpdate();
+        });
+        this.headerFactory.connect("unbind", (_self, obj) => {
+            const listHeader = obj;
+            this.headerContainers.set(listHeader, UNBOUND_POSITION);
+            this.scheduleBoundItemsUpdate();
+        });
+        this.headerFactory.connect("teardown", (_self, obj) => {
+            const listHeader = obj;
+            this.headerContainers.delete(listHeader);
+            this.headerContainerKeys.delete(listHeader);
+            listHeader.setChild(null);
+        });
+    }
+    setupSelectionModel(props) {
+        const baseModel = this.getBaseModel();
+        const selectionMode = props.selectionMode ?? (this.isDropDown() ? null : Gtk.SelectionMode.SINGLE);
+        if (this.isDropDown()) {
+            this.selectionModel = null;
+            return;
+        }
+        if (selectionMode === Gtk.SelectionMode.MULTIPLE) {
+            this.selectionModel = new Gtk.MultiSelection(baseModel);
+        }
+        else if (selectionMode === Gtk.SelectionMode.NONE) {
+            this.selectionModel = new Gtk.NoSelection(baseModel);
+        }
+        else {
+            const sel = new Gtk.SingleSelection(baseModel);
+            sel.setAutoselect(false);
+            sel.setCanUnselect(true);
+            this.selectionModel = sel;
+        }
+    }
+    getBaseModel() {
+        if (this.treeModel)
+            return this.treeModel;
+        if (this.flattenModel)
+            return this.flattenModel;
+        return this.model;
+    }
+    assignModelToWidget() {
+        const widget = this.container;
+        if (this.isDropDown()) {
+            const dropDownModel = this.hasSections()
+                ? this.flattenModel
+                : this.model;
+            if (widget instanceof Gtk.DropDown) {
+                widget.setModel(dropDownModel);
+            }
+            else if (widget instanceof Adw.ComboRow) {
+                widget.setModel(dropDownModel);
+            }
+            return;
+        }
+        if (!this.selectionModel)
+            return;
+        if (widget instanceof Gtk.ListView) {
+            widget.setModel(this.selectionModel);
+        }
+        else if (widget instanceof Gtk.GridView) {
+            widget.setModel(this.selectionModel);
+        }
+        else if (widget instanceof Gtk.ColumnView) {
+            widget.setModel(this.selectionModel);
+        }
+    }
+    assignFactoryToWidget() {
+        const widget = this.container;
+        if (widget instanceof Gtk.ListView) {
+            widget.setFactory(this.factory);
+            if (this.headerFactory) {
+                widget.setHeaderFactory(this.headerFactory);
+            }
+        }
+        else if (widget instanceof Gtk.ColumnView) {
+            if (this.headerFactory) {
+                widget.setHeaderFactory(this.headerFactory);
+            }
+        }
+        else if (widget instanceof Gtk.GridView) {
+            widget.setFactory(this.factory);
+        }
+        else if (widget instanceof Gtk.DropDown) {
+            widget.setFactory(this.factory);
+            if (this.listFactory) {
+                widget.setListFactory(this.listFactory);
+            }
+            if (this.headerFactory) {
+                widget.setHeaderFactory(this.headerFactory);
+            }
+        }
+        else if (widget instanceof Adw.ComboRow) {
+            widget.setFactory(this.factory);
+            if (this.listFactory) {
+                widget.setListFactory(this.listFactory);
+            }
+            if (this.headerFactory) {
+                widget.setHeaderFactory(this.headerFactory);
+            }
+        }
+    }
+    syncModel() {
+        if (!this.model)
+            return;
+        const mode = this.detectMode();
+        if (mode === "sections") {
+            this.syncSectionModel();
+            return;
+        }
+        if (mode === "tree") {
+            this.syncTreeModel();
+            return;
+        }
+        const flatItems = this.collectFlatItems();
+        resizeStringList(this.model, flatItems.length);
+        this.scheduleBoundItemsUpdate();
+    }
+    syncTreeModel() {
+        if (!this.model)
+            return;
+        const rootItems = this.collectRootItems();
+        const newSize = rootItems.length;
+        if (!this.treeModel) {
+            this.model.splice(0, this.model.getNItems(), new Array(newSize).fill(""));
+            this.rootItemIds = rootItems.map((item) => item.id);
+            this.treeModel = new Gtk.TreeListModel(this.model, false, this.props.autoexpand ?? false, (_item) => this.createChildModel(_item));
+            if (this.selectionModel) {
+                if (this.selectionModel instanceof Gtk.SingleSelection) {
+                    this.selectionModel.setModel(this.treeModel);
+                }
+                else if (this.selectionModel instanceof Gtk.MultiSelection) {
+                    this.selectionModel.setModel(this.treeModel);
+                }
+                else if (this.selectionModel instanceof Gtk.NoSelection) {
+                    this.selectionModel.setModel(this.treeModel);
+                }
+            }
+            this.scheduleBoundItemsUpdate();
+            return;
+        }
+        const oldSize = this.model.getNItems();
+        const overlap = Math.min(oldSize, newSize);
+        const transitionPositions = [];
+        for (let i = 0; i < overlap; i++) {
+            const obj = this.model.getObject(i);
+            if (!obj)
+                continue;
+            if (this.rootItemIds[i] !== rootItems[i]?.id) {
+                this.treeChildModels.delete(obj.handle);
+                this.queriedLeaves.delete(obj.handle);
+                transitionPositions.push(i);
+                continue;
+            }
+            const cachedChildModel = this.treeChildModels.get(obj.handle);
+            const newChildCount = rootItems[i]?.children?.length ?? 0;
+            if (cachedChildModel && newChildCount > 0) {
+                resizeStringList(cachedChildModel, newChildCount);
+            }
+            else if (cachedChildModel && newChildCount === 0) {
+                this.treeChildModels.delete(obj.handle);
+                transitionPositions.push(i);
+            }
+            else if (!cachedChildModel && newChildCount > 0) {
+                transitionPositions.push(i);
+            }
+        }
+        for (let i = overlap; i < oldSize; i++) {
+            const obj = this.model.getObject(i);
+            if (obj) {
+                this.treeChildModels.delete(obj.handle);
+                this.queriedLeaves.delete(obj.handle);
+            }
+        }
+        resizeStringList(this.model, newSize);
+        for (const pos of transitionPositions) {
+            if (pos < newSize) {
+                const oldObj = this.model.getObject(pos);
+                if (oldObj) {
+                    this.queriedLeaves.delete(oldObj.handle);
+                    this.treeChildModels.delete(oldObj.handle);
+                }
+                this.model.splice(pos, 1, [""]);
+            }
+        }
+        this.rootItemIds = rootItems.map((item) => item.id);
+        this.scheduleBoundItemsUpdate();
+    }
+    createChildModel(_item) {
+        const rootItems = this.collectRootItems();
+        const position = this.findStringObjectPosition(_item);
+        if (position === null || position >= rootItems.length) {
+            this.queriedLeaves.add(_item.handle);
+            return null;
+        }
+        const item = rootItems[position];
+        if (!item?.children || item.children.length === 0) {
+            this.queriedLeaves.add(_item.handle);
+            return null;
+        }
+        const childModel = new Gtk.StringList();
+        resizeStringList(childModel, item.children.length);
+        this.treeChildModels.set(_item.handle, childModel);
+        this.queriedLeaves.delete(_item.handle);
+        return childModel;
+    }
+    findStringObjectPosition(item) {
+        if (!this.model)
+            return null;
+        const nItems = this.model.getNItems();
+        for (let i = 0; i < nItems; i++) {
+            const obj = this.model.getObject(i);
+            if (obj && obj.handle === item.handle) {
+                return i;
+            }
+        }
+        return null;
+    }
+    syncSectionModel() {
+        if (!this.model)
+            return;
+        const sections = this.collectSections();
+        if (!this.sectionStore) {
+            this.sectionStore = new Gio.ListStore(Gtk.StringList.getGType());
+            this.flattenModel = new Gtk.FlattenListModel(this.sectionStore);
+            if (this.selectionModel) {
+                if (this.selectionModel instanceof Gtk.SingleSelection) {
+                    this.selectionModel.setModel(this.flattenModel);
+                }
+                else if (this.selectionModel instanceof Gtk.MultiSelection) {
+                    this.selectionModel.setModel(this.flattenModel);
+                }
+                else if (this.selectionModel instanceof Gtk.NoSelection) {
+                    this.selectionModel.setModel(this.flattenModel);
+                }
+            }
+            if (this.isDropDown()) {
+                this.assignModelToWidget();
+            }
+        }
+        while (this.sectionModels.length > sections.length) {
+            this.sectionModels.pop();
+            this.sectionStore.remove(this.sectionStore.getNItems() - 1);
+        }
+        for (let i = 0; i < sections.length; i++) {
+            const section = sections[i];
+            const itemCount = section.children?.length ?? 0;
+            if (i >= this.sectionModels.length) {
+                const sectionModel = new Gtk.StringList();
+                resizeStringList(sectionModel, itemCount);
+                this.sectionModels.push(sectionModel);
+                this.sectionStore.append(sectionModel);
+            }
+            else {
+                resizeStringList(this.sectionModels[i], itemCount);
+            }
+        }
+        this.scheduleBoundItemsUpdate();
+    }
+    resolveTreeItem(row) {
+        const rootItems = this.collectRootItems();
+        const depth = row.getDepth();
+        if (depth === 0) {
+            const rootItem = row.getItem();
+            if (!rootItem)
+                return null;
+            const pos = this.findStringObjectPosition(rootItem);
+            if (pos === null)
+                return null;
+            return rootItems[pos] ?? null;
+        }
+        const parentRow = row.getParent();
+        if (!parentRow)
+            return null;
+        const parentItem = this.resolveTreeItem(parentRow);
+        if (!parentItem?.children)
+            return null;
+        const childItem = row.getItem();
+        if (!childItem)
+            return null;
+        const childModel = parentRow.getChildren();
+        if (childModel) {
+            for (let j = 0; j < childModel.getNItems(); j++) {
+                const obj = childModel.getObject(j);
+                if (obj && obj.handle === childItem.handle) {
+                    return parentItem.children[j] ?? null;
+                }
+            }
+        }
+        return null;
+    }
+    applyTreeExpanderProps(expander, item) {
+        if (item.section)
+            return;
+        expander.setIndentForDepth(item.indentForDepth ?? true);
+        expander.setIndentForIcon(item.indentForIcon ?? true);
+        expander.setHideExpander(item.hideExpander ?? false);
+    }
+    resolveItemIdAtPosition(position) {
+        if (this.treeModel) {
+            const row = this.treeModel.getRow(position);
+            const item = row ? this.resolveTreeItem(row) : null;
+            return item?.id ?? null;
+        }
+        const flatItems = this.collectFlatItems();
+        return flatItems[position]?.id ?? null;
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (hasChanged(oldProps, newProps, "items")) {
+            this.scheduleSync();
+        }
+        if (hasChanged(oldProps, newProps, "selected")) {
+            this.applySelection(newProps.selected ?? null);
+        }
+        if (hasChanged(oldProps, newProps, "selectedId")) {
+            this.applySelectedId(newProps.selectedId ?? null);
+        }
+        if (hasChanged(oldProps, newProps, "onSelectionChanged")) {
+            this.connectSelectionSignal();
+        }
+        if (hasChanged(oldProps, newProps, "selectionMode")) {
+            this.rebuildSelectionModel(newProps);
+        }
+        if (hasChanged(oldProps, newProps, "renderItem") ||
+            hasChanged(oldProps, newProps, "renderListItem") ||
+            hasChanged(oldProps, newProps, "renderHeader")) {
+            this.scheduleBoundItemsUpdate();
+        }
+        if (hasChanged(oldProps, newProps, "autoexpand") && this.treeModel) {
+            this.treeModel.setAutoexpand(newProps.autoexpand ?? false);
+        }
+        if (hasChanged(oldProps, newProps, "onSortChanged")) {
+            this.connectSortSignal();
+        }
+        if (hasChanged(oldProps, newProps, "sortColumn") || hasChanged(oldProps, newProps, "sortOrder")) {
+            this.applySortColumn(newProps);
+        }
+    }
+    rebuildSelectionModel(props) {
+        const baseModel = this.getBaseModel();
+        const selectionMode = props.selectionMode ?? Gtk.SelectionMode.SINGLE;
+        if (selectionMode === Gtk.SelectionMode.MULTIPLE) {
+            this.selectionModel = new Gtk.MultiSelection(baseModel);
+        }
+        else if (selectionMode === Gtk.SelectionMode.NONE) {
+            this.selectionModel = new Gtk.NoSelection(baseModel);
+        }
+        else {
+            const sel = new Gtk.SingleSelection(baseModel);
+            sel.setAutoselect(false);
+            sel.setCanUnselect(true);
+            this.selectionModel = sel;
+        }
+        this.assignModelToWidget();
+        this.connectSelectionSignal();
+    }
+    applySelection(ids) {
+        if (!this.selectionModel || this.isDropDown())
+            return;
+        if (!ids || ids.length === 0) {
+            if (this.selectionModel instanceof Gtk.SingleSelection) {
+                this.selectionModel.setSelected(Gtk.INVALID_LIST_POSITION);
+            }
+            else if (this.selectionModel instanceof Gtk.MultiSelection) {
+                this.selectionModel.unselectAll();
+            }
+            return;
+        }
+        const idSet = new Set(ids);
+        const nItems = this.selectionModel.getNItems();
+        if (this.selectionModel instanceof Gtk.SingleSelection) {
+            for (let i = 0; i < nItems; i++) {
+                const id = this.resolveItemIdAtPosition(i);
+                if (id && idSet.has(id)) {
+                    this.selectionModel.setSelected(i);
+                    return;
+                }
+            }
+        }
+        else if (this.selectionModel instanceof Gtk.MultiSelection) {
+            this.selectionModel.unselectAll();
+            for (let i = 0; i < nItems; i++) {
+                const id = this.resolveItemIdAtPosition(i);
+                if (id && idSet.has(id)) {
+                    this.selectionModel.selectItem(i, false);
+                }
+            }
+        }
+    }
+    applySelectedId(id) {
+        if (!this.isDropDown())
+            return;
+        if (id === null || id === undefined)
+            return;
+        const flatItems = this.collectFlatItems();
+        for (let i = 0; i < flatItems.length; i++) {
+            if (flatItems[i]?.id === id) {
+                if (this.container instanceof Gtk.DropDown) {
+                    this.container.setSelected(i);
+                }
+                else if (this.container instanceof Adw.ComboRow) {
+                    this.container.setSelected(i);
+                }
+                return;
+            }
+        }
+    }
+    connectSelectionSignal() {
+        const { onSelectionChanged } = this.props;
+        if (this.isDropDown()) {
+            const handler = onSelectionChanged
+                ? () => {
+                    const position = this.container instanceof Gtk.DropDown
+                        ? this.container.getSelected()
+                        : this.container instanceof Adw.ComboRow
+                            ? this.container.getSelected()
+                            : -1;
+                    const flatItems = this.collectFlatItems();
+                    const item = flatItems[position];
+                    if (item) {
+                        onSelectionChanged(item.id);
+                    }
+                }
+                : undefined;
+            this.signalStore.set(this, this.container, "notify::selected", handler);
+            return;
+        }
+        if (!this.selectionModel)
+            return;
+        const handler = onSelectionChanged
+            ? () => {
+                const selection = this.selectionModel?.getSelection();
+                if (!selection)
+                    return;
+                const ids = [];
+                const nItems = this.selectionModel?.getNItems() ?? 0;
+                if (this.treeModel) {
+                    for (let i = 0; i < nItems; i++) {
+                        if (selection.contains(i)) {
+                            const row = this.treeModel.getRow(i);
+                            const item = row ? this.resolveTreeItem(row) : null;
+                            if (item)
+                                ids.push(item.id);
+                        }
+                    }
+                }
+                else {
+                    const flatItems = this.collectFlatItems();
+                    for (let i = 0; i < nItems; i++) {
+                        if (selection.contains(i)) {
+                            const item = flatItems[i];
+                            if (item)
+                                ids.push(item.id);
+                        }
+                    }
+                }
+                onSelectionChanged(ids);
+            }
+            : undefined;
+        this.signalStore.set(this, this.selectionModel, "selection-changed", handler, {
+            blockable: false,
+        });
+    }
+    connectSortSignal() {
+        if (!this.isColumnView())
+            return;
+        const columnView = this.container;
+        const sorter = columnView.getSorter();
+        if (!sorter)
+            return;
+        const { onSortChanged } = this.props;
+        const handler = onSortChanged
+            ? () => {
+                const cvSorter = columnView.getSorter();
+                if (!cvSorter) {
+                    onSortChanged(null, Gtk.SortType.ASCENDING);
+                    return;
+                }
+                const primaryColumn = cvSorter.getPrimarySortColumn();
+                const primaryOrder = cvSorter.getPrimarySortOrder();
+                const columnId = primaryColumn?.getId() ?? null;
+                onSortChanged(columnId, primaryOrder);
+            }
+            : undefined;
+        this.signalStore.set(this, sorter, "changed", handler, { blockable: false });
+    }
+    applySortColumn(props) {
+        if (!this.isColumnView())
+            return;
+        const columnView = this.container;
+        const { sortColumn, sortOrder } = props;
+        if (sortColumn === null || sortColumn === undefined) {
+            columnView.sortByColumn(Gtk.SortType.ASCENDING, null);
+            return;
+        }
+        const column = this.findColumnById(sortColumn);
+        if (column) {
+            columnView.sortByColumn(sortOrder ?? Gtk.SortType.ASCENDING, column);
+        }
+    }
+    findColumnById(id) {
+        if (!this.isColumnView())
+            return null;
+        const columnView = this.container;
+        const columns = columnView.getColumns();
+        const nItems = columns.getNItems();
+        for (let i = 0; i < nItems; i++) {
+            const obj = columns.getObject(i);
+            if (obj && obj.getId() === id) {
+                return obj;
+            }
+        }
+        return null;
+    }
+    scheduleSync() {
+        if (this.syncScheduled)
+            return;
+        this.syncScheduled = true;
+        queueMicrotask(() => {
+            this.syncScheduled = false;
+            if (this.disposed)
+                return;
+            this.syncModel();
+        });
+    }
+    scheduleBoundItemsUpdate() {
+        if (this.boundItemsUpdateScheduled)
+            return;
+        this.boundItemsUpdateScheduled = true;
+        queueMicrotask(() => {
+            this.boundItemsUpdateScheduled = false;
+            if (this.disposed)
+                return;
+            this.rebuildBoundItems();
+        });
+    }
+    rebuildBoundItems() {
+        const { __boundItemsRef, __rerender, __headerBoundItemsRef, renderItem, renderListItem, renderHeader } = this.props;
+        if (!__boundItemsRef || !__rerender)
+            return;
+        const flatItems = this.collectFlatItems();
+        const newBoundItems = [];
+        if (this.isColumnView()) {
+            for (const child of this.children) {
+                if (child instanceof ColumnViewColumnNode) {
+                    newBoundItems.push(...child.collectBoundItems(flatItems));
+                }
+            }
+        }
+        else {
+            const renderFn = renderItem ?? (this.isDropDown() ? (item) => String(item ?? "") : null);
+            if (renderFn) {
+                this.collectContainerBoundItems(this.containers, this.containerKeys, flatItems, renderFn, newBoundItems);
+            }
+            if (renderListItem && this.isDropDown()) {
+                this.collectContainerBoundItems(this.listContainers, this.listContainerKeys, flatItems, renderListItem, newBoundItems);
+            }
+        }
+        __boundItemsRef.current = newBoundItems;
+        if (__headerBoundItemsRef && renderHeader && this.sectionStore !== null) {
+            const sections = this.collectSections();
+            const headerBoundItems = [];
+            let sectionStart = 0;
+            for (let i = 0; i < sections.length; i++) {
+                const section = sections[i];
+                for (const [container, position] of this.headerContainers) {
+                    if (position === UNBOUND_POSITION)
+                        continue;
+                    if (position === sectionStart) {
+                        const key = this.headerContainerKeys.get(container);
+                        if (key) {
+                            const content = renderHeader(section.value);
+                            headerBoundItems.push([content, container, key]);
+                        }
+                    }
+                }
+                sectionStart += section.children?.length ?? 0;
+            }
+            __headerBoundItemsRef.current = headerBoundItems;
+        }
+        __rerender();
+    }
+    collectContainerBoundItems(containers, containerKeys, flatItems, renderFn, out) {
+        const isTree = this.treeModel !== null;
+        for (const [container, position] of containers) {
+            if (position === UNBOUND_POSITION)
+                continue;
+            const key = containerKeys.get(container);
+            if (!key)
+                continue;
+            if (isTree) {
+                const expander = container;
+                const row = expander.getListRow() ?? null;
+                if (!row)
+                    continue;
+                const item = this.resolveTreeItem(row);
+                if (!item)
+                    continue;
+                const content = renderFn(item.value, row);
+                out.push([content, container, key]);
+            }
+            else {
+                const item = flatItems[position];
+                if (!item)
+                    continue;
+                const content = renderFn(item.value);
+                out.push([content, container, key]);
+            }
+        }
+    }
+    getEstimatedItemSize() {
+        return {
+            width: this.props.estimatedItemWidth ?? -1,
+            height: this.props.estimatedItemHeight ?? -1,
+        };
+    }
+    applyEstimatedItemSize(widget) {
+        const { width, height } = this.getEstimatedItemSize();
+        widget.setSizeRequest(width, height);
+    }
+    getColumnPosition(columnNode) {
+        let columnIndex = 0;
+        for (const child of this.children) {
+            if (child === columnNode)
+                return columnIndex;
+            if (child instanceof ColumnViewColumnNode)
+                columnIndex++;
+        }
+        return columnIndex;
+    }
+}
+//# sourceMappingURL=list.js.map