@gjsify/webgl 0.0.4 → 0.1.0

package/lib/types/canvas-webgl-widget.d.ts

@@ -0,0 +1,509 @@
+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 OurHTMLCanvasElement } from './html-canvas-element.js';
+type WebGLReadyCallback = (canvas: globalThis.HTMLCanvasElement, gl: globalThis.WebGLRenderingContext) => void;
+/**
+ * A `Gtk.GLArea` subclass that handles WebGL bootstrapping:
+ * - Sets up OpenGL ES 3.2 context, depth buffer, stencil buffer
+ * - Creates an `HTMLCanvasElement` wrapping the GLArea on first render
+ * - Fires `onReady()` callbacks with (canvas, gl) once the context is available
+ * - Provides `requestAnimationFrame()` backed by GTK frame clock (vsync) + render signal
+ * - `installGlobals()` sets `globalThis.requestAnimationFrame` and `globalThis.performance`
+ *
+ * Usage:
+ * ```ts
+ * const widget = new CanvasWebGLWidget();
+ * widget.installGlobals();  // sets globalThis.requestAnimationFrame
+ * widget.onReady((canvas, gl) => {
+ *     gl.clearColor(0, 0, 0, 1);
+ *     // requestAnimationFrame is now available globally
+ * });
+ * window.set_child(widget);
+ * ```
+ */
+export declare const CanvasWebGLWidget: {
+    new (params?: Partial<Gtk.GLArea.ConstructorProps>): {
+        _canvas: OurHTMLCanvasElement | null;
+        _readyCallbacks: WebGLReadyCallback[];
+        _renderTag: number | null;
+        _tickCallbackId: number | null;
+        _frameCallback: FrameRequestCallback | null;
+        _timeOrigin: number;
+        /** The HTMLCanvasElement wrapping this GLArea. Available after the first render. */
+        get canvas(): globalThis.HTMLCanvasElement | null;
+        /**
+         * Registers a callback to be called once the WebGL context is ready.
+         * If the context is already available, the callback fires synchronously.
+         */
+        onReady(cb: WebGLReadyCallback): void;
+        /**
+         * @deprecated Use `onReady()` instead.
+         */
+        onWebGLReady(cb: WebGLReadyCallback): void;
+        /**
+         * Schedules a single animation frame callback, matching the browser `requestAnimationFrame` API.
+         * Backed by GTK frame clock (vsync-synced) + the GLArea render signal.
+         * Returns 0 (handle — cancel not yet implemented).
+         */
+        requestAnimationFrame(cb: FrameRequestCallback): number;
+        /**
+         * Sets browser globals (`requestAnimationFrame`, `performance`) so that
+         * browser-targeted code (e.g. Three.js) works unchanged on GJS.
+         */
+        installGlobals(): void;
+        get allowed_apis(): Gdk.GLAPI;
+        set allowed_apis(val: Gdk.GLAPI);
+        get allowedApis(): Gdk.GLAPI;
+        set allowedApis(val: Gdk.GLAPI);
+        get api(): Gdk.GLAPI;
+        get auto_render(): boolean;
+        set auto_render(val: boolean);
+        get autoRender(): boolean;
+        set autoRender(val: boolean);
+        get context(): Gdk.GLContext;
+        get has_depth_buffer(): boolean;
+        set has_depth_buffer(val: boolean);
+        get hasDepthBuffer(): boolean;
+        set hasDepthBuffer(val: boolean);
+        get has_stencil_buffer(): boolean;
+        set has_stencil_buffer(val: boolean);
+        get hasStencilBuffer(): boolean;
+        set hasStencilBuffer(val: boolean);
+        get use_es(): boolean;
+        set use_es(val: boolean);
+        get useEs(): boolean;
+        set useEs(val: boolean);
+        $signals: Gtk.GLArea.SignalSignatures;
+        _init(...args: any[]): void;
+        connect<K extends keyof Gtk.GLArea.SignalSignatures>(signal: K, callback: GObject.SignalCallback</*elided*/ any, Gtk.GLArea.SignalSignatures[K]>): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Gtk.GLArea.SignalSignatures>(signal: K, callback: GObject.SignalCallback</*elided*/ any, Gtk.GLArea.SignalSignatures[K]>): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Gtk.GLArea.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<Gtk.GLArea.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
+        emit(signal: string, ...args: any[]): void;
+        vfunc_render(context: Gdk.GLContext): boolean;
+        vfunc_resize(width: number, height: number): void;
+        attach_buffers(): void;
+        get_allowed_apis(): Gdk.GLAPI;
+        get_api(): Gdk.GLAPI;
+        get_auto_render(): boolean;
+        get_context(): Gdk.GLContext | null;
+        get_error(): GLib.Error | null;
+        get_has_depth_buffer(): boolean;
+        get_has_stencil_buffer(): boolean;
+        get_required_version(): [number, number];
+        get_use_es(): boolean;
+        make_current(): void;
+        queue_render(): void;
+        set_allowed_apis(apis: Gdk.GLAPI | null): void;
+        set_auto_render(auto_render: boolean): void;
+        set_error(error?: GLib.Error | null): void;
+        set_has_depth_buffer(has_depth_buffer: boolean): void;
+        set_has_stencil_buffer(has_stencil_buffer: boolean): void;
+        set_required_version(major: number, minor: number): void;
+        set_use_es(use_es: boolean): 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.GLArea>;
+    "new"(): Gtk.GLArea;
+    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 CanvasWebGLWidget = InstanceType<typeof CanvasWebGLWidget>;
+export {};

package/lib/types/extensions/ext-blend-minmax.d.ts

@@ -1,7 +1,7 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+import type { WebGLRenderingContext } from '../webgl-rendering-context.js';
 export declare class EXTBlendMinMax {
     MIN_EXT: number;
     MAX_EXT: number;
     constructor();
 }
-export declare function getEXTBlendMinMax(context: GjsifyWebGLRenderingContext): any;
+export declare function getEXTBlendMinMax(context: WebGLRenderingContext): any;

package/lib/types/extensions/ext-texture-filter-anisotropic.d.ts

@@ -1,7 +1,7 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+import type { WebGLRenderingContext } from '../webgl-rendering-context.js';
 export declare class EXTTextureFilterAnisotropic {
     TEXTURE_MAX_ANISOTROPY_EXT: number;
     MAX_TEXTURE_MAX_ANISOTROPY_EXT: number;
     constructor();
 }
-export declare function getEXTTextureFilterAnisotropic(context: GjsifyWebGLRenderingContext): any;
+export declare function getEXTTextureFilterAnisotropic(context: WebGLRenderingContext): any;

package/lib/types/extensions/oes-element-index-unit.d.ts

@@ -1,4 +1,4 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+import type { WebGLRenderingContext } from '../webgl-rendering-context.js';
 export declare class OESElementIndexUint {
 }
-export declare function getOESElementIndexUint(context: GjsifyWebGLRenderingContext): any;
+export declare function getOESElementIndexUint(context: WebGLRenderingContext): any;

package/lib/types/extensions/oes-standard-derivatives.d.ts

@@ -1,6 +1,6 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+import type { WebGLRenderingContext } from '../webgl-rendering-context.js';
 export declare class OESStandardDerivatives {
     FRAGMENT_SHADER_DERIVATIVE_HINT_OES: number;
     constructor();
 }
-export declare function getOESStandardDerivatives(context: GjsifyWebGLRenderingContext): any;
+export declare function getOESStandardDerivatives(context: WebGLRenderingContext): any;

package/lib/types/extensions/oes-texture-float-linear.d.ts

@@ -1,4 +1,4 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+import type { WebGLRenderingContext } from '../webgl-rendering-context.js';
 export declare class OESTextureFloatLinear {
 }
-export declare function getOESTextureFloatLinear(context: GjsifyWebGLRenderingContext): any;
+export declare function getOESTextureFloatLinear(context: WebGLRenderingContext): any;

package/lib/types/extensions/oes-texture-float.d.ts

@@ -1,4 +1,4 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+import type { WebGLRenderingContext } from '../webgl-rendering-context.js';
 export declare class OESTextureFloat {
 }
-export declare function getOESTextureFloat(context: GjsifyWebGLRenderingContext): any;
+export declare function getOESTextureFloat(context: WebGLRenderingContext): any;

package/lib/types/extensions/stackgl-destroy-context.d.ts

@@ -1,6 +1,6 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+import type { WebGLRenderingContext } from '../webgl-rendering-context.js';
 export declare class STACKGLDestroyContext {
     destroy: () => void;
-    constructor(ctx: GjsifyWebGLRenderingContext);
+    constructor(ctx: WebGLRenderingContext);
 }
-export declare function getSTACKGLDestroyContext(ctx: GjsifyWebGLRenderingContext): STACKGLDestroyContext;
+export declare function getSTACKGLDestroyContext(ctx: WebGLRenderingContext): STACKGLDestroyContext;

package/lib/types/extensions/stackgl-resize-drawing-buffer.d.ts

@@ -1,6 +1,6 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+import type { WebGLRenderingContext } from '../webgl-rendering-context.js';
 export declare class STACKGLResizeDrawingBuffer {
     resize: (width: number, height: number) => void;
-    constructor(ctx: GjsifyWebGLRenderingContext);
+    constructor(ctx: WebGLRenderingContext);
 }
-export declare function getSTACKGLResizeDrawingBuffer(ctx: GjsifyWebGLRenderingContext): STACKGLResizeDrawingBuffer;
+export declare function getSTACKGLResizeDrawingBuffer(ctx: WebGLRenderingContext): STACKGLResizeDrawingBuffer;

package/lib/types/html-canvas-element.d.ts

@@ -1,39 +1,27 @@
-/// <reference types="@girs/gtk-4.0/ambient" />
+import { HTMLCanvasElement as BaseHTMLCanvasElement } from '@gjsify/dom-elements';
 import Gtk from 'gi://Gtk?version=4.0';
-import { GjsifyWebGLRenderingContext } from './webgl-rendering-context.js';
-export interface GjsifyHTMLCanvasElement extends HTMLCanvasElement {
-}
-export declare class GjsifyHTMLCanvasElement implements HTMLCanvasElement {
-    protected readonly gtkGlArea: Gtk.GLArea;
-    _webgl?: WebGLRenderingContext & GjsifyWebGLRenderingContext;
-    _getGlArea(): Gtk.GLArea;
+import { WebGLRenderingContext as OurWebGLRenderingContext } from './webgl-rendering-context.js';
+import { WebGL2RenderingContext as OurWebGL2RenderingContext } from './webgl2-rendering-context.js';
+export declare class HTMLCanvasElement extends BaseHTMLCanvasElement {
+    readonly gtkGlArea: Gtk.GLArea;
+    _webgl?: OurWebGLRenderingContext;
+    _webgl2?: OurWebGL2RenderingContext;
     constructor(gtkGlArea: Gtk.GLArea);
-    /** Gets the height of a canvas element on a document. */
-    get height(): number;
-    get clientHeight(): number;
-    /** Sets the height of a canvas element on a document. */
-    set height(_height: number);
-    /** Gets the width of a canvas element on a document. */
+    /** Width from the GTK GLArea allocated size (overrides DOM attr-backed getter). */
     get width(): number;
-    /** Sets the width of a canvas element on a document. */
     set width(_width: number);
+    /** Height from the GTK GLArea allocated size (overrides DOM attr-backed getter). */
+    get height(): number;
+    set height(_height: number);
     get clientWidth(): number;
-    captureStream(_frameRequestRate?: number): MediaStream;
-    /**
-     * Returns an object that provides methods and properties for drawing and manipulating images and graphics on a canvas element in a document. A context object includes information about colors, line widths, fonts, and other graphic parameters that can be drawn on a canvas.
-     * @param contextId The identifier (ID) of the type of canvas to create. Internet Explorer 9 and Internet Explorer 10 support only a 2-D context using canvas.getContext("2d"); IE11 Preview also supports 3-D or WebGL context using canvas.getContext("experimental-webgl");
-     */
-    getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
-    getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
-    getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext & GjsifyWebGLRenderingContext | null;
-    getContext(contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
-    toBlob(_callback: BlobCallback, _type?: string, _quality?: any): void;
+    get clientHeight(): number;
+    /** Returns the underlying Gtk.GLArea. Used by WebGLRenderingContext for GLSL version detection. */
+    getGlArea(): Gtk.GLArea;
     /**
-     * Returns the content of the current canvas as an image that you can use as a source for another canvas or an HTML element.
-     * @param _type The standard MIME type for the image format to return. If you do not specify this parameter, the default value is a PNG format image.
+     * Returns a WebGL rendering context backed by the underlying Gtk.GLArea.
+     * 'webgl' and 'experimental-webgl' return a WebGLRenderingContext (WebGL 1.0).
+     * 'webgl2' returns a WebGL2RenderingContext (WebGL 2.0).
+     * Other context types emit a warning and return null.
      */
-    toDataURL(_type?: string, _quality?: any): string;
-    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
-    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    getContext(contextId: string, options?: any): any;
 }
-export { GjsifyHTMLCanvasElement as HTMLCanvasElement };