@gtkx/react 0.20.0 → 1.0.0-rc.1

package/src/nodes/application.ts

@@ -1,61 +0,0 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import { Node } from "../node.js";
-import type { Container, Props } from "../types.js";
-import { MenuNode } from "./menu.js";
-import { MenuModel } from "./models/menu.js";
-import { WindowNode } from "./window.js";
-
-export class ApplicationNode extends Node<Gtk.Application, Props, Node, Node> {
-    private menu: MenuModel;
-
-    constructor(typeName: string, props: Props, container: Gtk.Application, rootContainer: Container) {
-        super(typeName, props, container, rootContainer);
-        const application = rootContainer instanceof Gtk.Application ? rootContainer : undefined;
-        this.menu = new MenuModel("root", {}, rootContainer, container, application);
-    }
-
-    public override isValidChild(): boolean {
-        return true;
-    }
-
-    public override appendChild(child: Node): void {
-        if (child instanceof MenuNode) {
-            this.menu.appendChild(child);
-            this.container.setMenubar(this.menu.getMenu());
-            return;
-        }
-
-        super.appendChild(child);
-    }
-
-    public override insertBefore(child: Node, before: Node): void {
-        if (child instanceof MenuNode) {
-            if (before instanceof MenuNode) {
-                this.menu.insertBefore(child, before);
-            } else {
-                this.menu.appendChild(child);
-            }
-            this.container.setMenubar(this.menu.getMenu());
-            return;
-        }
-
-        super.insertBefore(child, before);
-    }
-
-    public override removeChild(child: Node): void {
-        if (child instanceof MenuNode) {
-            this.menu.removeChild(child);
-
-            if (this.menu.getMenu().getNItems() === 0) {
-                this.container.setMenubar(null);
-            }
-            return;
-        }
-
-        if (child instanceof WindowNode) {
-            child.container.setVisible(false);
-        }
-
-        super.removeChild(child);
-    }
-}

package/src/nodes/calendar.ts

@@ -1,42 +0,0 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-import type { GtkCalendarProps } from "../jsx.js";
-import type { Node } from "../node.js";
-import { ContainerSlotNode } from "./container-slot.js";
-import { EventControllerNode } from "./event-controller.js";
-import { filterProps, primitiveArrayEqual } from "./internal/props.js";
-import { SlotNode } from "./slot.js";
-import { WidgetNode } from "./widget.js";
-
-const OWN_PROPS = ["markedDays"] as const;
-
-type CalendarProps = Pick<GtkCalendarProps, (typeof OWN_PROPS)[number]>;
-
-type CalendarChild = EventControllerNode | SlotNode | ContainerSlotNode;
-
-export class CalendarNode extends WidgetNode<Gtk.Calendar, CalendarProps, CalendarChild> {
-    public override isValidChild(child: Node): boolean {
-        return child instanceof EventControllerNode || child instanceof SlotNode || child instanceof ContainerSlotNode;
-    }
-    private appliedMarks: number[] = [];
-
-    public override commitUpdate(oldProps: CalendarProps | null, newProps: CalendarProps): void {
-        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
-        this.applyOwnProps(newProps);
-    }
-
-    private applyOwnProps(newProps: CalendarProps): void {
-        const newMarkedDays = newProps.markedDays ?? [];
-
-        if (primitiveArrayEqual(this.appliedMarks, newMarkedDays)) {
-            return;
-        }
-
-        this.container.clearMarks();
-
-        for (const day of newMarkedDays) {
-            this.container.markDay(day);
-        }
-
-        this.appliedMarks = [...newMarkedDays];
-    }
-}

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

@@ -1,69 +0,0 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import type { GtkColorDialogButtonProps } from "../jsx.js";
-import type { Container } from "../types.js";
-import { filterProps, hasChanged } from "./internal/props.js";
-import { WidgetNode } from "./widget.js";
-
-const OWN_PROPS = ["rgba", "onRgbaChanged", "title", "modal", "withAlpha"] as const;
-
-type ColorDialogButtonProps = Pick<GtkColorDialogButtonProps, (typeof OWN_PROPS)[number]>;
-
-export class ColorDialogButtonNode extends WidgetNode<Gtk.ColorDialogButton, ColorDialogButtonProps> {
-    private dialog: Gtk.ColorDialog;
-
-    public static override createContainer(
-        _props: ColorDialogButtonProps,
-        containerClass: typeof Gtk.Widget,
-    ): Container | null {
-        const dialog = new Gtk.ColorDialog();
-        const button = new (containerClass as typeof Gtk.ColorDialogButton)(dialog);
-        return button;
-    }
-
-    constructor(
-        typeName: string,
-        props: ColorDialogButtonProps,
-        container: Gtk.ColorDialogButton,
-        rootContainer: Container,
-    ) {
-        super(typeName, props, container, rootContainer);
-        const dialog = container.getDialog();
-        if (!dialog) {
-            throw new Error("ColorDialogButton must have a dialog");
-        }
-        this.dialog = dialog;
-    }
-
-    public override commitUpdate(oldProps: ColorDialogButtonProps | null, newProps: ColorDialogButtonProps): void {
-        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
-        this.applyOwnProps(oldProps, newProps);
-    }
-
-    private applyOwnProps(oldProps: ColorDialogButtonProps | null, newProps: ColorDialogButtonProps): void {
-        if (hasChanged(oldProps, newProps, "title")) {
-            this.dialog.setTitle(newProps.title ?? "");
-        }
-
-        if (hasChanged(oldProps, newProps, "modal")) {
-            this.dialog.setModal(newProps.modal ?? true);
-        }
-
-        if (hasChanged(oldProps, newProps, "withAlpha")) {
-            this.dialog.setWithAlpha(newProps.withAlpha ?? true);
-        }
-
-        if (hasChanged(oldProps, newProps, "rgba") && newProps.rgba) {
-            this.container.setRgba(newProps.rgba);
-        }
-
-        if (hasChanged(oldProps, newProps, "onRgbaChanged")) {
-            const callback = newProps.onRgbaChanged;
-            this.signalStore.set(
-                this,
-                this.container,
-                "notify::rgba",
-                callback ? () => callback(this.container.getRgba()) : undefined,
-            );
-        }
-    }
-}

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

@@ -1,189 +0,0 @@
-import { getNativeId } from "@gtkx/ffi";
-import * as Gio from "@gtkx/ffi/gio";
-import type * as GObject from "@gtkx/ffi/gobject";
-import * as Gtk from "@gtkx/ffi/gtk";
-import type { ColumnViewColumnProps, ListItem } from "../jsx.js";
-import type { Node } from "../node.js";
-import type { Container } from "../types.js";
-import type { BoundItem } from "./internal/bound-item.js";
-import { hasChanged } from "./internal/props.js";
-import { MenuNode } from "./menu.js";
-import { MenuModel } from "./models/menu.js";
-import { VirtualNode } from "./virtual.js";
-import { WidgetNode } from "./widget.js";
-
-const UNBOUND_POSITION = -1;
-
-export class ColumnViewColumnNode extends VirtualNode<ColumnViewColumnProps, WidgetNode, MenuNode> {
-    private column: Gtk.ColumnViewColumn | null = null;
-    private columnFactory: Gtk.SignalListItemFactory | null = null;
-    private containers = new Map<Gtk.ListItem, number>();
-    private containerKeys = new Map<Gtk.ListItem, string>();
-    private menu: MenuModel;
-    private actionGroup: Gio.SimpleActionGroup;
-
-    constructor(typeName: string, props: ColumnViewColumnProps, container: undefined, rootContainer: Container) {
-        super(typeName, props, container, rootContainer);
-        this.actionGroup = new Gio.SimpleActionGroup();
-        this.menu = new MenuModel("root", {}, rootContainer, this.actionGroup);
-        this.menu.setActionMap(this.actionGroup, props.id);
-    }
-
-    public override isValidChild(child: Node): boolean {
-        return child instanceof MenuNode;
-    }
-
-    public override isValidParent(parent: Node): boolean {
-        return parent instanceof WidgetNode && parent.container instanceof Gtk.ColumnView;
-    }
-
-    public override finalizeInitialChildren(props: ColumnViewColumnProps): boolean {
-        this.setupFactory();
-        this.setupColumn(props);
-        this.updateHeaderMenu();
-        return false;
-    }
-
-    public override commitUpdate(oldProps: ColumnViewColumnProps | null, newProps: ColumnViewColumnProps): void {
-        super.commitUpdate(oldProps, newProps);
-        if (oldProps === null) return;
-        this.applyColumnProps(oldProps, newProps);
-    }
-
-    public override appendChild(child: MenuNode): void {
-        this.menu.appendChild(child);
-        this.updateHeaderMenu();
-    }
-
-    public override insertBefore(child: MenuNode, before: MenuNode): void {
-        this.menu.insertBefore(child, before);
-        this.updateHeaderMenu();
-    }
-
-    public override removeChild(child: MenuNode): void {
-        this.menu.removeChild(child);
-        this.updateHeaderMenu();
-    }
-
-    public override detachDeletedInstance(): void {
-        super.detachDeletedInstance();
-    }
-
-    public getColumn(): Gtk.ColumnViewColumn {
-        if (!this.column) throw new Error("ColumnViewColumn not initialized");
-        return this.column;
-    }
-
-    public collectBoundItems(flatItems: ListItem[]): BoundItem[] {
-        const { renderCell } = this.props;
-        if (!renderCell) return [];
-
-        const items: BoundItem[] = [];
-
-        for (const [container, position] of this.containers) {
-            if (position === UNBOUND_POSITION) continue;
-
-            const key = this.containerKeys.get(container);
-            if (!key) continue;
-
-            const item = flatItems[position];
-            if (!item) continue;
-            const content = renderCell(item.value);
-            items.push([content, container, key]);
-        }
-
-        return items;
-    }
-
-    public installActionGroup(widget: Gtk.Widget): void {
-        widget.insertActionGroup(this.props.id, this.actionGroup);
-    }
-
-    public uninstallActionGroup(widget: Gtk.Widget): void {
-        widget.insertActionGroup(this.props.id, null);
-    }
-
-    private setupFactory(): void {
-        this.columnFactory = new Gtk.SignalListItemFactory();
-
-        this.columnFactory.connect("setup", (_self: GObject.Object, obj: GObject.Object) => {
-            const listItem = obj as unknown as Gtk.ListItem;
-            const key = String(getNativeId(listItem.handle));
-            const placeholder = new Gtk.Box();
-            const { width, height } = this.getParentEstimatedItemSize();
-            placeholder.setSizeRequest(width, height);
-            listItem.setChild(placeholder);
-            this.containers.set(listItem, UNBOUND_POSITION);
-            this.containerKeys.set(listItem, key);
-        });
-
-        this.columnFactory.connect("bind", (_self: GObject.Object, obj: GObject.Object) => {
-            const listItem = obj as unknown as Gtk.ListItem;
-            this.containers.set(listItem, listItem.getPosition());
-            this.scheduleParentUpdate();
-        });
-
-        this.columnFactory.connect("unbind", (_self: GObject.Object, obj: GObject.Object) => {
-            const listItem = obj as unknown as Gtk.ListItem;
-            this.containers.set(listItem, UNBOUND_POSITION);
-            this.scheduleParentUpdate();
-        });
-
-        this.columnFactory.connect("teardown", (_self: GObject.Object, obj: GObject.Object) => {
-            const listItem = obj as unknown as Gtk.ListItem;
-            this.containers.delete(listItem);
-            this.containerKeys.delete(listItem);
-            listItem.setChild(null);
-        });
-    }
-
-    private setupColumn(props: ColumnViewColumnProps): void {
-        this.column = new Gtk.ColumnViewColumn(props.title, this.columnFactory);
-        this.column.setId(props.id);
-
-        if (props.expand !== undefined) this.column.setExpand(props.expand);
-        if (props.resizable !== undefined) this.column.setResizable(props.resizable);
-        if (props.fixedWidth !== undefined) this.column.setFixedWidth(props.fixedWidth);
-        if (props.visible !== undefined) this.column.setVisible(props.visible);
-        if (props.sortable) this.column.setSorter(new Gtk.Sorter());
-    }
-
-    private applyColumnProps(oldProps: ColumnViewColumnProps, newProps: ColumnViewColumnProps): void {
-        if (!this.column) return;
-
-        if (hasChanged(oldProps, newProps, "title")) this.column.setTitle(newProps.title);
-        if (hasChanged(oldProps, newProps, "expand")) this.column.setExpand(newProps.expand ?? false);
-        if (hasChanged(oldProps, newProps, "resizable")) this.column.setResizable(newProps.resizable ?? false);
-        if (hasChanged(oldProps, newProps, "fixedWidth")) this.column.setFixedWidth(newProps.fixedWidth ?? -1);
-        if (hasChanged(oldProps, newProps, "visible")) this.column.setVisible(newProps.visible ?? true);
-        if (hasChanged(oldProps, newProps, "sortable")) {
-            this.column.setSorter(newProps.sortable ? new Gtk.Sorter() : null);
-        }
-        if (hasChanged(oldProps, newProps, "renderCell")) this.scheduleParentUpdate();
-    }
-
-    private updateHeaderMenu(): void {
-        if (!this.column) return;
-        const menu = this.menu.getMenu();
-        this.column.setHeaderMenu(menu.getNItems() > 0 ? menu : null);
-    }
-
-    private getParentEstimatedItemSize(): { width: number; height: number } {
-        if (this.parent && "getEstimatedItemSize" in this.parent) {
-            return (
-                this.parent as { getEstimatedItemSize(): { width: number; height: number } }
-            ).getEstimatedItemSize();
-        }
-        return { width: -1, height: -1 };
-    }
-
-    private scheduleParentUpdate(): void {
-        if (
-            this.parent &&
-            "scheduleBoundItemsUpdate" in this.parent &&
-            typeof this.parent.scheduleBoundItemsUpdate === "function"
-        ) {
-            (this.parent as { scheduleBoundItemsUpdate(): void }).scheduleBoundItemsUpdate();
-        }
-    }
-}

package/src/nodes/container-slot.ts

@@ -1,87 +0,0 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-import type { ContainerSlotProps } from "../jsx.js";
-import type { Node } from "../node.js";
-import { isRemovable } from "./internal/predicates.js";
-import { VirtualNode } from "./virtual.js";
-import { WidgetNode } from "./widget.js";
-
-export class ContainerSlotNode extends VirtualNode<ContainerSlotProps, WidgetNode, WidgetNode> {
-    public override isValidChild(child: Node): boolean {
-        return child instanceof WidgetNode;
-    }
-
-    public override isValidParent(parent: Node): boolean {
-        return parent instanceof WidgetNode;
-    }
-
-    public override setParent(parent: WidgetNode | null): void {
-        if (!parent && this.parent) {
-            this.detachAllChildren(this.parent.container);
-        }
-
-        super.setParent(parent);
-
-        if (parent) {
-            for (const child of this.children) {
-                this.attachToParent(parent.container, child.container);
-            }
-        }
-    }
-
-    public override appendChild(child: WidgetNode): void {
-        super.appendChild(child);
-
-        if (this.parent) {
-            this.attachToParent(this.parent.container, child.container);
-        }
-    }
-
-    public override insertBefore(child: WidgetNode, before: WidgetNode): void {
-        super.insertBefore(child, before);
-
-        if (this.parent) {
-            this.attachToParent(this.parent.container, child.container);
-        }
-    }
-
-    public override removeChild(child: WidgetNode): void {
-        if (this.parent && isRemovable(this.parent.container)) {
-            const widget = child.container;
-            const currentParent = widget.getParent();
-            if (currentParent && currentParent === this.parent.container) {
-                this.parent.container.remove(widget);
-            }
-        }
-
-        super.removeChild(child);
-    }
-
-    public override detachDeletedInstance(): void {
-        if (this.parent) {
-            this.detachAllChildren(this.parent.container);
-        }
-        super.detachDeletedInstance();
-    }
-
-    private attachToParent(parent: Gtk.Widget, child: Gtk.Widget): void {
-        const methodName = this.props.id;
-        const method = parent[methodName as keyof Gtk.Widget];
-
-        if (typeof method !== "function") {
-            throw new Error(`Method '${methodName}' not found on '${parent.constructor.name}'`);
-        }
-
-        (method as (child: Gtk.Widget) => void).call(parent, child);
-    }
-
-    private detachAllChildren(parent: Gtk.Widget): void {
-        if (!isRemovable(parent)) return;
-
-        for (const child of this.children) {
-            const currentParent = child.container.getParent();
-            if (currentParent && currentParent === parent) {
-                parent.remove(child.container);
-            }
-        }
-    }
-}

package/src/nodes/dialog.ts

@@ -1,25 +0,0 @@
-import type * as Adw from "@gtkx/ffi/adw";
-import type { Props } from "../types.js";
-import { WidgetNode } from "./widget.js";
-import { WindowNode } from "./window.js";
-
-export class DialogNode extends WidgetNode<Adw.Dialog> {
-    protected override shouldAttachToParent(): boolean {
-        return false;
-    }
-
-    public override finalizeInitialChildren(props: Props): boolean {
-        this.commitUpdate(null, props);
-        return true;
-    }
-
-    public override commitMount(): void {
-        const parent = this.parent instanceof WindowNode ? this.parent.container : undefined;
-        this.container.present(parent);
-    }
-
-    public override detachDeletedInstance(): void {
-        this.container.forceClose();
-        super.detachDeletedInstance();
-    }
-}

package/src/nodes/drawing-area.ts

@@ -1,62 +0,0 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-import type { GtkDrawingAreaProps } from "../jsx.js";
-import type { Node } from "../node.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 = ["onDraw"] as const;
-
-type DrawFunc = (cr: import("@gtkx/ffi/cairo").Context, width: number, height: number, self: Gtk.DrawingArea) => void;
-type DrawingAreaProps = Pick<GtkDrawingAreaProps, (typeof OWN_PROPS)[number]>;
-
-type PendingDrawFuncEntry = { container: Gtk.DrawingArea; fn: DrawFunc };
-
-const pendingDrawFuncs: PendingDrawFuncEntry[] = [];
-
-function wrapDrawFunc(
-    fn: DrawFunc,
-): (self: Gtk.DrawingArea, cr: import("@gtkx/ffi/cairo").Context, width: number, height: number) => void {
-    return (self, cr, width, height) => fn(cr, width, height, self);
-}
-
-function ensurePendingBatch(): PendingDrawFuncEntry[] {
-    if (pendingDrawFuncs.length === 0) {
-        queueMicrotask(flushPendingDrawFuncs);
-    }
-
-    return pendingDrawFuncs;
-}
-
-function flushPendingDrawFuncs(): void {
-    const batch = pendingDrawFuncs.splice(0);
-
-    for (const { container, fn } of batch) {
-        container.setDrawFunc(wrapDrawFunc(fn));
-    }
-}
-
-type DrawingAreaChild = EventControllerNode | SlotNode | ContainerSlotNode;
-
-export class DrawingAreaNode extends WidgetNode<Gtk.DrawingArea, DrawingAreaProps, DrawingAreaChild> {
-    public override isValidChild(child: Node): boolean {
-        return child instanceof EventControllerNode || child instanceof SlotNode || child instanceof ContainerSlotNode;
-    }
-
-    public override commitUpdate(oldProps: DrawingAreaProps | null, newProps: DrawingAreaProps): void {
-        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
-        this.applyOwnProps(oldProps, newProps);
-    }
-
-    private applyOwnProps(oldProps: DrawingAreaProps | null, newProps: DrawingAreaProps): void {
-        if (hasChanged(oldProps, newProps, "onDraw")) {
-            if (this.container.getAllocatedWidth() > 0) {
-                this.container.setDrawFunc(newProps.onDraw ? wrapDrawFunc(newProps.onDraw) : null);
-            } else if (newProps.onDraw) {
-                ensurePendingBatch().push({ container: this.container, fn: newProps.onDraw });
-            }
-        }
-    }
-}

package/src/nodes/event-controller.ts

@@ -1,100 +0,0 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import { isConstructOnlyProp, resolvePropMeta, resolveSignal } from "../metadata.js";
-import { Node } from "../node.js";
-import type { Props } from "../types.js";
-import { createContainerWithProperties } from "./internal/construct.js";
-import type { SignalHandler } from "./internal/signal-store.js";
-import { WidgetNode } from "./widget.js";
-
-const G_TYPE_INVALID = 0;
-
-export class EventControllerNode<
-    T extends Gtk.EventController = Gtk.EventController,
-    // biome-ignore lint/suspicious/noExplicitAny: Self-referential type bounds require any
-    TChild extends Node = any,
-> extends Node<T, Props, WidgetNode, TChild> {
-    public static override createContainer(
-        props: Props,
-        containerClass: typeof Gtk.EventController,
-    ): Gtk.EventController {
-        if (containerClass.glibTypeName === "GtkDropTarget") {
-            const actions = (props.actions as number | undefined) ?? 0;
-            return new Gtk.DropTarget(G_TYPE_INVALID, actions);
-        }
-
-        return createContainerWithProperties(containerClass, props) as Gtk.EventController;
-    }
-
-    public override isValidChild(child: Node): boolean {
-        return this.container instanceof Gtk.ShortcutController && child.typeName === "Shortcut";
-    }
-
-    public override isValidParent(parent: Node): boolean {
-        return parent instanceof WidgetNode;
-    }
-
-    public override setParent(parent: WidgetNode | null): void {
-        if (!parent && this.parent) {
-            this.parent.container.removeController(this.container);
-        }
-
-        super.setParent(parent);
-
-        if (parent) {
-            parent.container.addController(this.container);
-        }
-    }
-
-    public override commitUpdate(oldProps: Props | null, newProps: Props): void {
-        super.commitUpdate(oldProps, newProps);
-        this.applyOwnProps(oldProps, newProps);
-    }
-
-    public override detachDeletedInstance(): void {
-        if (this.parent && this.container.getWidget() === this.parent.container) {
-            this.parent.container.removeController(this.container);
-        }
-        super.detachDeletedInstance();
-    }
-
-    private applyOwnProps(oldProps: Props | null, newProps: Props): void {
-        const propNames = new Set([...Object.keys(oldProps ?? {}), ...Object.keys(newProps ?? {})]);
-
-        for (const name of propNames) {
-            if (name === "children") continue;
-            if (isConstructOnlyProp(this.container, name)) continue;
-
-            const oldValue = oldProps?.[name];
-            const newValue = newProps[name];
-
-            if (oldValue === newValue) continue;
-
-            const signalName = resolveSignal(this.container, name);
-
-            if (signalName) {
-                const handler = typeof newValue === "function" ? (newValue as SignalHandler) : undefined;
-                this.signalStore.set(this, this.container, signalName, handler, { blockable: false });
-            } else if (newValue !== undefined) {
-                this.setProperty(name, newValue);
-            }
-        }
-    }
-
-    private setProperty(name: string, value: unknown): void {
-        if (name === "types" && this.container instanceof Gtk.DropTarget) {
-            const types = value as number[];
-            this.container.setGtypes(types.length, types);
-            return;
-        }
-
-        const propMeta = resolvePropMeta(this.container, name);
-
-        if (propMeta) {
-            const [, setterName] = propMeta;
-            const setterFn = (this.container as unknown as Record<string, (v: unknown) => void>)[setterName];
-            if (typeof setterFn === "function") {
-                setterFn.call(this.container, value);
-            }
-        }
-    }
-}