@gtkx/react 0.13.3 → 0.15.0

package/dist/nodes/notebook-page-tab.d.ts

@@ -8,6 +8,7 @@ export declare class NotebookPageTabNode extends SlotNode<Props> {
     private page?;
     static matches(type: string): boolean;
     setPage(notebook?: Gtk.Notebook, page?: Gtk.Widget): void;
+    updateProps(oldProps: Props | null, newProps: Props): void;
     private getNotebook;
     private getPage;
     protected onChildChange(_oldChild: Gtk.Widget | null): void;

package/dist/nodes/notebook-page-tab.js

@@ -1,3 +1,4 @@
+import { batch } from "@gtkx/ffi";
 import { registerNodeClass } from "../registry.js";
 import { SlotNode } from "./slot.js";
 export class NotebookPageTabNode extends SlotNode {
@@ -12,6 +13,9 @@ export class NotebookPageTabNode extends SlotNode {
         this.page = page;
         this.setParent(notebook);
     }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+    }
     getNotebook() {
         if (!this.notebook) {
             throw new Error("Expected Notebook reference to be set on NotebookPageTabNode");
@@ -25,15 +29,17 @@ export class NotebookPageTabNode extends SlotNode {
         return this.page;
     }
     onChildChange(_oldChild) {
-        if (!this.notebook || !this.page) {
-            return;
-        }
-        const notebook = this.getNotebook();
-        const page = this.getPage();
-        if (notebook.pageNum(page) === -1) {
-            return;
-        }
-        notebook.setTabLabel(page, this.child);
+        batch(() => {
+            if (!this.notebook || !this.page) {
+                return;
+            }
+            const notebook = this.getNotebook();
+            const page = this.getPage();
+            if (notebook.pageNum(page) === -1) {
+                return;
+            }
+            notebook.setTabLabel(page, this.child);
+        });
     }
 }
 registerNodeClass(NotebookPageTabNode);

package/dist/nodes/notebook-page.js

@@ -1,3 +1,4 @@
+import { batch } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
 import { scheduleAfterCommit } from "../scheduler.js";
@@ -93,12 +94,14 @@ export class NotebookPageNode extends SlotNode {
         notebook.removePage(pageNum);
     }
     onChildChange(oldChild) {
-        if (oldChild) {
-            this.detachPage(oldChild);
-        }
-        if (this.child) {
-            this.attachPage();
-        }
+        batch(() => {
+            if (oldChild) {
+                this.detachPage(oldChild);
+            }
+            if (this.child) {
+                this.attachPage();
+            }
+        });
     }
 }
 registerNodeClass(NotebookPageNode);

package/dist/nodes/scale.js

@@ -3,7 +3,6 @@ import { registerNodeClass } from "../registry.js";
 import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
 import { isContainerType } from "./internal/utils.js";
 import { ScaleMarkNode } from "./scale-mark.js";
-import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
 class ScaleNode extends WidgetNode {
     static priority = 1;
@@ -18,11 +17,7 @@ class ScaleNode extends WidgetNode {
             scheduleAfterCommit(() => child.addMark());
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.appendChild(child);
-            return;
-        }
-        throw new Error(`Cannot append '${child.typeName}' to 'Scale': expected x.ScaleMark or Widget`);
+        super.appendChild(child);
     }
     insertBefore(child, before) {
         if (child instanceof ScaleMarkNode) {
@@ -37,11 +32,7 @@ class ScaleNode extends WidgetNode {
             this.scheduleRebuildAllMarks();
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.insertBefore(child, before);
-            return;
-        }
-        throw new Error(`Cannot insert '${child.typeName}' into 'Scale': expected x.ScaleMark or Widget`);
+        super.insertBefore(child, before);
     }
     removeChild(child) {
         if (child instanceof ScaleMarkNode) {
@@ -52,11 +43,7 @@ class ScaleNode extends WidgetNode {
             this.scheduleRebuildAllMarks(CommitPriority.HIGH);
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.removeChild(child);
-            return;
-        }
-        throw new Error(`Cannot remove '${child.typeName}' from 'Scale': expected x.ScaleMark or Widget`);
+        super.removeChild(child);
     }
     scheduleRebuildAllMarks(priority = CommitPriority.NORMAL) {
         scheduleAfterCommit(() => {

package/dist/nodes/scrolled-window.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/nodes/scrolled-window.js

@@ -0,0 +1,22 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { filterProps, isContainerType } from "./internal/utils.js";
+import { WidgetNode } from "./widget.js";
+const PROPS = ["hscrollbarPolicy", "vscrollbarPolicy"];
+class ScrolledWindowNode extends WidgetNode {
+    static priority = 2;
+    static matches(_type, containerOrClass) {
+        return isContainerType(Gtk.ScrolledWindow, containerOrClass);
+    }
+    updateProps(oldProps, newProps) {
+        if (!oldProps ||
+            oldProps.hscrollbarPolicy !== newProps.hscrollbarPolicy ||
+            oldProps.vscrollbarPolicy !== newProps.vscrollbarPolicy) {
+            const hPolicy = newProps.hscrollbarPolicy ?? Gtk.PolicyType.AUTOMATIC;
+            const vPolicy = newProps.vscrollbarPolicy ?? Gtk.PolicyType.AUTOMATIC;
+            this.container.setPolicy(hPolicy, vPolicy);
+        }
+        super.updateProps(filterProps(oldProps ?? {}, PROPS), filterProps(newProps, PROPS));
+    }
+}
+registerNodeClass(ScrolledWindowNode);

package/dist/nodes/shortcut-controller.d.ts

@@ -0,0 +1,37 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../node.js";
+import type { Props } from "../types.js";
+import { VirtualNode } from "./virtual.js";
+/**
+ * Props for the ShortcutController virtual element.
+ *
+ * Attaches keyboard shortcuts to a widget. Must contain `x.Shortcut` children.
+ *
+ * @example
+ * ```tsx
+ * <GtkBox>
+ *     <x.ShortcutController scope={Gtk.ShortcutScope.GLOBAL}>
+ *         <x.Shortcut trigger="<Control>f" onActivate={toggleSearch} />
+ *         <x.Shortcut trigger="<Control>q" onActivate={quit} />
+ *     </x.ShortcutController>
+ * </GtkBox>
+ * ```
+ */
+export interface ShortcutControllerProps extends Props {
+    /** The scope for shortcuts (LOCAL, MANAGED, or GLOBAL) */
+    scope?: Gtk.ShortcutScope;
+}
+export declare class ShortcutControllerNode extends VirtualNode<ShortcutControllerProps> {
+    static priority: number;
+    static matches(type: string): boolean;
+    private controller?;
+    private parentWidget?;
+    private shortcuts;
+    setParent(widget?: Gtk.Widget): void;
+    appendChild(child: Node): void;
+    removeChild(child: Node): void;
+    updateProps(oldProps: ShortcutControllerProps | null, newProps: ShortcutControllerProps): void;
+    unmount(): void;
+    private applyScope;
+    private addShortcutToController;
+}

package/dist/nodes/shortcut-controller.js

@@ -0,0 +1,74 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { ShortcutNode } from "./shortcut.js";
+import { VirtualNode } from "./virtual.js";
+export class ShortcutControllerNode extends VirtualNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "ShortcutController";
+    }
+    controller;
+    parentWidget;
+    shortcuts = [];
+    setParent(widget) {
+        if (this.parentWidget && this.controller) {
+            this.parentWidget.removeController(this.controller);
+        }
+        this.parentWidget = widget;
+        if (widget) {
+            this.controller = new Gtk.ShortcutController();
+            this.applyScope();
+            widget.addController(this.controller);
+            for (const shortcut of this.shortcuts) {
+                this.addShortcutToController(shortcut);
+            }
+        }
+        else {
+            this.controller = undefined;
+        }
+    }
+    appendChild(child) {
+        if (!(child instanceof ShortcutNode)) {
+            throw new Error(`ShortcutController only accepts Shortcut children, got '${child.typeName}'`);
+        }
+        this.shortcuts.push(child);
+        if (this.controller) {
+            this.addShortcutToController(child);
+        }
+    }
+    removeChild(child) {
+        if (!(child instanceof ShortcutNode))
+            return;
+        const index = this.shortcuts.indexOf(child);
+        if (index !== -1) {
+            this.shortcuts.splice(index, 1);
+            if (this.controller && child.shortcut) {
+                this.controller.removeShortcut(child.shortcut);
+            }
+        }
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        if (!oldProps || oldProps.scope !== newProps.scope) {
+            this.applyScope();
+        }
+    }
+    unmount() {
+        this.setParent(undefined);
+        super.unmount();
+    }
+    applyScope() {
+        if (!this.controller)
+            return;
+        this.controller.setScope(this.props.scope ?? Gtk.ShortcutScope.LOCAL);
+    }
+    addShortcutToController(node) {
+        if (!this.controller)
+            return;
+        node.createShortcut();
+        if (node.shortcut) {
+            this.controller.addShortcut(node.shortcut);
+        }
+    }
+}
+registerNodeClass(ShortcutControllerNode);

package/dist/nodes/shortcut.d.ts

@@ -0,0 +1,38 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "../types.js";
+import { VirtualNode } from "./virtual.js";
+/**
+ * Props for the Shortcut virtual element.
+ *
+ * Defines a keyboard shortcut. Must be a child of `x.ShortcutController`.
+ *
+ * @example
+ * ```tsx
+ * <x.ShortcutController>
+ *     <x.Shortcut trigger="<Control>s" onActivate={save} />
+ *     <x.Shortcut trigger={["F5", "<Control>r"]} onActivate={refresh} />
+ *     <x.Shortcut trigger="Escape" onActivate={cancel} disabled={!canCancel} />
+ * </x.ShortcutController>
+ * ```
+ */
+export interface ShortcutProps extends Props {
+    /** The trigger string(s) using GTK accelerator format (e.g., "\<Control\>s", "F1") */
+    trigger: string | string[];
+    /**
+     * Called when the shortcut is activated.
+     * Return false to indicate the shortcut was not handled; otherwise it is considered handled.
+     */
+    onActivate: () => boolean | void;
+    /** Whether the shortcut is disabled */
+    disabled?: boolean;
+}
+export declare class ShortcutNode extends VirtualNode<ShortcutProps> {
+    static priority: number;
+    static matches(type: string): boolean;
+    shortcut?: Gtk.Shortcut;
+    private action?;
+    createShortcut(): void;
+    updateProps(oldProps: ShortcutProps | null, newProps: ShortcutProps): void;
+    unmount(): void;
+    private createTrigger;
+}

package/dist/nodes/shortcut.js

@@ -0,0 +1,46 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { VirtualNode } from "./virtual.js";
+export class ShortcutNode extends VirtualNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "Shortcut";
+    }
+    shortcut;
+    action;
+    createShortcut() {
+        const trigger = this.createTrigger();
+        this.action = new Gtk.CallbackAction(() => {
+            const result = this.props.onActivate();
+            return result !== false;
+        });
+        this.shortcut = new Gtk.Shortcut(trigger, this.action);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        if (this.shortcut && (oldProps?.trigger !== newProps.trigger || oldProps?.disabled !== newProps.disabled)) {
+            this.shortcut.setTrigger(this.createTrigger());
+        }
+    }
+    unmount() {
+        this.shortcut = undefined;
+        this.action = undefined;
+        super.unmount();
+    }
+    createTrigger() {
+        if (this.props.disabled) {
+            return Gtk.NeverTrigger.get();
+        }
+        const { trigger } = this.props;
+        const triggers = Array.isArray(trigger) ? trigger : [trigger];
+        if (triggers.length === 0) {
+            return Gtk.NeverTrigger.get();
+        }
+        let result = new Gtk.ShortcutTrigger(triggers[0]);
+        for (let i = 1; i < triggers.length; i++) {
+            result = new Gtk.AlternativeTrigger(result, new Gtk.ShortcutTrigger(triggers[i]));
+        }
+        return result;
+    }
+}
+registerNodeClass(ShortcutNode);

package/dist/nodes/slot.js

@@ -17,11 +17,20 @@ export class SlotNode extends VirtualNode {
     }
     unmount() {
         if (this.parent && this.child) {
+            const parent = this.parent;
             const oldChild = this.child;
             this.child = undefined;
-            this.onChildChange(oldChild ?? null);
+            queueMicrotask(() => {
+                if (parent.getRoot() !== null) {
+                    this.parent = parent;
+                    this.onChildChange(oldChild);
+                }
+                this.parent = undefined;
+            });
+        }
+        else {
+            this.parent = undefined;
         }
-        this.parent = undefined;
         super.unmount();
     }
     getId() {

package/dist/nodes/source-buffer.d.ts

@@ -0,0 +1,73 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import * as GtkSource from "@gtkx/ffi/gtksource";
+import { VirtualNode } from "./virtual.js";
+/**
+ * Props for the SourceBuffer virtual element.
+ *
+ * Used to declaratively configure the text buffer for a GtkSourceView with syntax highlighting,
+ * bracket matching, and other source code editing features.
+ *
+ * @example
+ * ```tsx
+ * <GtkSourceView>
+ *     <x.SourceBuffer
+ *         text={sourceCode}
+ *         language="typescript"
+ *         styleScheme="Adwaita-dark"
+ *         highlightSyntax
+ *         highlightMatchingBrackets
+ *         onTextChanged={(text) => console.log("Code:", text)}
+ *     />
+ * </GtkSourceView>
+ * ```
+ */
+export type SourceBufferProps = {
+    /** Text content */
+    text?: string;
+    /** Whether to enable undo/redo */
+    enableUndo?: boolean;
+    /** Callback when the text content changes */
+    onTextChanged?: (text: string) => void;
+    /** Callback when can-undo state changes */
+    onCanUndoChanged?: (canUndo: boolean) => void;
+    /** Callback when can-redo state changes */
+    onCanRedoChanged?: (canRedo: boolean) => void;
+    /**
+     * Language for syntax highlighting.
+     * Can be a language ID string (e.g., "typescript", "python", "rust") or a GtkSource.Language object.
+     */
+    language?: string | GtkSource.Language;
+    /**
+     * Style scheme for syntax highlighting colors.
+     * Can be a scheme ID string (e.g., "Adwaita-dark", "classic") or a GtkSource.StyleScheme object.
+     */
+    styleScheme?: string | GtkSource.StyleScheme;
+    /** Whether to enable syntax highlighting. Defaults to true when language is set. */
+    highlightSyntax?: boolean;
+    /** Whether to highlight matching brackets when cursor is on a bracket. Defaults to true. */
+    highlightMatchingBrackets?: boolean;
+    /**
+     * Whether the buffer has an implicit trailing newline.
+     * When true (default), trailing newlines are handled automatically during file load/save.
+     */
+    implicitTrailingNewline?: boolean;
+    /** Callback when the cursor position changes */
+    onCursorMoved?: () => void;
+    /** Callback when syntax highlighting is updated for a region */
+    onHighlightUpdated?: (start: Gtk.TextIter, end: Gtk.TextIter) => void;
+};
+export declare class SourceBufferNode extends VirtualNode<SourceBufferProps> {
+    static priority: number;
+    private sourceView?;
+    private buffer?;
+    static matches(type: string): boolean;
+    setSourceView(sourceView: GtkSource.View): void;
+    private resolveLanguage;
+    private resolveStyleScheme;
+    private setupBuffer;
+    private applySourceProps;
+    private getBufferText;
+    private updateSignalHandlers;
+    updateProps(oldProps: SourceBufferProps | null, newProps: SourceBufferProps): void;
+    unmount(): void;
+}

package/dist/nodes/source-buffer.js

@@ -0,0 +1,149 @@
+import { batch } from "@gtkx/ffi";
+import * as Gtk from "@gtkx/ffi/gtk";
+import * as GtkSource from "@gtkx/ffi/gtksource";
+import { registerNodeClass } from "../registry.js";
+import { signalStore } from "./internal/signal-store.js";
+import { VirtualNode } from "./virtual.js";
+export class SourceBufferNode extends VirtualNode {
+    static priority = 1;
+    sourceView;
+    buffer;
+    static matches(type) {
+        return type === "SourceBuffer";
+    }
+    setSourceView(sourceView) {
+        this.sourceView = sourceView;
+        this.setupBuffer();
+    }
+    resolveLanguage(language) {
+        if (typeof language === "string") {
+            const langManager = GtkSource.LanguageManager.getDefault();
+            return langManager.getLanguage(language);
+        }
+        return language;
+    }
+    resolveStyleScheme(scheme) {
+        if (typeof scheme === "string") {
+            const schemeManager = GtkSource.StyleSchemeManager.getDefault();
+            return schemeManager.getScheme(scheme);
+        }
+        return scheme;
+    }
+    setupBuffer() {
+        if (!this.sourceView)
+            return;
+        this.buffer = new GtkSource.Buffer();
+        this.sourceView.setBuffer(this.buffer);
+        if (this.props.enableUndo !== undefined) {
+            this.buffer.setEnableUndo(this.props.enableUndo);
+        }
+        if (this.props.text !== undefined) {
+            this.buffer.setText(this.props.text, -1);
+        }
+        this.applySourceProps();
+        this.updateSignalHandlers();
+    }
+    applySourceProps() {
+        if (!this.buffer)
+            return;
+        if (this.props.language !== undefined) {
+            const language = this.resolveLanguage(this.props.language);
+            this.buffer.setLanguage(language);
+        }
+        if (this.props.styleScheme !== undefined) {
+            const scheme = this.resolveStyleScheme(this.props.styleScheme);
+            this.buffer.setStyleScheme(scheme);
+        }
+        const highlightSyntax = this.props.highlightSyntax ?? this.props.language !== undefined;
+        this.buffer.setHighlightSyntax(highlightSyntax);
+        const highlightMatchingBrackets = this.props.highlightMatchingBrackets ?? true;
+        this.buffer.setHighlightMatchingBrackets(highlightMatchingBrackets);
+        if (this.props.implicitTrailingNewline !== undefined) {
+            this.buffer.setImplicitTrailingNewline(this.props.implicitTrailingNewline);
+        }
+    }
+    getBufferText() {
+        const buffer = this.buffer;
+        if (!buffer)
+            return "";
+        const startIter = new Gtk.TextIter();
+        const endIter = new Gtk.TextIter();
+        batch(() => {
+            buffer.getStartIter(startIter);
+            buffer.getEndIter(endIter);
+        });
+        return buffer.getText(startIter, endIter, true);
+    }
+    updateSignalHandlers() {
+        if (!this.buffer)
+            return;
+        const buffer = this.buffer;
+        const { onTextChanged, onCanUndoChanged, onCanRedoChanged, onCursorMoved, onHighlightUpdated } = this.props;
+        signalStore.set(this, buffer, "changed", onTextChanged ? () => onTextChanged(this.getBufferText()) : null);
+        signalStore.set(this, buffer, "notify::can-undo", onCanUndoChanged ? () => onCanUndoChanged(buffer.getCanUndo()) : null);
+        signalStore.set(this, buffer, "notify::can-redo", onCanRedoChanged ? () => onCanRedoChanged(buffer.getCanRedo()) : null);
+        signalStore.set(this, buffer, "cursor-moved", onCursorMoved ?? null);
+        signalStore.set(this, buffer, "highlight-updated", onHighlightUpdated
+            ? (_buffer, start, end) => onHighlightUpdated(start, end)
+            : null);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        if (!this.buffer)
+            return;
+        if (!oldProps || oldProps.enableUndo !== newProps.enableUndo) {
+            if (newProps.enableUndo !== undefined) {
+                this.buffer.setEnableUndo(newProps.enableUndo);
+            }
+        }
+        if (!oldProps || oldProps.text !== newProps.text) {
+            if (newProps.text !== undefined) {
+                const currentText = this.getBufferText();
+                if (currentText !== newProps.text) {
+                    this.buffer.setText(newProps.text, -1);
+                }
+            }
+        }
+        if (!oldProps || oldProps.language !== newProps.language) {
+            if (newProps.language !== undefined) {
+                const language = this.resolveLanguage(newProps.language);
+                this.buffer.setLanguage(language);
+            }
+        }
+        if (!oldProps || oldProps.styleScheme !== newProps.styleScheme) {
+            if (newProps.styleScheme !== undefined) {
+                const scheme = this.resolveStyleScheme(newProps.styleScheme);
+                this.buffer.setStyleScheme(scheme);
+            }
+        }
+        if (!oldProps ||
+            oldProps.highlightSyntax !== newProps.highlightSyntax ||
+            oldProps.language !== newProps.language) {
+            const highlightSyntax = newProps.highlightSyntax ?? newProps.language !== undefined;
+            this.buffer.setHighlightSyntax(highlightSyntax);
+        }
+        if (!oldProps || oldProps.highlightMatchingBrackets !== newProps.highlightMatchingBrackets) {
+            const highlightMatchingBrackets = newProps.highlightMatchingBrackets ?? true;
+            this.buffer.setHighlightMatchingBrackets(highlightMatchingBrackets);
+        }
+        if (!oldProps || oldProps.implicitTrailingNewline !== newProps.implicitTrailingNewline) {
+            if (newProps.implicitTrailingNewline !== undefined) {
+                this.buffer.setImplicitTrailingNewline(newProps.implicitTrailingNewline);
+            }
+        }
+        if (!oldProps ||
+            oldProps.onTextChanged !== newProps.onTextChanged ||
+            oldProps.onCanUndoChanged !== newProps.onCanUndoChanged ||
+            oldProps.onCanRedoChanged !== newProps.onCanRedoChanged ||
+            oldProps.onCursorMoved !== newProps.onCursorMoved ||
+            oldProps.onHighlightUpdated !== newProps.onHighlightUpdated) {
+            this.updateSignalHandlers();
+        }
+    }
+    unmount() {
+        this.buffer = undefined;
+        this.sourceView = undefined;
+        super.unmount();
+    }
+}
+registerNodeClass(SourceBufferNode);

package/dist/nodes/source-view.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/nodes/source-view.js

@@ -0,0 +1,42 @@
+import * as GtkSource from "@gtkx/ffi/gtksource";
+import { registerNodeClass } from "../registry.js";
+import { isContainerType } from "./internal/utils.js";
+import { SourceBufferNode } from "./source-buffer.js";
+import { WidgetNode } from "./widget.js";
+class SourceViewNode extends WidgetNode {
+    static priority = 1;
+    bufferChild;
+    static matches(_type, containerOrClass) {
+        return isContainerType(GtkSource.View, containerOrClass);
+    }
+    appendChild(child) {
+        if (this.tryAttachSourceBuffer(child))
+            return;
+        super.appendChild(child);
+    }
+    insertBefore(child, before) {
+        if (this.tryAttachSourceBuffer(child))
+            return;
+        super.insertBefore(child, before);
+    }
+    removeChild(child) {
+        if (child instanceof SourceBufferNode) {
+            if (this.bufferChild === child) {
+                this.bufferChild = undefined;
+            }
+            return;
+        }
+        super.removeChild(child);
+    }
+    tryAttachSourceBuffer(child) {
+        if (!(child instanceof SourceBufferNode))
+            return false;
+        if (this.bufferChild) {
+            throw new Error("SourceView can only have one SourceBuffer child");
+        }
+        this.bufferChild = child;
+        child.setSourceView(this.container);
+        return true;
+    }
+}
+registerNodeClass(SourceViewNode);