@gtkx/ffi 0.6.0 → 0.7.0

package/dist/generated/adw/spinner-paintable.js

@@ -1,5 +1,6 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
 /**
  * A paintable showing a loading spinner.
  *
@@ -84,6 +85,270 @@ export class SpinnerPaintable extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Compute a concrete size for the `GdkPaintable`.
+     *
+     * Applies the sizing algorithm outlined in the
+     * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+     * to the given @paintable. See that link for more details.
+     *
+     * It is not necessary to call this function when both `specified_width` and `specified_height` are known, but it is useful to call this
+     * function in GtkWidget:measure implementations to compute the
+     * other dimension when only one dimension is given.
+     * @param specifiedWidth - the width `paintable` could be drawn into or
+     * @param specifiedHeight - the height `paintable` could be drawn into or
+     * @param defaultWidth - the width `paintable` would be drawn into if
+     * @param defaultHeight - the height `paintable` would be drawn into if
+     * @param concreteWidth - will be set to the concrete width computed
+     * @param concreteHeight - will be set to the concrete height computed
+     */
+    computeConcreteSize(specifiedWidth, specifiedHeight, defaultWidth, defaultHeight, concreteWidth, concreteHeight) {
+        call("libadwaita-1.so.0", "gdk_paintable_compute_concrete_size", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: specifiedWidth,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: specifiedHeight,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: defaultWidth,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: defaultHeight,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                value: concreteWidth,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                value: concreteHeight,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Gets an immutable paintable for the current contents displayed by @paintable.
+     *
+     * This is useful when you want to retain the current state of an animation,
+     * for example to take a screenshot of a running animation.
+     *
+     * If the `paintable` is already immutable, it will return itself.
+     */
+    getCurrentImage() {
+        const ptr = call("libadwaita-1.so.0", "gdk_paintable_get_current_image", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getInterface(ptr, Gdk.Paintable);
+    }
+    /**
+     * Get flags for the paintable.
+     *
+     * This is oftentimes useful for optimizations.
+     *
+     * See [flags@Gdk.PaintableFlags] for the flags and what they mean.
+     */
+    getFlags() {
+        return call("libadwaita-1.so.0", "gdk_paintable_get_flags", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+     *
+     * The aspect ratio is the width divided by the height, so a value of 0.5
+     * means that the `paintable` prefers to be displayed twice as high as it
+     * is wide. Consumers of this interface can use this to preserve aspect
+     * ratio when displaying the paintable.
+     *
+     * This is a purely informational value and does not in any way limit the
+     * values that may be passed to [method@Gdk.Paintable.snapshot].
+     *
+     * Usually when a `paintable` returns nonzero values from
+     * [method@Gdk.Paintable.get_intrinsic_width] and
+     * [method@Gdk.Paintable.get_intrinsic_height] the aspect ratio
+     * should conform to those values, though that is not required.
+     *
+     * If the `paintable` does not have a preferred aspect ratio,
+     * it returns 0. Negative values are never returned.
+     */
+    getIntrinsicAspectRatio() {
+        return call("libadwaita-1.so.0", "gdk_paintable_get_intrinsic_aspect_ratio", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "float", size: 64 });
+    }
+    /**
+     * Gets the preferred height the `paintable` would like to be displayed at.
+     *
+     * Consumers of this interface can use this to reserve enough space to draw
+     * the paintable.
+     *
+     * This is a purely informational value and does not in any way limit the
+     * values that may be passed to [method@Gdk.Paintable.snapshot].
+     *
+     * If the `paintable` does not have a preferred height, it returns 0.
+     * Negative values are never returned.
+     */
+    getIntrinsicHeight() {
+        return call("libadwaita-1.so.0", "gdk_paintable_get_intrinsic_height", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Gets the preferred width the `paintable` would like to be displayed at.
+     *
+     * Consumers of this interface can use this to reserve enough space to draw
+     * the paintable.
+     *
+     * This is a purely informational value and does not in any way limit the
+     * values that may be passed to [method@Gdk.Paintable.snapshot].
+     *
+     * If the `paintable` does not have a preferred width, it returns 0.
+     * Negative values are never returned.
+     */
+    getIntrinsicWidth() {
+        return call("libadwaita-1.so.0", "gdk_paintable_get_intrinsic_width", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Called by implementations of `GdkPaintable` to invalidate their contents.
+     *
+     * Unless the contents are invalidated, implementations must guarantee that
+     * multiple calls of [method@Gdk.Paintable.snapshot] produce the same output.
+     *
+     * This function will emit the [signal@Gdk.Paintable::invalidate-contents]
+     * signal.
+     *
+     * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+     * it must not call this function.
+     */
+    invalidateContents() {
+        call("libadwaita-1.so.0", "gdk_paintable_invalidate_contents", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Called by implementations of `GdkPaintable` to invalidate their size.
+     *
+     * As long as the size is not invalidated, `paintable` must return the same
+     * values for its intrinsic width, height and aspect ratio.
+     *
+     * This function will emit the [signal@Gdk.Paintable::invalidate-size]
+     * signal.
+     *
+     * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+     * it must not call this function.
+     */
+    invalidateSize() {
+        call("libadwaita-1.so.0", "gdk_paintable_invalidate_size", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Snapshots the given paintable with the given `width` and @height.
+     *
+     * The paintable is drawn at the current (0,0) offset of the @snapshot.
+     * If `width` and `height` are not larger than zero, this function will
+     * do nothing.
+     * @param snapshot - a `GdkSnapshot` to snapshot to
+     * @param width - width to snapshot in
+     * @param height - height to snapshot in
+     */
+    snapshot(snapshot, width, height) {
+        call("libadwaita-1.so.0", "gdk_paintable_snapshot", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: snapshot?.id ?? snapshot,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: width,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: height,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Snapshots the paintable with the given colors.
+     *
+     * If less than 4 colors are provided, GTK will pad the array with default
+     * colors.
+     * @param snapshot - a `GdkSnapshot` to snapshot to
+     * @param width - width to snapshot in
+     * @param height - height to snapshot in
+     * @param colors - a pointer to an array of colors
+     * @param nColors - The number of colors
+     */
+    snapshotSymbolic(snapshot, width, height, colors, nColors) {
+        call("libadwaita-1.so.0", "gtk_symbolic_paintable_snapshot_symbolic", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: snapshot?.id ?? snapshot,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: width,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: height,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "boxed",
+                        innerType: "GdkRGBA",
+                        lib: "libadwaita-1.so.0",
+                    },
+                },
+                value: colors,
+            },
+            {
+                type: { type: "int", size: 64, unsigned: true },
+                value: nColors,
+            },
+        ], { type: "undefined" });
+    }
     connect(signal, handler, after = false) {
         const selfType = { type: "gobject", borrowed: true };
         const argTypes = [selfType];

package/dist/generated/adw/split-button.d.ts

@@ -1,3 +1,4 @@
+import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import * as Gtk from "../gtk/index.js";
@@ -135,6 +136,62 @@ export declare class SplitButton extends Gtk.Widget {
      * @param useUnderline - whether an underline in the text indicates a mnemonic
      */
     setUseUnderline(useUnderline: boolean): void;
+    /**
+     * Gets the action name for @actionable.
+     */
+    getActionName(): string | null;
+    /**
+     * Gets the current target value of @actionable.
+     */
+    getActionTargetValue(): GLib.Variant | null;
+    /**
+     * Specifies the name of the action with which this widget should be
+     * associated.
+     *
+     * If `action_name` is %NULL then the widget will be unassociated from
+     * any previous action.
+     *
+     * Usually this function is used when the widget is located (or will be
+     * located) within the hierarchy of a `GtkApplicationWindow`.
+     *
+     * Names are of the form “win.save” or “app.quit” for actions on the
+     * containing [class@ApplicationWindow] or its associated [class@Application],
+     * respectively. This is the same form used for actions in the [class@Gio.Menu]
+     * associated with the window.
+     * @param actionName - an action name
+     */
+    setActionName(actionName?: string | null): void;
+    /**
+     * Sets the target value of an actionable widget.
+     *
+     * If `target_value` is %NULL then the target value is unset.
+     *
+     * The target value has two purposes. First, it is used as the parameter
+     * to activation of the action associated with the `GtkActionable` widget.
+     * Second, it is used to determine if the widget should be rendered as
+     * “active” — the widget is active if the state is equal to the given target.
+     *
+     * Consider the example of associating a set of buttons with a [iface@Gio.Action]
+     * with string state in a typical “radio button” situation. Each button
+     * will be associated with the same action, but with a different target
+     * value for that action. Clicking on a particular button will activate
+     * the action with the target of that button, which will typically cause
+     * the action’s state to change to that value. Since the action’s state
+     * is now equal to the target value of the button, the button will now
+     * be rendered as active (and the other buttons, with different targets,
+     * rendered inactive).
+     * @param targetValue - a [struct@GLib.Variant] to set as the target value
+     */
+    setActionTargetValue(targetValue?: GLib.Variant | null): void;
+    /**
+     * Sets the action-name and associated string target value of an
+     * actionable widget.
+     *
+     * `detailed_action_name` is a string in the format accepted by
+     * [func@Gio.Action.parse_detailed_name].
+     * @param detailedActionName - the detailed action name
+     */
+    setDetailedActionName(detailedActionName: string): void;
     connect(signal: "activate", handler: (self: SplitButton) => void, after?: boolean): number;
     connect(signal: "clicked", handler: (self: SplitButton) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: SplitButton, pspec: GObject.ParamSpec) => void, after?: boolean): number;

package/dist/generated/adw/split-button.js

@@ -1,4 +1,4 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getBoxed, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
 import * as Gtk from "../gtk/index.js";
 /**
  * A combined button and dropdown widget.
@@ -387,6 +387,124 @@ export class SplitButton extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the action name for @actionable.
+     */
+    getActionName() {
+        return call("libadwaita-1.so.0", "gtk_actionable_get_action_name", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "string", borrowed: true });
+    }
+    /**
+     * Gets the current target value of @actionable.
+     */
+    getActionTargetValue() {
+        const ptr = call("libadwaita-1.so.0", "gtk_actionable_get_action_target_value", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GVariant",
+            lib: "libadwaita-1.so.0",
+        });
+        if (ptr === null)
+            return null;
+        return getBoxed(ptr, "GVariant");
+    }
+    /**
+     * Specifies the name of the action with which this widget should be
+     * associated.
+     *
+     * If `action_name` is %NULL then the widget will be unassociated from
+     * any previous action.
+     *
+     * Usually this function is used when the widget is located (or will be
+     * located) within the hierarchy of a `GtkApplicationWindow`.
+     *
+     * Names are of the form “win.save” or “app.quit” for actions on the
+     * containing [class@ApplicationWindow] or its associated [class@Application],
+     * respectively. This is the same form used for actions in the [class@Gio.Menu]
+     * associated with the window.
+     * @param actionName - an action name
+     */
+    setActionName(actionName) {
+        call("libadwaita-1.so.0", "gtk_actionable_set_action_name", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the target value of an actionable widget.
+     *
+     * If `target_value` is %NULL then the target value is unset.
+     *
+     * The target value has two purposes. First, it is used as the parameter
+     * to activation of the action associated with the `GtkActionable` widget.
+     * Second, it is used to determine if the widget should be rendered as
+     * “active” — the widget is active if the state is equal to the given target.
+     *
+     * Consider the example of associating a set of buttons with a [iface@Gio.Action]
+     * with string state in a typical “radio button” situation. Each button
+     * will be associated with the same action, but with a different target
+     * value for that action. Clicking on a particular button will activate
+     * the action with the target of that button, which will typically cause
+     * the action’s state to change to that value. Since the action’s state
+     * is now equal to the target value of the button, the button will now
+     * be rendered as active (and the other buttons, with different targets,
+     * rendered inactive).
+     * @param targetValue - a [struct@GLib.Variant] to set as the target value
+     */
+    setActionTargetValue(targetValue) {
+        call("libadwaita-1.so.0", "gtk_actionable_set_action_target_value", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "GVariant",
+                    lib: "libadwaita-1.so.0",
+                },
+                value: targetValue?.id ?? targetValue,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the action-name and associated string target value of an
+     * actionable widget.
+     *
+     * `detailed_action_name` is a string in the format accepted by
+     * [func@Gio.Action.parse_detailed_name].
+     * @param detailedActionName - the detailed action name
+     */
+    setDetailedActionName(detailedActionName) {
+        call("libadwaita-1.so.0", "gtk_actionable_set_detailed_action_name", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: detailedActionName,
+            },
+        ], { type: "undefined" });
+    }
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };

package/dist/generated/adw/spring-animation.js

@@ -1,4 +1,4 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getBoxed, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
 import { Animation } from "./animation.js";
 /**
  * A spring-based [class@Animation].
@@ -190,7 +190,7 @@ export class SpringAnimation extends Animation {
             innerType: "AdwSpringParams",
             lib: "libadwaita-1.so.0",
         });
-        return getObject(ptr);
+        return getBoxed(ptr, "AdwSpringParams");
     }
     /**
      * Gets the value `self` will animate from.

package/dist/generated/adw/spring-params.js

@@ -1,4 +1,4 @@
-import { call, getObject, registerType } from "@gtkx/ffi";
+import { call, getObject, getBoxed, registerType } from "@gtkx/ffi";
 /**
  * Physical parameters of a spring for [class@SpringAnimation].
  *
@@ -165,7 +165,7 @@ export class SpringParams {
             innerType: "AdwSpringParams",
             lib: "libadwaita-1.so.0",
         });
-        return getObject(ptr);
+        return getBoxed(ptr, "AdwSpringParams");
     }
     /**
      * Decreases the reference count of @self.

package/dist/generated/adw/squeezer.d.ts

@@ -166,6 +166,15 @@ export declare class Squeezer extends Gtk.Widget {
      * @param yalign - the new alignment value
      */
     setYalign(yalign: number): void;
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
+    getOrientation(): Gtk.Orientation;
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
+    setOrientation(orientation: Gtk.Orientation): void;
     connect(signal: "notify", handler: (self: Squeezer, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/adw/squeezer.js

@@ -1,4 +1,4 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
 import * as Gtk from "../gtk/index.js";
 /**
  * A best fit container.
@@ -119,7 +119,7 @@ export class Squeezer extends Gtk.Widget {
                 value: this.id,
             },
         ], { type: "gobject", borrowed: true });
-        return getObject(ptr);
+        return getInterface(ptr, Gtk.SelectionModel);
     }
     /**
      * Gets the switch threshold policy for @self.
@@ -383,6 +383,33 @@ export class Squeezer extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
+    getOrientation() {
+        return call("libadwaita-1.so.0", "gtk_orientable_get_orientation", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
+    setOrientation(orientation) {
+        call("libadwaita-1.so.0", "gtk_orientable_set_orientation", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: orientation,
+            },
+        ], { type: "undefined" });
+    }
     connect(signal, handler, after = false) {
         const selfType = { type: "gobject", borrowed: true };
         const argTypes = [selfType];

package/dist/generated/adw/status-page.js

@@ -1,4 +1,5 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import * as Gdk from "../gdk/index.js";
 import * as Gtk from "../gtk/index.js";
 /**
  * A page used for empty/error states and similar use-cases.
@@ -92,7 +93,7 @@ export class StatusPage extends Gtk.Widget {
         ], { type: "gobject", borrowed: true });
         if (ptr === null)
             return null;
-        return getObject(ptr);
+        return getInterface(ptr, Gdk.Paintable);
     }
     /**
      * Gets the title for @self.

package/dist/generated/adw/style-manager.js

@@ -1,4 +1,4 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getBoxed, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 /**
  * A class for managing application-wide styling.
@@ -97,7 +97,7 @@ export class StyleManager extends GObject.GObject {
             innerType: "GdkRGBA",
             lib: "libadwaita-1.so.0",
         });
-        return getObject(ptr);
+        return getBoxed(ptr, "GdkRGBA");
     }
     /**
      * Gets the requested application color scheme.

package/dist/generated/adw/swipe-tracker.d.ts

@@ -1,6 +1,7 @@
 import { NavigationDirection } from "./enums.js";
 import { Swipeable } from "./swipeable.js";
 import * as GObject from "../gobject/index.js";
+import * as Gtk from "../gtk/index.js";
 export declare class SwipeTracker extends GObject.GObject {
     static readonly glibTypeName: string;
     /**
@@ -94,6 +95,15 @@ export declare class SwipeTracker extends GObject.GObject {
      * @param delta - the position delta
      */
     shiftPosition(delta: number): void;
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
+    getOrientation(): Gtk.Orientation;
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
+    setOrientation(orientation: Gtk.Orientation): void;
     connect(signal: "begin-swipe", handler: (self: SwipeTracker) => void, after?: boolean): number;
     connect(signal: "end-swipe", handler: (self: SwipeTracker, velocity: number, to: number) => void, after?: boolean): number;
     connect(signal: "prepare", handler: (self: SwipeTracker, direction: NavigationDirection) => void, after?: boolean): number;

package/dist/generated/adw/swipe-tracker.js

@@ -1,4 +1,5 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { Swipeable } from "./swipeable.js";
 import * as GObject from "../gobject/index.js";
 /**
  * A swipe tracker used in [class@Carousel], [class@NavigationView] and
@@ -131,7 +132,7 @@ export class SwipeTracker extends GObject.GObject {
                 value: this.id,
             },
         ], { type: "gobject", borrowed: true });
-        return getObject(ptr);
+        return getInterface(ptr, Swipeable);
     }
     /**
      * Gets whether to allow swiping past the last available snap point.
@@ -286,6 +287,33 @@ export class SwipeTracker extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
+    getOrientation() {
+        return call("libadwaita-1.so.0", "gtk_orientable_get_orientation", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
+    setOrientation(orientation) {
+        call("libadwaita-1.so.0", "gtk_orientable_set_orientation", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: orientation,
+            },
+        ], { type: "undefined" });
+    }
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };