@gjsify/canvas2d 0.1.0

package/lib/types/canvas-drawing-area.d.ts

@@ -0,0 +1,482 @@
+import GObject from 'gi://GObject';
+import Gdk from 'gi://Gdk?version=4.0';
+import GLib from 'gi://GLib?version=2.0';
+import Gtk from 'gi://Gtk?version=4.0';
+import { HTMLCanvasElement as GjsifyHTMLCanvasElement } from '@gjsify/dom-elements';
+import { CanvasRenderingContext2D } from './canvas-rendering-context-2d.js';
+type Canvas2DReadyCallback = (canvas: globalThis.HTMLCanvasElement, ctx: CanvasRenderingContext2D) => void;
+/**
+ * A `Gtk.DrawingArea` subclass that handles Canvas 2D bootstrapping:
+ * - Creates an `HTMLCanvasElement` + `CanvasRenderingContext2D` on first draw
+ * - Blits the Canvas 2D Cairo.ImageSurface onto the DrawingArea each frame
+ * - Fires `onReady()` callbacks with (canvas, ctx) once the context is available
+ * - Provides `requestAnimationFrame()` backed by GTK frame clock (vsync)
+ * - `installGlobals()` sets `globalThis.requestAnimationFrame` and `globalThis.performance`
+ *
+ * Usage:
+ * ```ts
+ * const widget = new Canvas2DWidget();
+ * widget.installGlobals();  // sets globalThis.requestAnimationFrame
+ * widget.onReady((canvas, ctx) => {
+ *     ctx.fillStyle = 'red';
+ *     ctx.fillRect(0, 0, 100, 100);
+ * });
+ * window.set_child(widget);
+ * ```
+ */
+export declare const Canvas2DWidget: {
+    new (params?: Partial<Gtk.DrawingArea.ConstructorProps>): {
+        _canvas: GjsifyHTMLCanvasElement | null;
+        _ctx: CanvasRenderingContext2D | null;
+        _readyCallbacks: Canvas2DReadyCallback[];
+        _tickCallbackId: number | null;
+        _frameCallback: FrameRequestCallback | null;
+        _timeOrigin: number;
+        /** @internal Draw function called by GTK. Blits the Cairo surface to screen. */
+        _onDraw(_area: Gtk.DrawingArea, cr: any, width: number, height: number): void;
+        /** The HTMLCanvasElement backing this widget. Available after the first draw. */
+        get canvas(): globalThis.HTMLCanvasElement | null;
+        /** Get the 2D rendering context. Available after the first draw. */
+        getContext(_id: "2d"): CanvasRenderingContext2D | null;
+        /**
+         * Register a callback to be invoked once the Canvas 2D context is ready.
+         * If the context is already available, the callback fires synchronously.
+         */
+        onReady(cb: Canvas2DReadyCallback): void;
+        /**
+         * Schedules a single animation frame callback, matching the browser `requestAnimationFrame` API.
+         * Backed by GTK frame clock (vsync-synced, typically ~60 FPS).
+         * Returns 0 (handle — cancel not yet implemented).
+         */
+        requestAnimationFrame(cb: FrameRequestCallback): number;
+        /**
+         * Sets browser globals (`requestAnimationFrame`, `performance`) so that
+         * browser-targeted code works unchanged on GJS.
+         */
+        installGlobals(): void;
+        get content_height(): number;
+        set content_height(val: number);
+        get contentHeight(): number;
+        set contentHeight(val: number);
+        get content_width(): number;
+        set content_width(val: number);
+        get contentWidth(): number;
+        set contentWidth(val: number);
+        $signals: Gtk.DrawingArea.SignalSignatures;
+        widget: Gtk.Widget;
+        _init(...args: any[]): void;
+        connect<K extends keyof Gtk.DrawingArea.SignalSignatures>(signal: K, callback: GObject.SignalCallback</*elided*/ any, Gtk.DrawingArea.SignalSignatures[K]>): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Gtk.DrawingArea.SignalSignatures>(signal: K, callback: GObject.SignalCallback</*elided*/ any, Gtk.DrawingArea.SignalSignatures[K]>): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Gtk.DrawingArea.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<Gtk.DrawingArea.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
+        emit(signal: string, ...args: any[]): void;
+        vfunc_resize(width: number, height: number): void;
+        get_content_height(): number;
+        get_content_width(): number;
+        set_content_height(height: number): void;
+        set_content_width(width: number): void;
+        set_draw_func(draw_func?: Gtk.DrawingAreaDrawFunc | null): void;
+        get accessible_role(): Gtk.AccessibleRole;
+        set accessible_role(val: Gtk.AccessibleRole);
+        get accessibleRole(): Gtk.AccessibleRole;
+        set accessibleRole(val: Gtk.AccessibleRole);
+        announce(message: string, priority: Gtk.AccessibleAnnouncementPriority | null): void;
+        get_accessible_id(): string | null;
+        get_accessible_parent(): Gtk.Accessible | null;
+        get_accessible_role(): Gtk.AccessibleRole;
+        get_at_context(): Gtk.ATContext;
+        get_bounds(): [boolean, number, number, number, number];
+        get_first_accessible_child(): Gtk.Accessible | null;
+        get_next_accessible_sibling(): Gtk.Accessible | null;
+        get_platform_state(state: Gtk.AccessiblePlatformState | null): boolean;
+        reset_property(property: Gtk.AccessibleProperty | null): void;
+        reset_relation(relation: Gtk.AccessibleRelation | null): void;
+        reset_state(state: Gtk.AccessibleState | null): void;
+        set_accessible_parent(parent?: Gtk.Accessible | null, next_sibling?: Gtk.Accessible | null): void;
+        update_next_accessible_sibling(new_sibling?: Gtk.Accessible | null): void;
+        update_platform_state(state: Gtk.AccessiblePlatformState | null): void;
+        update_property(properties: Gtk.AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+        update_relation(relations: Gtk.AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+        update_state(states: Gtk.AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+        vfunc_get_accessible_id(): string | null;
+        vfunc_get_accessible_parent(): Gtk.Accessible | null;
+        vfunc_get_at_context(): Gtk.ATContext | null;
+        vfunc_get_bounds(): [boolean, number, number, number, number];
+        vfunc_get_first_accessible_child(): Gtk.Accessible | null;
+        vfunc_get_next_accessible_sibling(): Gtk.Accessible | null;
+        vfunc_get_platform_state(state: Gtk.AccessiblePlatformState): boolean;
+        get_buildable_id(): string | null;
+        vfunc_add_child(builder: Gtk.Builder, child: GObject.Object, type?: string | null): void;
+        vfunc_custom_finished(builder: Gtk.Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+        vfunc_custom_tag_end(builder: Gtk.Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+        vfunc_custom_tag_start(builder: Gtk.Builder, child: GObject.Object | null, tagname: string): [boolean, Gtk.BuildableParser, any];
+        vfunc_get_id(): string;
+        vfunc_get_internal_child<T = GObject.Object>(builder: Gtk.Builder, childname: string): T;
+        vfunc_parser_finished(builder: Gtk.Builder): void;
+        vfunc_set_buildable_property(builder: Gtk.Builder, name: string, value: GObject.Value | any): void;
+        vfunc_set_id(id: string): void;
+        bind_property(source_property: string, target: GObject.Object, target_property: string, flags: GObject.BindingFlags | null): GObject.Binding;
+        bind_property_full(source_property: string, target: GObject.Object, target_property: string, flags: GObject.BindingFlags | null, transform_to?: GObject.BindingTransformFunc | null, transform_from?: GObject.BindingTransformFunc | null, notify?: GLib.DestroyNotify | null): GObject.Binding;
+        bind_property_full(...args: never[]): any;
+        force_floating(): void;
+        freeze_notify(): void;
+        get_data(key: string): any | null;
+        get_property(property_name: string, value: GObject.Value | any): any;
+        get_qdata(quark: GLib.Quark): any | null;
+        getv(names: string[], values: (GObject.Value | any)[]): void;
+        is_floating(): boolean;
+        notify(property_name: string): void;
+        notify_by_pspec(pspec: GObject.ParamSpec): void;
+        ref(): GObject.Object;
+        ref_sink(): GObject.Object;
+        run_dispose(): void;
+        set_data(key: string, data?: any | null): void;
+        set_property(property_name: string, value: GObject.Value | any): void;
+        steal_data(key: string): any | null;
+        steal_qdata(quark: GLib.Quark): any | null;
+        thaw_notify(): void;
+        unref(): void;
+        watch_closure(closure: GObject.Closure): void;
+        vfunc_constructed(): void;
+        vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+        vfunc_dispose(): void;
+        vfunc_finalize(): void;
+        vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+        vfunc_notify(pspec: GObject.ParamSpec): void;
+        vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+        disconnect(id: number): void;
+        set(properties: {
+            [key: string]: any;
+        }): void;
+        block_signal_handler(id: number): void;
+        unblock_signal_handler(id: number): void;
+        stop_emission_by_name(detailedName: string): void;
+        get can_focus(): boolean;
+        set can_focus(val: boolean);
+        get canFocus(): boolean;
+        set canFocus(val: boolean);
+        get can_target(): boolean;
+        set can_target(val: boolean);
+        get canTarget(): boolean;
+        set canTarget(val: boolean);
+        get css_classes(): string[];
+        set css_classes(val: string[]);
+        get cssClasses(): string[];
+        set cssClasses(val: string[]);
+        get css_name(): string;
+        get cssName(): string;
+        get cursor(): Gdk.Cursor;
+        set cursor(val: Gdk.Cursor);
+        get focus_on_click(): boolean;
+        set focus_on_click(val: boolean);
+        get focusOnClick(): boolean;
+        set focusOnClick(val: boolean);
+        get focusable(): boolean;
+        set focusable(val: boolean);
+        get halign(): Gtk.Align;
+        set halign(val: Gtk.Align);
+        get has_default(): boolean;
+        get hasDefault(): boolean;
+        get has_focus(): boolean;
+        get hasFocus(): boolean;
+        get has_tooltip(): boolean;
+        set has_tooltip(val: boolean);
+        get hasTooltip(): boolean;
+        set hasTooltip(val: boolean);
+        get height_request(): number;
+        set height_request(val: number);
+        get heightRequest(): number;
+        set heightRequest(val: number);
+        get hexpand(): boolean;
+        set hexpand(val: boolean);
+        get hexpand_set(): boolean;
+        set hexpand_set(val: boolean);
+        get hexpandSet(): boolean;
+        set hexpandSet(val: boolean);
+        get layout_manager(): Gtk.LayoutManager;
+        set layout_manager(val: Gtk.LayoutManager);
+        get layoutManager(): Gtk.LayoutManager;
+        set layoutManager(val: Gtk.LayoutManager);
+        get limit_events(): boolean;
+        set limit_events(val: boolean);
+        get limitEvents(): boolean;
+        set limitEvents(val: boolean);
+        get margin_bottom(): number;
+        set margin_bottom(val: number);
+        get marginBottom(): number;
+        set marginBottom(val: number);
+        get margin_end(): number;
+        set margin_end(val: number);
+        get marginEnd(): number;
+        set marginEnd(val: number);
+        get margin_start(): number;
+        set margin_start(val: number);
+        get marginStart(): number;
+        set marginStart(val: number);
+        get margin_top(): number;
+        set margin_top(val: number);
+        get marginTop(): number;
+        set marginTop(val: number);
+        get name(): string;
+        set name(val: string);
+        get opacity(): number;
+        set opacity(val: number);
+        get overflow(): Gtk.Overflow;
+        set overflow(val: Gtk.Overflow);
+        get parent(): Gtk.Widget;
+        get receives_default(): boolean;
+        set receives_default(val: boolean);
+        get receivesDefault(): boolean;
+        set receivesDefault(val: boolean);
+        get root(): Gtk.Root;
+        get scale_factor(): number;
+        get scaleFactor(): number;
+        get sensitive(): boolean;
+        set sensitive(val: boolean);
+        get tooltip_markup(): string;
+        set tooltip_markup(val: string);
+        get tooltipMarkup(): string;
+        set tooltipMarkup(val: string);
+        get tooltip_text(): string;
+        set tooltip_text(val: string);
+        get tooltipText(): string;
+        set tooltipText(val: string);
+        get valign(): Gtk.Align;
+        set valign(val: Gtk.Align);
+        get vexpand(): boolean;
+        set vexpand(val: boolean);
+        get vexpand_set(): boolean;
+        set vexpand_set(val: boolean);
+        get vexpandSet(): boolean;
+        set vexpandSet(val: boolean);
+        get visible(): boolean;
+        set visible(val: boolean);
+        get width_request(): number;
+        set width_request(val: number);
+        get widthRequest(): number;
+        set widthRequest(val: number);
+        vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+        vfunc_contains(x: number, y: number): boolean;
+        vfunc_css_changed(change: Gtk.CssStyleChange): void;
+        vfunc_direction_changed(previous_direction: Gtk.TextDirection): void;
+        vfunc_focus(direction: Gtk.DirectionType): boolean;
+        vfunc_get_request_mode(): Gtk.SizeRequestMode;
+        vfunc_grab_focus(): boolean;
+        vfunc_hide(): void;
+        vfunc_keynav_failed(direction: Gtk.DirectionType): boolean;
+        vfunc_map(): void;
+        vfunc_measure(orientation: Gtk.Orientation, for_size: number): [number, number, number, number];
+        vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+        vfunc_move_focus(direction: Gtk.DirectionType): void;
+        vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Gtk.Tooltip): boolean;
+        vfunc_realize(): void;
+        vfunc_root(): void;
+        vfunc_set_focus_child(child?: Gtk.Widget | null): void;
+        vfunc_show(): void;
+        vfunc_size_allocate(width: number, height: number, baseline: number): void;
+        vfunc_snapshot(snapshot: Gtk.Snapshot): void;
+        vfunc_state_flags_changed(previous_state_flags: Gtk.StateFlags): void;
+        vfunc_system_setting_changed(settings: Gtk.SystemSetting): void;
+        vfunc_unmap(): void;
+        vfunc_unrealize(): void;
+        vfunc_unroot(): void;
+        action_set_enabled(action_name: string, enabled: boolean): void;
+        activate(): boolean;
+        activate_action(name: string, args?: GLib.Variant | null): boolean;
+        activate_default(): void;
+        add_controller(controller: Gtk.EventController): void;
+        add_css_class(css_class: string): void;
+        add_mnemonic_label(label: Gtk.Widget): void;
+        add_tick_callback(callback: Gtk.TickCallback): number;
+        allocate(width: number, height: number, baseline: number, transform?: import("@girs/gsk-4.0").default.Transform | null): void;
+        child_focus(direction: Gtk.DirectionType | null): boolean;
+        compute_bounds(target: Gtk.Widget): [boolean, import("@girs/graphene-1.0").default.Rect];
+        compute_expand(orientation: Gtk.Orientation | null): boolean;
+        compute_point(target: Gtk.Widget, point: import("@girs/graphene-1.0").default.Point): [boolean, import("@girs/graphene-1.0").default.Point];
+        compute_transform(target: Gtk.Widget): [boolean, import("@girs/graphene-1.0").default.Matrix];
+        contains(x: number, y: number): boolean;
+        create_pango_context(): import("@girs/pango-1.0").default.Context;
+        create_pango_layout(text?: string | null): import("@girs/pango-1.0").default.Layout;
+        dispose_template(widget_type: GObject.GType): void;
+        drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+        error_bell(): void;
+        get_allocated_baseline(): number;
+        get_allocated_height(): number;
+        get_allocated_width(): number;
+        get_allocation(): Gtk.Allocation;
+        get_ancestor(widget_type: GObject.GType): Gtk.Widget | null;
+        get_baseline(): number;
+        get_can_focus(): boolean;
+        get_can_target(): boolean;
+        get_child_visible(): boolean;
+        get_clipboard(): Gdk.Clipboard;
+        get_color(): Gdk.RGBA;
+        get_css_classes(): string[];
+        get_css_name(): string;
+        get_cursor(): Gdk.Cursor | null;
+        get_direction(): Gtk.TextDirection;
+        get_display(): Gdk.Display;
+        get_first_child(): Gtk.Widget | null;
+        get_focus_child(): Gtk.Widget | null;
+        get_focus_on_click(): boolean;
+        get_focusable(): boolean;
+        get_font_map(): import("@girs/pango-1.0").default.FontMap | null;
+        get_font_options(): import("@girs/gjs/cairo").default.FontOptions | null;
+        get_frame_clock(): Gdk.FrameClock | null;
+        get_halign(): Gtk.Align;
+        get_has_tooltip(): boolean;
+        get_height(): number;
+        get_hexpand(): boolean;
+        get_hexpand_set(): boolean;
+        get_last_child(): Gtk.Widget | null;
+        get_layout_manager(): Gtk.LayoutManager | null;
+        get_limit_events(): boolean;
+        get_mapped(): boolean;
+        get_margin_bottom(): number;
+        get_margin_end(): number;
+        get_margin_start(): number;
+        get_margin_top(): number;
+        get_name(): string;
+        get_native(): Gtk.Native | null;
+        get_next_sibling(): Gtk.Widget | null;
+        get_opacity(): number;
+        get_overflow(): Gtk.Overflow;
+        get_pango_context(): import("@girs/pango-1.0").default.Context;
+        get_parent(): Gtk.Widget | null;
+        get_preferred_size(): [Gtk.Requisition | null, Gtk.Requisition | null];
+        get_prev_sibling(): Gtk.Widget | null;
+        get_primary_clipboard(): Gdk.Clipboard;
+        get_realized(): boolean;
+        get_receives_default(): boolean;
+        get_request_mode(): Gtk.SizeRequestMode;
+        get_root(): Gtk.Root | null;
+        get_scale_factor(): number;
+        get_sensitive(): boolean;
+        get_settings(): Gtk.Settings;
+        get_size(orientation: Gtk.Orientation | null): number;
+        get_size_request(): [number, number];
+        get_state_flags(): Gtk.StateFlags;
+        get_style_context(): Gtk.StyleContext;
+        get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+        get_tooltip_markup(): string | null;
+        get_tooltip_text(): string | null;
+        get_valign(): Gtk.Align;
+        get_vexpand(): boolean;
+        get_vexpand_set(): boolean;
+        get_visible(): boolean;
+        get_width(): number;
+        grab_focus(): boolean;
+        has_css_class(css_class: string): boolean;
+        has_visible_focus(): boolean;
+        hide(): void;
+        in_destruction(): boolean;
+        init_template(): void;
+        insert_action_group(name: string, group?: import("@girs/gio-2.0").default.ActionGroup | null): void;
+        insert_after(parent: Gtk.Widget, previous_sibling?: Gtk.Widget | null): void;
+        insert_before(parent: Gtk.Widget, next_sibling?: Gtk.Widget | null): void;
+        is_ancestor(ancestor: Gtk.Widget): boolean;
+        is_drawable(): boolean;
+        is_focus(): boolean;
+        is_sensitive(): boolean;
+        is_visible(): boolean;
+        keynav_failed(direction: Gtk.DirectionType | null): boolean;
+        list_mnemonic_labels(): Gtk.Widget[];
+        map(): void;
+        measure(orientation: Gtk.Orientation | null, for_size: number): [number, number, number, number];
+        mnemonic_activate(group_cycling: boolean): boolean;
+        observe_children(): import("@girs/gio-2.0").default.ListModel;
+        observe_controllers(): import("@girs/gio-2.0").default.ListModel;
+        pick(x: number, y: number, flags: Gtk.PickFlags | null): Gtk.Widget | null;
+        queue_allocate(): void;
+        queue_draw(): void;
+        queue_resize(): void;
+        realize(): void;
+        remove_controller(controller: Gtk.EventController): void;
+        remove_css_class(css_class: string): void;
+        remove_mnemonic_label(label: Gtk.Widget): void;
+        remove_tick_callback(id: number): void;
+        set_can_focus(can_focus: boolean): void;
+        set_can_target(can_target: boolean): void;
+        set_child_visible(child_visible: boolean): void;
+        set_css_classes(classes: string[]): void;
+        set_cursor(cursor?: Gdk.Cursor | null): void;
+        set_cursor_from_name(name?: string | null): void;
+        set_direction(dir: Gtk.TextDirection | null): void;
+        set_focus_child(child?: Gtk.Widget | null): void;
+        set_focus_on_click(focus_on_click: boolean): void;
+        set_focusable(focusable: boolean): void;
+        set_font_map(font_map?: import("@girs/pango-1.0").default.FontMap | null): void;
+        set_font_options(options?: import("@girs/gjs/cairo").default.FontOptions | null): void;
+        set_halign(align: Gtk.Align | null): void;
+        set_has_tooltip(has_tooltip: boolean): void;
+        set_hexpand(expand: boolean): void;
+        set_hexpand_set(set: boolean): void;
+        set_layout_manager(layout_manager?: Gtk.LayoutManager | null): void;
+        set_limit_events(limit_events: boolean): void;
+        set_margin_bottom(margin: number): void;
+        set_margin_end(margin: number): void;
+        set_margin_start(margin: number): void;
+        set_margin_top(margin: number): void;
+        set_name(name: string): void;
+        set_opacity(opacity: number): void;
+        set_overflow(overflow: Gtk.Overflow | null): void;
+        set_parent(parent: Gtk.Widget): void;
+        set_receives_default(receives_default: boolean): void;
+        set_sensitive(sensitive: boolean): void;
+        set_size_request(width: number, height: number): void;
+        set_state_flags(flags: Gtk.StateFlags | null, clear: boolean): void;
+        set_tooltip_markup(markup?: string | null): void;
+        set_tooltip_text(text?: string | null): void;
+        set_valign(align: Gtk.Align | null): void;
+        set_vexpand(expand: boolean): void;
+        set_vexpand_set(set: boolean): void;
+        set_visible(visible: boolean): void;
+        should_layout(): boolean;
+        show(): void;
+        size_allocate(allocation: Gtk.Allocation, baseline: number): void;
+        snapshot_child(child: Gtk.Widget, snapshot: Gtk.Snapshot): void;
+        translate_coordinates(dest_widget: Gtk.Widget, src_x: number, src_y: number): [boolean, number, number];
+        trigger_tooltip_query(): void;
+        unmap(): void;
+        unparent(): void;
+        unrealize(): void;
+        unset_state_flags(flags: Gtk.StateFlags | null): void;
+        [Symbol.iterator]: () => IterableIterator<Gtk.Widget>;
+    };
+    $gtype: GObject.GType<Gtk.DrawingArea>;
+    "new"(): Gtk.DrawingArea;
+    get_default_direction(): Gtk.TextDirection;
+    set_default_direction(dir: Gtk.TextDirection): void;
+    add_shortcut(shortcut: Gtk.Shortcut): void;
+    bind_template_callback_full(callback_name: string, callback_symbol: GObject.Callback): void;
+    bind_template_child_full(name: string, internal_child: boolean, struct_offset: number): void;
+    get_accessible_role(): Gtk.AccessibleRole;
+    get_activate_signal(): number;
+    get_css_name(): string;
+    get_layout_manager_type(): GObject.GType;
+    install_action(action_name: string, parameter_type: string | null, activate: Gtk.WidgetActionActivateFunc): void;
+    install_property_action(action_name: string, property_name: string): void;
+    query_action(index_: number): [boolean, GObject.GType, string, GLib.VariantType | null, string];
+    set_accessible_role(accessible_role: Gtk.AccessibleRole): void;
+    set_activate_signal(signal_id: number): void;
+    set_activate_signal_from_name(signal_name: string): void;
+    set_css_name(name: string): void;
+    set_layout_manager_type(type: GObject.GType): void;
+    set_template(template_bytes: GLib.Bytes | Uint8Array): void;
+    set_template_from_resource(resource_name: string): void;
+    set_template_scope(scope: Gtk.BuilderScope): void;
+    newv(object_type: GObject.GType, parameters: GObject.Parameter[]): GObject.Object;
+    compat_control(what: number, data?: any | null): number;
+    interface_find_property(g_iface: GObject.TypeInterface, property_name: string): GObject.ParamSpec;
+    interface_install_property(g_iface: GObject.TypeInterface, pspec: GObject.ParamSpec): void;
+    interface_list_properties(g_iface: GObject.TypeInterface): GObject.ParamSpec[];
+    find_property(property_name: string): GObject.ParamSpec;
+    install_properties(pspecs: GObject.ParamSpec[]): void;
+    install_property(property_id: number, pspec: GObject.ParamSpec): void;
+    list_properties(): GObject.ParamSpec[];
+    override_property(property_id: number, name: string): void;
+    _classInit(klass: any): any;
+};
+export type Canvas2DWidget = InstanceType<typeof Canvas2DWidget>;
+export {};

package/lib/types/canvas-gradient.d.ts

@@ -0,0 +1,11 @@
+import Cairo from 'cairo';
+/**
+ * CanvasGradient wrapping a Cairo LinearGradient or RadialGradient.
+ */
+export declare class CanvasGradient {
+    private _pattern;
+    constructor(type: 'linear' | 'radial', x0: number, y0: number, x1: number, y1: number, r0?: number, r1?: number);
+    addColorStop(offset: number, color: string): void;
+    /** @internal Get the underlying Cairo pattern for rendering. */
+    _getCairoPattern(): Cairo.LinearGradient | Cairo.RadialGradient;
+}

package/lib/types/canvas-path.d.ts

@@ -0,0 +1,80 @@
+/** A recorded path operation. */
+type PathOp = {
+    type: 'moveTo';
+    x: number;
+    y: number;
+} | {
+    type: 'lineTo';
+    x: number;
+    y: number;
+} | {
+    type: 'closePath';
+} | {
+    type: 'bezierCurveTo';
+    cp1x: number;
+    cp1y: number;
+    cp2x: number;
+    cp2y: number;
+    x: number;
+    y: number;
+} | {
+    type: 'quadraticCurveTo';
+    cpx: number;
+    cpy: number;
+    x: number;
+    y: number;
+} | {
+    type: 'arc';
+    x: number;
+    y: number;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    ccw: boolean;
+} | {
+    type: 'ellipse';
+    x: number;
+    y: number;
+    rx: number;
+    ry: number;
+    rotation: number;
+    startAngle: number;
+    endAngle: number;
+    ccw: boolean;
+} | {
+    type: 'rect';
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+} | {
+    type: 'roundRect';
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    radii: number | number[];
+};
+/**
+ * Path2D records path operations for later replay on a CanvasRenderingContext2D.
+ */
+export declare class Path2D {
+    /** @internal Recorded operations */
+    _ops: PathOp[];
+    constructor(pathOrSvg?: Path2D | string);
+    addPath(path: Path2D): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    closePath(): void;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    rect(x: number, y: number, w: number, h: number): void;
+    roundRect(x: number, y: number, w: number, h: number, radii?: number | number[]): void;
+    /**
+     * @internal Replay all recorded path operations onto a Cairo context.
+     */
+    _replayOnCairo(ctx: import('cairo').default.Context): void;
+}
+export {};

package/lib/types/canvas-pattern.d.ts

@@ -0,0 +1,12 @@
+import Cairo from 'cairo';
+/**
+ * CanvasPattern wrapping a Cairo SurfacePattern.
+ */
+export declare class CanvasPattern {
+    private _pattern;
+    private constructor();
+    /** Create a CanvasPattern from a supported image source. Returns null if unsupported. */
+    static create(image: any, repetition: string | null): CanvasPattern | null;
+    /** @internal Get the underlying Cairo pattern for rendering. */
+    _getCairoPattern(): Cairo.SurfacePattern;
+}