@gtkx/react 0.15.0 → 0.17.1

package/dist/nodes/internal/simple-list-store.js

@@ -1,4 +1,3 @@
-import { batch } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
 export class SimpleListStore {
     ids = [];
@@ -9,14 +8,12 @@ export class SimpleListStore {
     }
     appendItem(id, label) {
         const existingIndex = this.ids.indexOf(id);
-        batch(() => {
-            if (existingIndex >= 0) {
-                this.model.remove(existingIndex);
-                this.ids.splice(existingIndex, 1);
-            }
-            this.ids.push(id);
-            this.model.append(label);
-        });
+        if (existingIndex >= 0) {
+            this.model.remove(existingIndex);
+            this.ids.splice(existingIndex, 1);
+        }
+        this.ids.push(id);
+        this.model.append(label);
     }
     removeItem(id) {
         const index = this.ids.indexOf(id);

package/dist/nodes/internal/text-buffer-controller.d.ts

@@ -0,0 +1,43 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../../node.js";
+import type { TextContentChild, TextContentParent } from "../text-content.js";
+import { TextSegmentNode } from "../text-segment.js";
+type BufferCallbackProps = {
+    onBufferChanged?: ((buffer: Gtk.TextBuffer) => void) | null;
+    onTextInserted?: ((buffer: Gtk.TextBuffer, offset: number, text: string) => void) | null;
+    onTextDeleted?: ((buffer: Gtk.TextBuffer, startOffset: number, endOffset: number) => void) | null;
+    onCanUndoChanged?: ((canUndo: boolean) => void) | null;
+    onCanRedoChanged?: ((canRedo: boolean) => void) | null;
+};
+type BufferProps = {
+    enableUndo?: boolean;
+} & BufferCallbackProps;
+export declare class TextBufferController<TBuffer extends Gtk.TextBuffer = Gtk.TextBuffer> {
+    private readonly owner;
+    private readonly container;
+    private readonly createBuffer;
+    private buffer;
+    private textChildren;
+    constructor(owner: Node & TextContentParent, container: Gtk.TextView, createBuffer: () => TBuffer);
+    getBuffer(): TBuffer | null;
+    hasTextChildren(): boolean;
+    ensureBuffer(): TBuffer;
+    applyOwnProps(oldProps: BufferProps | null, newProps: BufferProps): void;
+    private updateSignalHandlers;
+    isTextContentChild(child: Node): child is TextContentChild;
+    appendChild(child: TextContentChild): void;
+    insertBefore(child: TextContentChild, before: TextContentChild): void;
+    removeChild(child: TextContentChild): void;
+    private setChildParent;
+    private getTotalLength;
+    private insertTextAtOffset;
+    private deleteTextAtRange;
+    private updateChildOffsets;
+    private reapplyAllTagsRecursive;
+    private reapplyTagsFromOffset;
+    private findDirectChildContaining;
+    onChildInserted(child: TextContentChild): void;
+    onChildRemoved(child: TextContentChild): void;
+    onChildTextChanged(child: TextSegmentNode, oldLength: number, _newLength: number): void;
+}
+export {};

package/dist/nodes/internal/text-buffer-controller.js

@@ -0,0 +1,287 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { TextAnchorNode } from "../text-anchor.js";
+import { TextPaintableNode } from "../text-paintable.js";
+import { TextSegmentNode } from "../text-segment.js";
+import { TextTagNode } from "../text-tag.js";
+import { hasChanged } from "./utils.js";
+export class TextBufferController {
+    owner;
+    container;
+    createBuffer;
+    buffer = null;
+    textChildren = [];
+    constructor(owner, container, createBuffer) {
+        this.owner = owner;
+        this.container = container;
+        this.createBuffer = createBuffer;
+    }
+    getBuffer() {
+        return this.buffer;
+    }
+    hasTextChildren() {
+        return this.textChildren.length > 0;
+    }
+    ensureBuffer() {
+        if (!this.buffer) {
+            this.buffer = this.createBuffer();
+            this.container.setBuffer(this.buffer);
+        }
+        return this.buffer;
+    }
+    applyOwnProps(oldProps, newProps) {
+        const hasBufferProps = newProps.enableUndo !== undefined ||
+            newProps.onBufferChanged !== undefined ||
+            newProps.onTextInserted !== undefined ||
+            newProps.onTextDeleted !== undefined ||
+            newProps.onCanUndoChanged !== undefined ||
+            newProps.onCanRedoChanged !== undefined;
+        if (!hasBufferProps && this.textChildren.length === 0) {
+            return;
+        }
+        const buffer = this.ensureBuffer();
+        if (hasChanged(oldProps, newProps, "enableUndo") && newProps.enableUndo !== undefined) {
+            buffer.setEnableUndo(newProps.enableUndo);
+        }
+        const signalHandlersChanged = hasChanged(oldProps, newProps, "onBufferChanged") ||
+            hasChanged(oldProps, newProps, "onTextInserted") ||
+            hasChanged(oldProps, newProps, "onTextDeleted") ||
+            hasChanged(oldProps, newProps, "onCanUndoChanged") ||
+            hasChanged(oldProps, newProps, "onCanRedoChanged");
+        if (signalHandlersChanged) {
+            this.updateSignalHandlers(newProps);
+        }
+    }
+    updateSignalHandlers(callbacks) {
+        if (!this.buffer)
+            return;
+        const buffer = this.buffer;
+        const { onBufferChanged, onTextInserted, onTextDeleted, onCanUndoChanged, onCanRedoChanged } = callbacks;
+        this.owner.signalStore.set(this.owner, buffer, "changed", onBufferChanged ? () => onBufferChanged(buffer) : null);
+        this.owner.signalStore.set(this.owner, buffer, "insert-text", onTextInserted
+            ? (location, text) => onTextInserted(buffer, location.getOffset(), text)
+            : null);
+        this.owner.signalStore.set(this.owner, buffer, "delete-range", onTextDeleted
+            ? (start, end) => onTextDeleted(buffer, start.getOffset(), end.getOffset())
+            : null);
+        this.owner.signalStore.set(this.owner, buffer, "notify::can-undo", onCanUndoChanged ? () => onCanUndoChanged(buffer.getCanUndo()) : null);
+        this.owner.signalStore.set(this.owner, buffer, "notify::can-redo", onCanRedoChanged ? () => onCanRedoChanged(buffer.getCanRedo()) : null);
+    }
+    isTextContentChild(child) {
+        return (child instanceof TextSegmentNode ||
+            child instanceof TextTagNode ||
+            child instanceof TextAnchorNode ||
+            child instanceof TextPaintableNode);
+    }
+    appendChild(child) {
+        const buffer = this.ensureBuffer();
+        const wasMoved = this.textChildren.indexOf(child) !== -1;
+        if (wasMoved) {
+            const existingIndex = this.textChildren.indexOf(child);
+            const oldOffset = child.bufferOffset;
+            const oldLength = child.getLength();
+            this.textChildren.splice(existingIndex, 1);
+            if (oldLength > 0) {
+                this.deleteTextAtRange(oldOffset, oldOffset + oldLength);
+            }
+            this.updateChildOffsets(existingIndex);
+        }
+        const offset = this.getTotalLength();
+        this.textChildren.push(child);
+        child.bufferOffset = offset;
+        this.setChildParent(child);
+        if (child instanceof TextSegmentNode) {
+            this.insertTextAtOffset(child.getText(), offset);
+        }
+        else if (child instanceof TextTagNode) {
+            const text = child.getText();
+            this.insertTextAtOffset(text, offset);
+            if (!child.hasBuffer()) {
+                child.setBuffer(buffer);
+            }
+        }
+        else if (child instanceof TextAnchorNode) {
+            child.setTextViewAndBuffer(this.container, buffer);
+        }
+        else if (child instanceof TextPaintableNode) {
+            child.setTextViewAndBuffer(this.container, buffer);
+        }
+        if (wasMoved) {
+            this.updateChildOffsets(0);
+            this.reapplyTagsFromOffset(0);
+        }
+    }
+    insertBefore(child, before) {
+        const buffer = this.ensureBuffer();
+        const existingIndex = this.textChildren.indexOf(child);
+        if (existingIndex !== -1) {
+            const oldOffset = child.bufferOffset;
+            const oldLength = child.getLength();
+            this.textChildren.splice(existingIndex, 1);
+            if (oldLength > 0) {
+                this.deleteTextAtRange(oldOffset, oldOffset + oldLength);
+            }
+            this.updateChildOffsets(existingIndex);
+        }
+        const beforeIndex = this.textChildren.indexOf(before);
+        const insertIndex = beforeIndex !== -1 ? beforeIndex : this.textChildren.length;
+        let offset = 0;
+        for (let i = 0; i < insertIndex; i++) {
+            const c = this.textChildren[i];
+            if (c)
+                offset += c.getLength();
+        }
+        this.textChildren.splice(insertIndex, 0, child);
+        child.bufferOffset = offset;
+        this.setChildParent(child);
+        if (child instanceof TextSegmentNode) {
+            this.insertTextAtOffset(child.getText(), offset);
+        }
+        else if (child instanceof TextTagNode) {
+            const text = child.getText();
+            this.insertTextAtOffset(text, offset);
+            if (!child.hasBuffer()) {
+                child.setBuffer(buffer);
+            }
+        }
+        else if (child instanceof TextAnchorNode) {
+            child.setTextViewAndBuffer(this.container, buffer);
+        }
+        else if (child instanceof TextPaintableNode) {
+            child.setTextViewAndBuffer(this.container, buffer);
+        }
+        this.updateChildOffsets(0);
+        this.reapplyTagsFromOffset(0);
+    }
+    removeChild(child) {
+        const index = this.textChildren.indexOf(child);
+        if (index === -1)
+            return;
+        const offset = child.bufferOffset;
+        const length = child.getLength();
+        this.textChildren.splice(index, 1);
+        if (this.buffer && length > 0) {
+            this.deleteTextAtRange(offset, offset + length);
+        }
+        this.updateChildOffsets(index);
+        this.reapplyTagsFromOffset(offset);
+    }
+    setChildParent(child) {
+        if (child instanceof TextSegmentNode || child instanceof TextTagNode) {
+            child.setParent(this.owner);
+        }
+    }
+    getTotalLength() {
+        let length = 0;
+        for (const child of this.textChildren) {
+            length += child.getLength();
+        }
+        return length;
+    }
+    insertTextAtOffset(text, offset) {
+        const buffer = this.buffer;
+        if (!buffer || text.length === 0)
+            return;
+        const iter = new Gtk.TextIter();
+        buffer.getIterAtOffset(iter, offset);
+        buffer.insert(iter, text, text.length);
+    }
+    deleteTextAtRange(start, end) {
+        const buffer = this.buffer;
+        if (!buffer || start >= end)
+            return;
+        const startIter = new Gtk.TextIter();
+        const endIter = new Gtk.TextIter();
+        buffer.getIterAtOffset(startIter, start);
+        buffer.getIterAtOffset(endIter, end);
+        buffer.delete(startIter, endIter);
+    }
+    updateChildOffsets(startIndex) {
+        let offset = 0;
+        for (let i = 0; i < startIndex; i++) {
+            const child = this.textChildren[i];
+            if (child)
+                offset += child.getLength();
+        }
+        for (let i = startIndex; i < this.textChildren.length; i++) {
+            const child = this.textChildren[i];
+            if (child) {
+                child.bufferOffset = offset;
+                offset += child.getLength();
+            }
+        }
+    }
+    reapplyAllTagsRecursive(children) {
+        for (const child of children) {
+            if (child instanceof TextTagNode) {
+                child.reapplyTag();
+                this.reapplyAllTagsRecursive(child.getChildren());
+            }
+        }
+    }
+    reapplyTagsFromOffset(fromOffset) {
+        for (const child of this.textChildren) {
+            if (child instanceof TextTagNode) {
+                if (child.bufferOffset >= fromOffset) {
+                    child.reapplyTag();
+                    this.reapplyAllTagsRecursive(child.getChildren());
+                }
+                else if (child.bufferOffset + child.getLength() > fromOffset) {
+                    child.reapplyTag();
+                    this.reapplyAllTagsRecursive(child.getChildren());
+                }
+            }
+        }
+    }
+    findDirectChildContaining(offset) {
+        for (let i = 0; i < this.textChildren.length; i++) {
+            const child = this.textChildren[i];
+            if (child) {
+                const start = child.bufferOffset;
+                const end = start + child.getLength();
+                if (offset >= start && offset <= end) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+    onChildInserted(child) {
+        if (!this.buffer)
+            return;
+        const text = child.getText();
+        if (text.length > 0) {
+            this.insertTextAtOffset(text, child.bufferOffset);
+        }
+        const containingIndex = this.findDirectChildContaining(child.bufferOffset);
+        if (containingIndex !== -1) {
+            this.updateChildOffsets(containingIndex + 1);
+        }
+        this.reapplyTagsFromOffset(child.bufferOffset);
+    }
+    onChildRemoved(child) {
+        if (!this.buffer)
+            return;
+        const offset = child.bufferOffset;
+        const length = child.getLength();
+        if (length > 0) {
+            this.deleteTextAtRange(offset, offset + length);
+        }
+        const containingIndex = this.findDirectChildContaining(offset);
+        if (containingIndex !== -1) {
+            this.updateChildOffsets(containingIndex + 1);
+        }
+        this.reapplyTagsFromOffset(offset);
+    }
+    onChildTextChanged(child, oldLength, _newLength) {
+        if (!this.buffer)
+            return;
+        const offset = child.bufferOffset;
+        this.deleteTextAtRange(offset, offset + oldLength);
+        this.insertTextAtOffset(child.getText(), offset);
+        const containingIndex = this.findDirectChildContaining(offset);
+        if (containingIndex !== -1) {
+            this.updateChildOffsets(containingIndex + 1);
+        }
+        this.reapplyTagsFromOffset(offset);
+    }
+}

package/dist/nodes/internal/text-tag-styles.d.ts

@@ -0,0 +1,43 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type * as Pango from "@gtkx/ffi/pango";
+export type TagStyleProps = {
+    background?: string;
+    backgroundFullHeight?: boolean;
+    foreground?: string;
+    family?: string;
+    font?: string;
+    sizePoints?: number;
+    size?: number;
+    scale?: number;
+    weight?: Pango.Weight | number;
+    style?: Pango.Style;
+    stretch?: Pango.Stretch;
+    variant?: Pango.Variant;
+    strikethrough?: boolean;
+    underline?: Pango.Underline;
+    overline?: Pango.Overline;
+    rise?: number;
+    letterSpacing?: number;
+    lineHeight?: number;
+    leftMargin?: number;
+    rightMargin?: number;
+    indent?: number;
+    pixelsAboveLines?: number;
+    pixelsBelowLines?: number;
+    pixelsInsideWrap?: number;
+    justification?: Gtk.Justification;
+    direction?: Gtk.TextDirection;
+    wrapMode?: Gtk.WrapMode;
+    editable?: boolean;
+    invisible?: boolean;
+    allowBreaks?: boolean;
+    insertHyphens?: boolean;
+    fallback?: boolean;
+    accumulativeMargin?: boolean;
+    paragraphBackground?: string;
+    showSpaces?: Pango.ShowFlags;
+    textTransform?: Pango.TextTransform;
+    fontFeatures?: string;
+    language?: string;
+};
+export declare function applyStyleChanges(tag: Gtk.TextTag, oldProps: TagStyleProps | null, newProps: TagStyleProps): void;

package/dist/nodes/internal/text-tag-styles.js

@@ -0,0 +1,52 @@
+import { hasChanged } from "./utils.js";
+const STYLE_PROPS = {
+    background: "setBackground",
+    backgroundFullHeight: "setBackgroundFullHeight",
+    foreground: "setForeground",
+    family: "setFamily",
+    font: "setFont",
+    sizePoints: "setSizePoints",
+    size: "setSize",
+    scale: "setScale",
+    weight: "setWeight",
+    style: "setStyle",
+    stretch: "setStretch",
+    variant: "setVariant",
+    strikethrough: "setStrikethrough",
+    underline: "setUnderline",
+    overline: "setOverline",
+    rise: "setRise",
+    letterSpacing: "setLetterSpacing",
+    lineHeight: "setLineHeight",
+    leftMargin: "setLeftMargin",
+    rightMargin: "setRightMargin",
+    indent: "setIndent",
+    pixelsAboveLines: "setPixelsAboveLines",
+    pixelsBelowLines: "setPixelsBelowLines",
+    pixelsInsideWrap: "setPixelsInsideWrap",
+    justification: "setJustification",
+    direction: "setDirection",
+    wrapMode: "setWrapMode",
+    editable: "setEditable",
+    invisible: "setInvisible",
+    allowBreaks: "setAllowBreaks",
+    insertHyphens: "setInsertHyphens",
+    fallback: "setFallback",
+    accumulativeMargin: "setAccumulativeMargin",
+    paragraphBackground: "setParagraphBackground",
+    showSpaces: "setShowSpaces",
+    textTransform: "setTextTransform",
+    fontFeatures: "setFontFeatures",
+    language: "setLanguage",
+};
+export function applyStyleChanges(tag, oldProps, newProps) {
+    for (const prop of Object.keys(STYLE_PROPS)) {
+        if (hasChanged(oldProps, newProps, prop)) {
+            const value = newProps[prop];
+            if (value !== undefined) {
+                const setter = tag[STYLE_PROPS[prop]];
+                setter.call(tag, value);
+            }
+        }
+    }
+}

package/dist/nodes/internal/tree-list-item-renderer.d.ts

@@ -1,25 +1,26 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { ReactNode } from "react";
+import type Reconciler from "react-reconciler";
+import { BaseItemRenderer } from "./base-item-renderer.js";
 import type { TreeStore } from "./tree-store.js";
 export type TreeRenderItemFn<T> = (item: T | null, row: Gtk.TreeListRow | null) => ReactNode;
-export declare class TreeListItemRenderer {
-    private factory;
-    private store?;
-    private fiberRoots;
+export declare class TreeListItemRenderer extends BaseItemRenderer<TreeStore> {
     private expanders;
     private setupComplete;
     private pendingBinds;
-    private tornDown;
-    private renderFn?;
-    private estimatedItemHeight?;
-    constructor();
-    getFactory(): Gtk.SignalListItemFactory;
-    setRenderFn(renderFn?: TreeRenderItemFn<unknown>): void;
-    setStore(store?: TreeStore | null): void;
-    setEstimatedItemHeight(height?: number): void;
-    private getStore;
+    private renderFn;
+    private boundItems;
+    setRenderFn(renderFn: TreeRenderItemFn<unknown> | null): void;
+    rebindItem(id: string): void;
+    protected getStoreTypeName(): string;
     dispose(): void;
-    private initialize;
+    protected renderItem(_ptr: number): ReactNode;
+    protected getItemFromListItem(listItem: Gtk.ListItem): unknown;
+    protected onSetup(listItem: Gtk.ListItem, ptr: number): Gtk.Widget;
+    protected onSetupComplete(ptr: number): void;
+    protected onBind(listItem: Gtk.ListItem, ptr: number, fiberRoot: Reconciler.FiberRoot): void;
+    protected onUnbind(listItem: Gtk.ListItem): void;
+    protected onTeardown(_listItem: Gtk.ListItem, ptr: number): void;
     private processPendingBind;
     private renderBind;
 }